【Golang第10章：文件操作】GO语言的文件管理，go语言读文件和写文件、GO语言拷贝文件、GO语言判断文件是否存在、GO语言Json文件格式和解析

介绍

这个是在B站上看边看视频边做的笔记，这一章是Glang的文件操作

主要内容有Go语言文件管理，go语言读文件和写文件、GO语言拷贝文件、GO语言判断文件是否存在、GO语言Json文件格式和解析，GO语言如何设置命令行参数

配套视频自己去B站里面搜【go语言】，最高的播放量就是

里面的注释我写的可能不太对，欢迎大佬们指出╰(°▽°)╯

文章目录

• 介绍
• (十)、文件操作
• • 一、文件的基本介绍
  • 二、打开文件和关闭文件
  • 三、读文件操作
  • 四、写文件操作
  • • 1.基本介绍 `os.OpenFile` 函数
    • 2.基本应用实例-方式一
    • 3.基本应用实例-方式二
  • 五、判断文件是否存在
  • 六、拷贝文件
  • 七、统计字符数量
  • 八、命令行参数
  • • 1.基本介绍
    • 2.举例说明
    • 3.flag 包用来解析命令行参数
  • 九、JSON文件
  • • 1.基本介绍
    • 2. json 数据格式说明
    • 3. json 数据在线解析
    • 4. json 的序列化
    • 5. json 的反序列化
• 章节目录

(十)、文件操作

一、文件的基本介绍

• 文件的概念

  文件,对我们并不陌生,文件是数据源(保存数据的地方)的一种,比如大家经常使用的word 文档,txt 文件,excel 文件…都是文件。文件最主要的作用就是保存数据,它既可以保存一张图片,也可以保持视频,声音…

• 输入流和输出流

  

• os.File 封装所有文件相关操作，File 是一个结构体

  

  总结：后面我们操作文件，会经常使用到os.File 结构体.

二、打开文件和关闭文件

• 使用的函数和方法

  

  

• 案例

  package main
  
  import (
  	"fmt"
  	"os"
  )
  
  func main() {
  	//概念说明: file 的叫法
  	//1.file 叫file对象
  	//2.flle 叫file指针
  	//3.file叫file文件句柄
  
  	//打开文件
  	file, err := os.Open("d:/test.txt") //当前没有test.txt 文件
  
  	if err != nil {
  		fmt.Println("open file err=", err) //输出open file err= open d:/test.txt: The system cannot find the file specified.
  	}
  
  	//输出下文件，看看，文件是什么 ，重下面看出文件就是一个指针
  	fmt.Printf("file=%v\n", file) //无文件输出 file=<nil> ，有文件file=&{0xc0000da780}
  
  	//关闭文件
  	err = file.Close()
  	if err != nil {
  		fmt.Println(err)
  	}
  }
  

三、读文件操作

1. 读取文件的内容并显示在终端(带缓冲区的方式)，使用os.Open, file.Close,bufio.NewReader(),reader.ReadString 函数和方法.

代码

package main

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

func main() {

  //打开文件
  file, err := os.Open("d:/test.txt") //当前没有test.txt 文件

  if err != nil { //输出错误
  	fmt.Println("open file err=", err) //输出open file err= open d:/test.txt: The system cannot find the file specified.
  }

  //当函数退出时，要及时关闭file
  defer file.Close() //要及时关闭file句柄，否则会有内存泄漏.

  //创建一个 *Reader ,是带缓冲的 ,默认大小为4096
  reader := bufio.NewReader(file)

  //循环的读取文件的内容
  for {
  	//reader会返回2个结果str为具体内容，err为错误信息
  	str, err := reader.ReadString('\n') //使用带缓冲区，读到一个换行就结束
  	if err == io.EOF {                  //io.EOF表示文件的末尾
  		break //读到末尾后退出循环
  	}

  	//输出内容
  	fmt.Print(str) //因为默认有换行符，所以不需要Println进行换行
  }

  fmt.Println("-----文件读取结束-----")
}

