读取用户的输入

从键盘和标准输入 os.Stdin 读取输入，最简单的办法是使用 fmt 包提供的 Scan… 和 Sscan… 开头的函数

看如下的程序

func test1() {
	var s1, s2 string
	fmt.Scanf("%s,%s", &s1, &s2)
	fmt.Println(s1, s2)
	input := "hello,world"
	format := "%s,%s"
	fmt.Sscanf(input, format, &s1, &s2)
	fmt.Println(s1, s2)
}

也可以使用bufio包提供的缓冲读取器来读取数据，如下例子所示

func test2() {
	inputReader := bufio.NewReader(os.Stdin)
	input, err := inputReader.ReadString(' ')
	if err != nil {
		fmt.Println("error")
		return
	}
	fmt.Println(input)
}

inputReader 是一个指向 bufio.Reader 的指针。inputReader := bufio.NewReader(os.Stdin) 这行代码，将会创建一个读取器，并将其与标准输入绑定。

bufio.NewReader() 构造函数的签名为：func NewReader(rd io.Reader) *Reader

该函数的实参可以是满足 io.Reader 接口的任意对象，函数返回一个新的带缓冲的 io.Reader 对象，它将从指定读取器（例如 os.Stdin）读取内容。

返回的读取器对象提供一个方法 ReadString(delim byte)，该方法从输入中读取内容，直到碰到 delim 指定的字符，然后将读取到的内容连同 delim 字符一起放到缓冲区。

ReadString 返回读取到的字符串，如果碰到错误则返回 nil。如果它一直读到文件结束，则返回读取到的字符串和 io.EOF。如果读取过程中没有碰到 delim 字符，将返回错误 err != nil

文件读写

读文件

在 Go 语言中，文件使用指向 os.File 类型的指针来表示的，也叫做文件句柄

看如下的代码

func test3() {
	inputFile, fileErr := os.Open("test.dat")
	if fileErr != nil {
		fmt.Println("open fail error")
	}
	defer inputFile.Close()

	inputReader := bufio.NewReader(inputFile)
	for {
		inputString, inputErr := inputReader.ReadString('#')
		if inputErr == io.EOF {
			return
		}
		fmt.Println(inputString)
	}
}

写文件

写文件的逻辑和之前类似，有如下代码

func test4() {
	// 获取到文件的句柄
	outfile, outerror := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)
	if outerror != nil {
		fmt.Println("create fail")
		return
	}
	defer outfile.Close()

	// 用文件的句柄初始化写对象
	outWriter := bufio.NewWriter(outfile)

	str := "hello world\n"

	for i := 0; i < 10; i++ {
		// 利用写对象，向文件当中写数据
		_, err := outWriter.WriteString(str)
		if err != nil {
			fmt.Println("error")
			return
		}
		fmt.Println("write success: ", str)
	}

	err := outWriter.Flush()
	if err != nil {
		fmt.Println("error")
		return
	}
}

文件拷贝

如何拷贝一个文件到另一个文件？最简单的方式就是使用 io 包：

// filecopy.go
package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	CopyFile("target.txt", "source.txt")
	fmt.Println("Copy done!")
}

func CopyFile(dstName, srcName string) (written int64, err error) {
	src, err := os.Open(srcName)
	if err != nil {
		return
	}
	defer src.Close()

	dst, err := os.Create(dstName)
	if err != nil {
		return
	}
	defer dst.Close()

	return io.Copy(dst, src)
}

注意 defer 的使用：当打开 dst 文件时发生了错误，那么 defer 仍然能够确保 src.Close() 执行。如果不这么做，src 文件会一直保持打开状态并占用资源。

io包中接口的概念

func test5() {
	fmt.Fprintf(os.Stdout, "%s\n", "hello go fprintf")
	buf := bufio.NewWriter(os.Stdout)
	fmt.Fprintf(buf, "%s\n", "hello newwirter")
	buf.Flush()
}

下面是 fmt.Fprintf() 函数的实际签名

func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

不是写入一个文件，而是写入一个 io.Writer 接口类型的变量，下面是 Writer 接口在 io 包中的定义

type Writer interface {
	Write(p []byte) (n int, err error)
}

fmt.Fprintf() 依据指定的格式向第一个参数内写入字符串，第一个参数必须实现了 io.Writer 接口。Fprintf() 能够写入任何类型，只要其实现了 Write 方法，包括 os.Stdout，文件（例如 os.File），管道，网络连接，通道等等。同样地，也可以使用 bufio 包中缓冲写入。bufio 包中定义了 type Writer struct{…}

JSON 数据格式

编码

数据结构要在网络中传输或保存到文件，就必须对其编码和解码；目前存在很多编码格式：JSON，XML，gob，Google 缓冲协议等等。Go 语言支持所有这些编码格式

结构可能包含二进制数据，如果将其作为文本打印，那么可读性是很差的。另外结构内部可能包含匿名字段，而不清楚数据的用意

通过把数据转换成纯文本，使用命名的字段来标注，让其具有可读性。这样的数据格式可以通过网络传输，而且是与平台无关的，任何类型的应用都能够读取和输出，不与操作系统和编程语言的类型相关

比如给出如下的代码，主要会进行一些json数据的编码或解码

json.Marshal() 的函数签名是 func Marshal(v interface{}) ([]byte, error)，下面是数据编码后的 JSON 文本（实际上是一个 []byte）

出于安全考虑，在 web 应用中最好使用 json.MarshalforHTML() 函数，其对数据执行 HTML 转码，所以文本可以被安全地嵌在 HTML

解码任意的数据：

json 包使用 map[string]interface{} 和 []interface{} 储存任意的 JSON 对象和数组；其可以被反序列化为任何的 JSON blob 存储到接口值中。

来看这个 JSON 数据，被存储在变量 b 中：

b := []byte(`{"Name": "Wednesday", "Age": 6, "Parents": ["Gomez", "Morticia"]}`)

不用理解这个数据的结构，我们可以直接使用 Unmarshal() 把这个数据编码并保存在接口值中：

var f interface{}
err := json.Unmarshal(b, &f)

f 指向的值是一个 map，key 是一个字符串，value 是自身存储作为空接口类型的值：

map[string]interface{} {
	"Name": "Wednesday",
	"Age":  6,
	"Parents": []interface{} {
		"Gomez",
		"Morticia",
	},
}

要访问这个数据，我们可以使用类型断言

m := f.(map[string]interface{})

我们可以通过 for range 语法和 type switch 来访问其实际类型：

for k, v := range m {
	switch vv := v.(type) {
	case string:
		fmt.Println(k, "is string", vv)
	case int:
		fmt.Println(k, "is int", vv)

	case []interface{}:
		fmt.Println(k, "is an array:")
		for i, u := range vv {
			fmt.Println(i, u)
		}
	default:
		fmt.Println(k, "is of a type I don’t know how to handle")
	}
}

通过这种方式，你可以处理未知的 JSON 数据，同时可以确保类型安全