格式化輸入輸出
從終端獲取用戶的輸入，go提供了三個(gè)函數(shù)：
//格式化輸入，空格作為分隔符，占位符和格式化輸出一致
fmt.Scanf(format string, a ...interface{})
//從終端獲取用戶輸入，存儲在Scan的參數(shù)里，空格和換行符作為分隔符
fmt.Scan(a ...interface{})
//從終端獲取用戶輸入，存儲在Scanln的參數(shù)里，空格作為分隔符，遇到換行符結(jié)束
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
同時(shí)還可以從字符串中獲取輸入，跟上面的差不多:
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{})
格式化輸入輸出原理
終端其實(shí)是一個(gè)文件，跟終端相關(guān)的實(shí)例都定義在os包里面，主要有:
os.Stdin 標(biāo)準(zhǔn)輸入的文件實(shí)例，類型為*File
os.Stdout 標(biāo)準(zhǔn)輸出的文件實(shí)例，類型為*File
os.Stderr 標(biāo)準(zhǔn)錯(cuò)誤輸出的文件實(shí)例，類型為*File
我們可以看看os包里面的源碼,可以看到這三項(xiàng)分別對于了終端的三個(gè)操作。
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封裝來進(jìn)行輸出。
func Println(a ...interface{}) (n int, err error) {
return Fprintln(os.Stdout, a...)
}
因?yàn)檫@三項(xiàng)都是文件類型，所以我們也可以使用文件來操作終端。比如終端讀取就可以使用
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，那么我們也可以直接使用文件格式來進(jìn)行格式化輸入
//從文件格式化輸入，空格作為分隔符，占位符和格式化輸出一致
fmt.Fscanf(r io.Reader, format string, a ...interface{})
//從文件獲取用戶輸入，存儲在Scan的參數(shù)里，空格和換行符作為分隔符
fmt.Fscan(r io.Reader, a ...interface{})
//從文件獲取用戶輸入，存儲在Scanln的參數(shù)里，空格作為分隔符，遇到換行符結(jié)束
fmt.Fscanln(r io.Reader, a ...interface{})
fmt.Fprintln(w io.Writer, a ...interface{})
這個(gè)跟之前的Scan而已少了一層封裝，就不多做贅述了。
bufio讀取帶空格的字符串
文件本身的讀取，性能是非常差的。所以我們再文件讀取的時(shí)候加上一層緩存，可以提升文件讀取時(shí)的性能。
在go中，是通過bufio來進(jìn)行緩存讀寫，之前我們的終端也說了是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
命令行參數(shù)處理
命令行參數(shù)都在os.Args切片里面，如果用戶通過命令行傳遞參數(shù)，那么參數(shù)就被存在os.Args，os.Args第0個(gè)是文件名。
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)
}
}
}
// 參數(shù)之間使用空格來進(jìn)行分隔。
使用flag包來寫命令行參數(shù)應(yīng)用:
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"
也有比較好的三方庫對命令行進(jìn)行了很好的封裝，github.com/urfave/cli