2. 读取文件的内容并显示在终端(使用ioutil 一次将整个文件读入到内存中)，这种方式适用于文件不大的情况。相关方法和函数(ioutil.ReadFile)

代码

package main

import (
  "fmt"
  "io/ioutil"
)

func main() {
  //使用ioutil.ReadFile一次性将文件读取到位
  file := "d:/test.txt"

  content, err := ioutil.ReadFile(file) //只适合文件不太大的情况使用
  if err != nil {
  	fmt.Printf("red file err=%v\n", err)
  }

  //把读取道德内容显示到终端
  fmt.Printf("%v\n", content)         //输出的是byte切片,因此我们需要转换为string类型
  fmt.Printf("%v\n", string(content)) //或者fmt.Printf("%s\n", content)

  //我们没有显示的Open文件，因此也不需要显示Close文件
  //因为,文件的Open和close被封装到ReadFile函数内部

}

四、写文件操作

1.基本介绍 os.OpenFile 函数

const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
)

2.基本应用实例-方式一

1. 创建一个新文件，写入内容5 句"hello, Gardon"

   package main
   
   import (
   	"bufio"
   	"fmt"
   	"os"
   )
   
   func main() {
   	//创建一个新文件，写入内容5 句"hello, Gardon"
   	//1.打开文件 d:/adc.txt
   
   	filePath := "d:/adc.txt"
   	//打开只写模式，并且，如果不存在将创建一个新文件，Linux权限为0666
   	file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
   	if err != nil {
   		fmt.Printf("打开文件错误：%v\n", err)
   		return
   	}
   
   	//及时关闭file句柄
   	defer file.Close()
   
   	//准备写入内容5 句"hello, Gardon"
   str := "hello, Gardon\r\n" // \r\n 表示换行 ,因为有的编辑器不识别\n，所以把\n和\r都带上
   
   	//写入时，使用带缓存的 *Writer
   	writer := bufio.NewWriter(file)
   
   	for i := 0; i < 5; i++ {
   		writer.WriteString(str) //把str的内容循环5次写入缓存中
   	}
   
   	//因为writer是带缓存，因此在调用Writerstring方法时，其实
   	//内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
   	//真正写入到文件中,否则文件中会丢失数据
   	writer.Flush() //把缓存内容写入到实际文件中
   }
   

2. 打开一个存在的文件中，将原来的内容覆盖成新的内容10 句"你好，世界!"

   package main
   
   import (
   	"bufio"
   	"fmt"
   	"os"
   )
   
   //打开一个存在的文件中，将原来的内容覆盖成新的内容10 句"你好，世界!"
   func main() {
   	//1.打开文件 d:/adc.txt
   	filePath := "d:/adc.txt"
   
   	//打开只写模式，并且，把打开文件全部清除掉在写入，Linux权限为0666
   	file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0666)
   	if err != nil {
   		fmt.Printf("打开文件错误：%v\n", err)
   		return
   	}
   
   	//及时关闭file句柄
   	defer file.Close()
   
   	//准备写入内容5 句"hello, Gardon"
   	str := "你好，世界！\r\n" // \r\n 表示换行 ,因为有的编辑器不识别\n，所以把\n和\r都带上
   
   	//写入时，使用带缓存的 *Writer
   	writer := bufio.NewWriter(file)
   
   	for i := 0; i < 10; i++ {
   		writer.WriteString(str) //把str的内容循环5次写入缓存中
   	}
   
   	//因为writer是带缓存，因此在调用Writerstring方法时，其实
   	//内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
   	//真正写入到文件中,否则文件中会丢失数据
   	writer.Flush() //把缓存内容写入到实际文件中
   }
   

