go-IO操做(一)

格式化輸入輸出

從終端獲取用戶的輸入，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