【原创】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!\n", 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('\n')
if err == nil {
fmt.Printf("The input was: %s\n", 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)
}