3. 打开一个存在的文件，在原来的内容追加内容"ABC! ENGLISH!"

   package main
   
   import (
   	"bufio"
   	"fmt"
   	"os"
   )
   
   //打开一个存在的文件，在原来的内容追加内容"ABC! ENGLISH!"
   func main() {
   	//1.打开文件 d:/adc.txt
   	filePath := "d:/adc.txt"
   
   	//打开只写模式，并且在原来的内容追加内容，Linux权限为0666
   	file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND, 0666)
   	if err != nil {
   		fmt.Printf("打开文件错误：%v\n", err)
   		return
   	}
   
   	//及时关闭file句柄
   	defer file.Close()
   
   	//准备追加内容" ABC! ENGLISH! "
   	str := "ABC! ENGLISH!\r\n" // \r\n 表示换行 ,因为有的编辑器不识别\n，所以把\n和\r都带上
   
   	//写入时，使用带缓存的 *Writer
   	writer := bufio.NewWriter(file)
   
   	for i := 0; i < 10; i++ {
   		writer.WriteString(str) //把str的内容循环10次写入缓存中
   	}
   
   	//因为writer是带缓存，因此在调用Writerstring方法时，其实
   	//内容是先写入到缓存的，所以需要调用Flush方法，将缓冲的数据
   	//真正写入到文件中,否则文件中会丢失数据
   	writer.Flush() //把缓存内容写入到实际文件中
   }
   

4. 打开一个存在的文件，将原来的内容读出显示在终端，并且追加5 句"hello,你好，世界!"

   package main
   
   import (
   	"bufio"
   	"fmt"
   	"io"
   	"os"
   )
   
   //打开一个存在的文件，将原来的内容读出显示在终端，并且追加5 句"hello,你好，世界!"
   func main() {
   	//1.打开文件 d:/adc.txt
   	filePath := "d:/adc.txt"
   
   	//打开读写模式，并且在原来的内容追加内容，Linux权限为0666
   	file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 0666)
   	if err != nil {
   		fmt.Printf("打开文件错误：%v\n", err)
   		return
   	}
   
   	//及时关闭file句柄
   	defer file.Close() //函数执行完毕后关闭file句柄
   
   	//读取原先的内容，并显示在终端==================
   	reader := bufio.NewReader(file)
   	for {
   		str, err := reader.ReadString('\n')
   		if err == io.EOF { //如果读取到文件末尾，就break退出循环
   			break
   		}
   
   		//显示到终端
   		fmt.Print(str)
   	}
   	//============================================
   
   	//准备追加内容" hello,你好，世界! "
   	str := "hello,你好，世界!\r\n"
   	writer := bufio.NewWriter(file)
   
   	for i := 0; i < 5; i++ {
   		writer.WriteString(str) //把str的内容循环5次写入缓存中
   	}
   	writer.Flush()
   }
   

3.基本应用实例-方式二

编程一个程序，将一个文件的内容，写入到另外一个文件。注：这两个文件已经存在了.

说明：使用ioutil.ReadFile / ioutil.WriteFile 完成写文件的任务.

代码：

package main

import (
	"fmt"
	"io/ioutil"
)

func main() {
	//将D:/test.txt 文件导入到 D:/abc.txt  文件

	//1.首先将D:/test.txt 内容读取到内存
	//2.将读取道德内容写入 D:/abc.txt

	file1Path := "D:/test.txt"
	file2Path := "D:/abc.txt"

	data, err := ioutil.ReadFile(file1Path) //读取文件，
	if err != nil {
		fmt.Println("文件读取错误,", err)
		return //读取文件错误，直接结束整个函数
	}

	//写入文件，你要写入的路径，读取的路径，Linux权限
	err = ioutil.WriteFile(file2Path, data, 0666)
	if err != nil {
		fmt.Println("文件写入错误,", err)
	}
}

五、判断文件是否存在

golang判断文件或文件夹是否存在的方法为使用os. Stat()函数返回的错误值进行判断: .

