格式化输入输出
从终端获取用户的输入，go提供了三个函数：
//格式化输入，空格作为分隔符，占位符和格式化输出一致
fmt.Scanf(format string, a ...interface{})
//从终端获取用户输入，存储在Scan的参数里，空格和换行符作为分隔符
fmt.Scan(a ...interface{})
//从终端获取用户输入，存储在Scanln的参数里，空格作为分隔符，遇到换行符结束
fmt.Scanln(a ...interface{})
例子：
package main
import (
"fmt"
)
func main() {
scanf()
//scan()
//scanln()
}
func scanf() {
var a string
fmt.Scanf("%s", &a)
fmt.Println("this is input:", a)
}
// go run main.go
// 123
// this is input: 123
func scan() {
var b int
var c int
fmt.Scan(&b, &c)
fmt.Println("this is input:", b, c)
}
// go run main.go
// 1
// 2
// this is input: 1 2
func scanln() {
var d int
var e int
fmt.Scanln(&d, &e)
fmt.Println("this is input:", d, e)
}
// go run main.go
// 12 23
// this is input: 12 23
同时还可以从字符串中获取输入，跟上面的差不多:
fmt.Sscanf(str string, format string, a ...interface{})
fmt.Sscan(str string, a ...interface{})
fmt.Sscanln(str string, a ...interface{})
例子:
package main
import (
"fmt"
)
func main() {
sscanfln()
}
func sscanfln() {
var a string
str := "12345"
fmt.Sscanf(str, "%s", &a)
fmt.Println("this is Sscanf input:", a)
var b int
str = "12345 333"
fmt.Sscan(str, &a, &b)
fmt.Println("this is Sscan input:", a, b)
fmt.Sscanln(str, &a, &b)
fmt.Println("this is Sscanln input:", a, b)
}
// go run main.go
// this is Sscanf input: 12345
// this is Sscan input: 12345 333
// this is Sscanln input: 12345 333
格式化输出:
fmt.Printlf(format string, a ...interface{})
fmt.Print(a ...interface{})
fmt.Println(a ...interface{})
格式化并返回字符串
fmt.Sprintlf(format string, a ...interface{})
fmt.Sprint(a ...interface{})
fmt.Sprintln(a ...interface{})
格式化输入输出原理
终端其实是一个文件，跟终端相关的实例都定义在os包里面，主要有:
os.Stdin 标准输入的文件实例，类型为*File
os.Stdout 标准输出的文件实例，类型为*File
os.Stderr 标准错误输出的文件实例，类型为*File
我们可以看看os包里面的源码,可以看到这三项分别对于了终端的三个操作。
var (
Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)
在go中所有的输入输出都是封装os包的，比如我们常用的fmt.Println()，就是os.Stdout封装来进行输出。
func Println(a ...interface{}) (n int, err error) {
return Fprintln(os.Stdout, a...)
}
因为这三项都是文件类型，所以我们也可以使用文件来操作终端。比如终端读取就可以使用
Fiel.Read(b []byte)
终端输出：
File.Write(b []byte)
File.WriteString(str string)
例子：
package main
import (
"os"
)
func main() {
var buf [16]byte
os.Stdin.Read(buf[:])
// fmt.Println(string(buf[:]))
os.Stdout.WriteString(string(buf[:]))
}
//go run main.go
//hello
//hello
既然终端的操作类型是File，那么我们也可以直接使用文件格式来进行格式化输入
//从文件格式化输入，空格作为分隔符，占位符和格式化输出一致
fmt.Fscanf(r io.Reader, format string, a ...interface{})
//从文件获取用户输入，存储在Scan的参数里，空格和换行符作为分隔符
fmt.Fscan(r io.Reader, a ...interface{})
//从文件获取用户输入，存储在Scanln的参数里，空格作为分隔符，遇到换行符结束
fmt.Fscanln(r io.Reader, a ...interface{})
fmt.Fprintln(w io.Writer, a ...interface{})
这个跟之前的Scan而已少了一层封装，就不多做赘述了。
bufio读取带空格的字符串
文件本身的读取，性能是非常差的。所以我们再文件读取的时候加上一层缓存，可以提升文件读取时的性能。
在go中，是通过bufio来进行缓存读写，之前我们的终端也说了是File，所以我们也可以使用bufio来读取。
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
var str string
reader := bufio.NewReader(os.Stdin)
fmt.Println("Please input:")
str, err := reader.ReadString('\n')
if err == nil {
fmt.Println(str)
}
}
//go run main.go
//Please input:
//this is hello golang
//this is hello golang
命令行参数处理
命令行参数都在os.Args切片里面，如果用户通过命令行传递参数，那么参数就被存在os.Args，os.Args第0个是文件名。
package main
import (
"fmt"
"os"
)
func main() {
fmt.Println("args[0]:", os.Args[0])
if len(os.Args) > 1 {
for index, v := range os.Args {
if index == 0 {
continue
}
fmt.Printf("args[%d]: %s\n", index, v)
}
}
}
// 参数之间使用空格来进行分隔。
使用flag包来写命令行参数应用:
package main
import (
"flag"
"fmt"
)
func main() {
var aoo string
flag.StringVar(&aoo, "a", "A", "a is name")
flag.Parse()
fmt.Println(aoo)
}
// go run main.go -a "hello"
也有比较好的三方库对命令行进行了很好的封装，github.com/urfave/cli
