【原创】go语言学习（十四）IO操作1

目录：

• 格式化输入
• 格式化输出
• 终端输入输出背后的原理理
• bufio包的使用
• 命令行参数处理理和urfave/cli使用

格式化输入

1、从终端获取⽤用户的输入

格式化输入

fmt.Scan(a …interface{}): 从终端获取⽤用户输入，存储在Scanln中的参数里，空格和换行符作为分隔符

fmt.Scanf(format string, a…interface{}): 格式化输入，空格作为分隔符，占位符和格式化输出一致

fmt.Scanln(a …interface{}): 从终端获取⽤用户输入，存储在Scanln中的参数里，空格作为分隔符，遇到换行符结束

2、终端操作实例

package main
import (
    "fmt"
)
var (
    firstName, lastName, s string
    i int
    f float32
    input = "56.12 / 5212 / Go"
    format = "%f / %d / %s"
)
func main() {
    fmt.Println("Please enter your full name: ")
    fmt.Scanln(&firstName, &lastName)
    // fmt.Scanf("%s %s", &firstName, &lastName)
    fmt.Printf("Hi %s %s!
", firstName, lastName) // Hi Chris Naegels
    fmt.Sscanf(input, format, &f, &i, &s)
    fmt.Println("From the string we read: ", f, i, s)
}

　　

3、从字符串中获取输入

fmt.Sscanf(str, format string, a…interface{}): 格式化输入，空格作为分隔符，占位符和格式化输出一致

fmt.Sscan(str string, a …interface{}): 从终端获取⽤用户输入，存储在Scanln中的参数⾥里里，空格和换行符作为分隔符

fmt.Sscanln(str string, a …interface{}): 从终端获取⽤用户输入，存储在Scanln中的参数⾥里里，空格作为分隔符，遇到换行符结束

格式化输出

1、格式化输出

fmt.Println(a …interface{}): 把零个或多个变量量打印到终端， 并换⾏行行
fmt.Printf(format string, a…interface{}): 格式化输出，并打印到终端
fmt.Print(a …interface{}): 把零个或多个变量量打印到终端

2、格式化并返回字符串

fmt.Sprintln(a …interface{}): 把零个或多个变量量按空格进⾏行行格式化并换⾏行行，返回字符串串
fmt.Sprintf(format string, a…interface{}): 格式化并返回字符串串
fmt.Sprint(a …interface{}): 把零个或多个变量量按空格进⾏行行格式化，返回字符串串

终端输入输出背后的原理理

1、终端其实是一个文件

os.Stdin：标准输⼊入的⽂文件实例例，类型为*File
os.Stdout：标准输出的⽂文件实例例，类型为*File
os.Stderr：标准错误输出的⽂文件实例例，类型为*File

2、以文件的方式操作终端

File.Read(b []byte)
File.Write(b []byte)
终端读取：
终端输出：
File.WriteString(str string)

3、从文件获取输入

格式化输入
fmt.Fscan(file, a …interface{}): 从文件获取用户输入，存储在Scanln中的参数里，空格和换行符作为分隔符

fmt.Fscanf(file, format string, a…interface{}): 从文件格式化输入，空格作为分隔符，占位符和 格式化输出一致

fmt.Fscanln(file, a …interface{}): 从文件获取用户输入，存储在Scanln中的参数里，空格作为分隔符，遇到换行符结束

4、格式化输出到文件中
格式化输出
fmt.Fprintln(file, a …interface{}): 把零个或多个变量量写入到文件中， 并换行
fmt.Fprintf(file, format string, a…interface{}): 格式化输出，并写⼊入到文件中
fmt.Fprint(file, a …interface{}): 把零个或多个变量量写入到文件

bufio包的使用

1、带缓冲区的读写

package main
import (
    "bufio"
    "fmt"
    "os"
)
var inputReader *bufio.Reader
var input string
var err error
func main() {
    inputReader = bufio.NewReader(os.Stdin)
    fmt.Println("Please enter some input: ")
    input, err = inputReader.ReadString('
')
    if err == nil {
        fmt.Printf("The input was: %s
", input)
    }
}

　　

命令行参数处理理和urfave/cli使用

1、os.Args命令行参数的切片

package main
import (
    "fmt"
    "os"
)
func main() {
    who := "Alice"
    if len(os.Args) > 1 {
        who += strings.Join(os.Args[1:], " ")
    }
    fmt.Println("Good Morning", who)
}

　　

2、使⽤用flag包获取命令行参数

package main
import (
    "flag"
    "fmt"
)
func parseArgs() {
    flag.IntVar(&length, "l", 16, "-l ⽣成密码的长度")
    flag.StringVar(&charset, "t", "num",
        `-t 制定密码⽣成的字符集,
        num:只使⽤数字[0-9],
        char:只使⽤英⽂字母[a-zA-Z],
        mix: 使⽤数字和字母，
        advance:使⽤数字、字母以及特殊字符`)
    flag.Parse()
}
func main() {
    parseArgs()
}        

　　

3、urfave/cli包的使用

package main
import (
    "fmt"
    "os"
    "github.com/urfave/cli"
)
func main() {
    app := cli.NewApp()
    app.Name = "greet"
    app.Usage = "fight the loneliness!"
    app.Action = func(c *cli.Context) error {
        fmt.Println("Hello friend!")
        return nil
    }
    app.Run(os.Args)
}

　　

4、获取命令行参数

package main
import (
    "fmt"
    "os"
    "github.com/urfave/cli"
)
func main() {
    app := cli.NewApp()
    app.Action = func(c *cli.Context) error {
    fmt.Printf("Hello %q", c.Args().Get(0))
        return nil
    }
    app.Run(os.Args)
}

　　

5、获取选项参数

package main
import (
    "fmt"
    "os"
    "github.com/urfave/cli"
)
func main() {
    var language string
    var recusive bool
    app := cli.NewApp()
    app.Flags = []cli.Flag{
    cli.StringFlag{
        Name: "lang, l",
        Value: "english",
        Usage: "language for the greeting",
        Destination: &language,
    },
    cli.BoolFlag{
        Name: "recusive, r",
        Usage: "recusive for the greeting",
        Destination: &recusive,
    },
}
app.Action = func(c *cli.Context) error {
    var cmd string
    if c.NArg() > 0 {
        cmd = c.Args()[0]
        fmt.Println("cmd is ", cmd)
    }
    fmt.Println("recusive is ", recusive)
    fmt.Println("language is ", language)
        return nil
    }
    app.Run(os.Args)
}