1. 如果返回的错误为nil,说明文件或文件夹存在
2. 如果返回的错误类型使用os.IsNotExist()判断为true,说明文件或文件夹不存在
3. 如果返回的错误为其它类型，则不确定是否在存在

package main

import (
	"fmt"
	"os"
)

func PathExists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil { //文件或目录存在
		return true, nil
	}

	//返回一个布尔值说明该错误是否表示一个文件或目录不存在。
	//ErrNotExist和一些系统调用错误会使它返回真。
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

func main() {
	filePath := "d:/abc1.txt"
	exist, err := PathExists(filePath)

	if exist {
		fmt.Println("文件存在")
	} else {
		fmt.Println("文件不存在")
		if err != nil {
			fmt.Println(err)
		}
	}
}

六、拷贝文件

说明：将一张图片/电影/mp3 拷贝到另外一个文件

使用io 包func Copy(dst Writer, src Reader) (written int64, err error)

注意: Copy 函数是io 包提供的.

package main

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

//将d盘下的test.txt拷贝到e盘下

//变量一个函数，接收2个文件路径 srcFileName   dstFileName
func CopyFile(dstFileName string, srcFileName string) (writer int64, err error) {
	srcFile, err := os.Open(srcFileName)
	if err != nil {
		fmt.Println("打开文件错误", err)
	}

	//通过srcfile，获取到 Reader
	reader := bufio.NewReader(srcFile)

	defer srcFile.Close() //完成函数后关闭srcFile

	//打开dstFileName
	dstFile1, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0666)
	if err != nil {
		fmt.Println("打开文件错误", err)
	}

	//通过writer1，获取到Writer
	writer1 := bufio.NewWriter(dstFile1)

	defer dstFile1.Close() //完成函数后关闭dstFile

	return io.Copy(writer1, reader)
}

func main() {
	//1.调用CopyFile完成文件拷贝

	srcFile := "d:/test.txt"
	dstFile := "e:/test.txt"
	CopyFile(dstFile, srcFile)
	_, err := CopyFile(dstFile, srcFile)
	if err == nil {
		fmt.Println("拷贝完成")
	} else {
		fmt.Println(err)
	}
}

七、统计字符数量

**说明：**统计一个文件中含有的英文、数字、空格及其它字符数量

代码：

package main

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

//统计一个文件中含有的英文、数字、空格及其它字符数量

//定义一个结构体，用户保存统计结果
type CharCount struct {
	ChCount    int //记录英文个数
	NumCount   int //记录数字的个数
	SpaceCount int //记录空格的个数
	OtherCount int //记录其它字符的个数
}

func main() {
	//思路:打开一个文件，创一个Reader
	//每读取一行，就去统计该行有多少个英文、数字、空格和其他字符
	//然后将结果保存到一个结构体

	fileName := "D:/test.txt"
	file, err := os.Open(fileName)
	if err != nil {
		fmt.Println("打开文件失败，", err)
		return
	}
	defer file.Close() //关闭file句柄，防止内存溢出

	//定义CharCount实例
	var count CharCount
	//创建一个Reader
	reader := bufio.NewReader(file)

	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF {
			break
		}

		//遍历str,进行统计
		for _, v := range str { //v拿到的是byte数组
			switch {
			case v >= 'a' && v <= 'z':
				fallthrough //穿透处理，强制执行后面代码，fallthrough不能用在switch的最后一个分支。
			case v >= 'A' && v <= 'Z':
				count.ChCount++
			case v == ' ' || v == '\t':
				count.SpaceCount++
			case v >= '0' && v <= '9':
				count.NumCount++
			default:
				count.OtherCount++
			}
		}
	}

	fmt.Printf("字母的个数为%v 数字的个数为%v 空格的字符为%v 其他字符为%v",
		count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}

八、命令行参数

我们希望能够获取到命令行输入的各种参数，该如何处理? 如图：=> 命令行参数

1.基本介绍

os.Args 是一个string 的切片，用来存储所有的命令行参数

2.举例说明

请编写一段代码，可以获取命令行各个参数

代码：

package main

import (
	"fmt"
	"os"
)

//获取命令行各个参数
func main() {
	fmt.Println("命令行的参数有", len(os.Args))
	//遍历os . Args切片，就可以得到所有的命令行输入参数值
	for i, v := range os.Args {
		fmt.Printf("args[%v]=%v\n", i, v)
	}

}

go build -o test.exe .\main.go	#打包

test.exe install  ./config	#例子

命令行的参数有 3
args[0]=D:\code\Go\src\demo2\05demo\main\test.exe # 启动程序
args[1]=install # 参数
args[2]=./config # 参数

3.flag 包用来解析命令行参数

说明: 前面的方式是比较原生的方式，对解析参数不是特别的方便，特别是带有指定参数形式的命
令行。

比如：cmd>main.exe -f c:/aaa.txt -p 200 -u root 这样的形式命令行，go 设计者给我们提供了flag包，可以方便的解析命令行参数，而且参数顺序可以随意

请编写一段代码，可以获取命令行各个参数.

代码：

package main

import (
	"flag"
	"fmt"
)

func main() {
	//定义几个变量，用于接收命令行的参数值
	var user string
	var pwd string
	var host string
	var port int

	//&user 			就是接收用户命令行中输入的-u 后面的是参数值
	//"u" 				就是 -u 指定参数
	//""  				就是默认值
	// "用户名默认为空"  返回的说明
	flag.StringVar(&user, "u", "", "用户名默认为空")
	flag.StringVar(&pwd, "pwd", "", "密码默认为空")
	flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
	flag.IntVar(&port, "p", 12345, "端口，默认为12345")

	//这里有一个非常重要的操作，转换，调用该方法
	flag.Parse()

	//输出从控制台获取的结果
	fmt.Printf("user=%v pwd=%v host=%v port=%v\n",
		user, pwd, host, port)
}

go build -o test.exe .\main.go	#打包


test.exe -u admin -pwd 123 -h 127.0.0.1 -p 3306 # 运行并接参数
user=admin pwd=123 host=127.0.0.1 port=3306 #输出



test.exe -u admin -pwd 123 -h 127.0.0.1 #使用默认值
user=admin pwd=123 host=127.0.0.1 port=12345

九、JSON文件

1.基本介绍

• 概述

  JSON(avaScript Object Notation)是- -种轻量级的数据交换格式。易于人阅读和编写。同时也易
  于机器解析和生成。key-val

  JSON是在2001年开始推广使用的数据格式，目前已经成为主流的数据格式。

  JSON易于机器解析和生成，并有效地提升网络传输效率,通常程序在网络传输时会先将数据(结构体、map等)序列化成json字符串到接收方得到json字符串时，在反序列化恢复成原来的数据类型(结构体、map等)。这种方式已然成为各个语言的标准。

• 应用场景(示意图)

  

2. json 数据格式说明

3. json 数据在线解析

https://www.json.cn/ 网站可以验证一个json 格式的数据是否正确。尤其是在我们编写比较复杂的
json 格式数据时，很有用。

[{"name":"tom","age":20,"address":["上海","北京"],"hobby":["足球","乒乓球"]},{"name":"mary","age":22,"address":["上海","北京","成都"]}]

格式化：

[
    {
        "name": "tom",
        "age": 20,
        "address": [
            "上海",
            "北京"
        ],
        "hobby": [
            "足球",
            "乒乓球"
        ]
    },
    {
        "name": "mary",
        "age": 22,
        "address": [
            "上海",
            "北京",
            "成都"
        ]
    }
]

4. json 的序列化

• 介绍

  json 序列化是指，将有key-value 结构的数据类型(比如结构体、map、切片)序列化成json 字符串的操作。

• 案例

  这里介绍一下结构体、map 和切片的序列化，其它数据类型的序列化类似。

• 代码

  package main
  
  import (
  	"encoding/json"
  	"fmt"
  )
  
  //定义一个结构体========================
  type Monster struct {
  	Name     string `json:"name"`     //打标签，让json输出的是标签，使用的是反射机制
  	Age      int    `json:"age"`      //打标签，让json输出的是标签，使用的是反射机制
  	Birthday string `json:"birthday"` //打标签，让json输出的是标签，使用的是反射机制
  	Sal      float64
  	Skill    string
  }
  
  func testStruct() {
  	//演示
  	monster := Monster{
  		Name:     "牛魔王",
  		Age:      500,
  		Birthday: "1263-01-25",
  		Sal:      8000.0,
  		Skill:    "野蛮冲撞",
  	}
  
  	//结构体monster序列化
  	data, err := json.Marshal(&monster)
  	if err != nil {
  		fmt.Println("序列化错误，", err)
  	}
  
  	//输出序列化后的结果
  	fmt.Printf("\n结构体：序列化后的结果是:\n%v\n", string(data))
  	// fmt.Printf("方式2：序列化后的结果是:\n%s\n", data)
  }
  
  //============================================
  
  //将map进行序列化==============================
  func testMap() {
  	//定义一个map
  	//var a map[string]interface{}
  
  	//使用map,需要先make
  	a := make(map[string]interface{})
  	a["name"] = "红孩儿"
  	a["age"] = 30
  	a["address"] = "火焰山"
  
  	//将a这个map进行序列化
  	data, err := json.Marshal(&a)
  	if err != nil {
  		fmt.Println("序列化错误，", err)
  	}
  
  	//输出序列化后的结果
  	fmt.Printf("\nmap：序列化后的结果是:\n%v\n", string(data))
  	// fmt.Printf("方式2：序列化后的结果是:\n%s\n", data)
  }
  
  //============================================
  
  //对切片进行序列化  使用难一点的切片例如 []map[string]interface{}
  func testSlice() {
  	var slice []map[string]interface{}
  
  	m1 := make(map[string]interface{}) //声明并make
  	m1["name"] = "孙悟空"
  	m1["age"] = 500
  	m1["address"] = [2]string{"花果山", "水帘洞"}
  
  	slice = append(slice, m1) //开辟空间并追加m1数组
  
  	m2 := make(map[string]interface{}) //声明并make
  	m2["name"] = "杨戬"
  	m2["age"] = 524
  	m2["address"] = "天庭"
  
  	slice = append(slice, m2) //开辟空间并追加m2数组
  
  	//将切片进行序列化操作
  	data, err := json.Marshal(&slice)
  	if err != nil {
  		fmt.Println("序列化错误，", err)
  	}
  
  	//输出序列化后的结果
  	fmt.Printf("\n切片：序列化后的结果是:\n%v\n", string(data))
  	//fmt.Printf("方式2：序列化后的结果是:\n%s\n", data)
  }
  
  //============================================
  
  //对基本数据类型序列化 ，对基本数据类型序列化意义不大
  func testFloat64() {
  	var num1 float64 = 2345.67
  
  	//对num1进行序列化
  	data, err := json.Marshal(&num1)
  	if err != nil {
  		fmt.Println("序列化错误，", err)
  	}
  
  	//输出序列化后的结果
  	fmt.Printf("\n基本数据：序列化后的结果是:\n%s\n", data)
  }
  
  //============================================
  
  func main() {
  	testStruct()
  	testMap()
  	testSlice()
  	testFloat64()
  }
  

• 注意事项

  对于结构体的序列化，如果我们希望序列化后的key 的名字，由我们自己重新制定，那么可以给struct指定一个tag 标签.

  //定义一个结构体========================
  type Monster struct {
  	Name     string `json:"name"`     //打标签，让json输出的是标签，使用的是反射机制
  	Age      int    `json:"age"`      //打标签，让json输出的是标签，使用的是反射机制
  	Birthday string `json:"birthday"` //打标签，让json输出的是标签，使用的是反射机制
  	Sal      float64
  	Skill    string
  }
  

5. json 的反序列化

• 基本介绍

  json 反序列化是指，将json 字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作

• 应用案例

  这里介绍一下将json 字符串反序列化成结构体、map 和切片

• 案例

  package main
  
  import (
  	"encoding/json"
  	"fmt"
  )
  
  type Monster struct { //用来获取json字符串的结构体
  	Name     string `json:"name"`
  	Age      int    `json:"age"`
  	Birthday string `json:"birthday"`
  	Sal      float64
  	Skill    string
  }
  
  //演示将json字符串，反序列化成struct
  func unmarshalStruct() {
  	//模拟获取到json字符串
  	str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"
  
  	//定义一个monster实例
  	var monster Monster
  	err := json.Unmarshal([]byte(str), &monster) //使用引用传递，才能改变monster
  	if err != nil {
  		fmt.Println("反序列化错误：", err)
  	}
  
  	//显示monster结构体数据
  	fmt.Println("结构体反序列化后：", monster) //{牛魔王 500 2011-11-11 8000 牛魔拳}
  }
  
  //反序列化成map
  func unmarshalMap() {
  	str := "{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"
  
  	//定义一个map
  	//反序列化时，不需要make，因为make操作被封装到Unmarshal函数
  	var a map[string]interface{}
  
  	//反序列化
  	err := json.Unmarshal([]byte(str), &a) //使用引用传递，才能改变monster
  	if err != nil {
  		fmt.Println("反序列化错误：", err)
  	}
  	fmt.Println("map反序列化后：", a)
  }
  
  //反序列化成切片
  func unmarshalSlice() {
  	//反序列化切片，需要完整的json字符串，获取的默认产数在前后添加[]
  	str := "[{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}]"
  
  	//定义一个切片
  	//反序列化时，不需要make，因为make操作被封装到Unmarshal函数
  	var slice []map[string]interface{}
  
  	//反序列化
  	err := json.Unmarshal([]byte(str), &slice) //使用引用传递，才能改变monster
  	if err != nil {
  		fmt.Println("反序列化错误：", err)
  	}
  	fmt.Println("切片反序列化后：", slice)
  
  }
  
  func main() {
  	unmarshalStruct()
  	unmarshalMap()
  	unmarshalSlice()
  }
  

• 对上面代码的小结说明

  1. 在反序列化一个json 字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致。

  2. 如果json 字符串是通过程序获取到的，则不需要再对“ 转义处理。

     

章节目录

【Golang第1~3章：基础】如何安装golang、第一个GO程序、golang的基础

【Golang第4章：函数】Golang包的引用，return语句、指针、匿名函数、闭包、go函数参数传递方式，golang获取当前时间

【Golang第5章：数组与切片】golang如何使用数组、数组的遍历和、使用细节和内存中的布局；golang如何使用切片，切片在内存中的布局

【Golang第6章：排序和查找】golang怎么排序，golang的顺序查找和二分查找，go语言中顺序查找二分查找介绍和案例

【Golang第7章：map】go语言中map的基本介绍，golang中map的使用案例，go语言中map的增删改查操作，go语言对map的值进行排序

【Golang第8章：面向对象编程】Go语言的结构体是什么，怎么声明；Golang方法的调用和声明；go语言面向对象实例，go语言工厂模式；golang面向对象的三大特性：继承、封装、多态

【Golang第9章：项目练习】go项目练习家庭收支记账软件项目、go项目练习客户管理系统项目

【Golang第10章：文件操作】GO语言的文件管理，go语言读文件和写文件、GO语言拷贝文件、GO语言判断文件是否存在、GO语言Json文件格式和解析

【Golang第11章：单元测试】GO语言单元测试

【Golang第12章：goroutine协程与channel管道】GO语言goroutine协程和channel管道的基本介绍、goroutine协