文件操作-2

文件操作-2

命令行参数

需求：

能够获得在命令行输入的各种参数

基本介绍：

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

举例说明

写一段代码，能够获取命令行各个参数

代码实现：

package main

import (
	"flag"
	"fmt"
)

func main() {
	//定义的变量用来接收命令行参数
	var user string
	var pwd string
	var host string
	var port int
	//&user 就是接收用户命令行中输入的 -u 后面的参数值
	//“u”，就是指定参数
	//“”默认值
	//“用户名默认为空的”说明
	flag.StringVar(&user, "u", "", "用户名默认为空")
	flag.StringVar(&pwd, "pwd", "", "密码，默认为空")
	flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
	flag.IntVar(&port, "p", 3306, "端口名，默认为3306")
	//这里有一个额外的操作，转换，必须通过该方法
	flag.Parse()
	//输出结果
	fmt.Printf("user = %v\npwd = %v\nhost = %v\nport = %v",
		user, pwd, host, port)
}

其中运用了flag包中的函数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KwPssCoZ-1649750998538)(C:\Users\黑色\AppData\Roaming\Typora\typora-user-images\image-20220409095400065.png)]

最后必须调用一下flag.Parse()函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AMEAsvcE-1649750998540)(C:\Users\黑色\AppData\Roaming\Typora\typora-user-images\image-20220409095500300.png)]

json的基本介绍

概述

• JSON(JavaScript Objrct Notation)是一种轻量级的数据交换格式。易与人阅读和编写。同时也已于机器解析和生成，其一般格式都是：key-value
• Json是在2001年开始推广使用的数据格式，目前已经成为主流的数据格式
• JSON易于机器解析和生成，并有效的提升网络传输效率，通常程序在网络传输时会先将数据（结构体，map等）序列化成为json字符，当接收方得到json字符串时，再反序列化回复成原来的数据类型（结构体，map）这种方式已然称为各个语言的标准

应用的场景示意图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iVSonCQV-1649750998541)(C:\Users\黑色\AppData\Roaming\Typora\typora-user-images\image-20220409100126852.png)]

jison数据格式说明

在JS语言中，一切都是对象。因此，任何的数据类型都可以通过JSON来表示，例如字符串，数字，对象，数组，map，结构体等

JSON键值对时用来保存数据一种方式：

键/值对组合中的键名卸载前面，并用双引号""包裹，使用冒号:分离，然后境紧接着值:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xs2ll6TI-1649750998542)(C:\Users\黑色\AppData\Roaming\Typora\typora-user-images\image-20220409100649218.png)]

jison数据在线解析

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

[{"name":"json","age":58},{"name":"mary","age":18},{"name":"jack","age":58,"adress":["北京","上海"]}
]
序列化：
[
    {
        "name":"json",
        "age":58
    },
    {
        "name":"mary",
        "age":18
    },
    {
        "name":"jack",
        "age":58,
        "adress":[
            "北京",
            "上海"
        ]
    }
]

json的序列化

• 介绍：

json序列化是指，将有key-value结构类型（比如结构体、map、切片）序列化成为json字符串的操作

• 应用案例

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

代码演示：

package main

import (
	"encoding/json"
	"fmt"
)

//结构体
type Monster struct {
	Name     string
	Age      int
	Birthday string
	Sal      float64
	Skill    string
}

func testStruct() {
	monster := Monster{
		Name: "牛魔王", Age: 596, Birthday: "2011-9-6",
		Sal: 8000.0, Skill: "芭蕉扇",
	}
	//将monster序列化
	data, err := json.Marshal(&monster)
	//返回一个数据和一个err
	if err != nil {
		fmt.Printf("序列化错误 err = %v\n", err)
	}
	fmt.Printf("monster序列化结果 = %v\n", string(data))
}

func testMap() {
	//map序列化,一个空接口，可以接收任何的数据类型
	var testMap map[string]interface{}
	//使用map就需要make
	testMap = make(map[string]interface{})
	testMap["naem"] = "孙行者"
	testMap["age"] = 2956
	testMap["adress"] = "花果山"
	//开始将这一个map序列化
	data, err := json.Marshal(testMap)
	if err != nil {
		fmt.Printf("序列化错误 err = %v\n", err)
	}
	fmt.Printf("testmap 序列化之后 = %v\n", string(data))
}

func testSlice() {
	//切片的序列化
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"] = "jack"
	m1["age"] = 18
	m1["adress"] = "北京"
	slice = append(slice, m1)

	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"] = "jack"
	m2["age"] = 18
	m2["adress"] = [...]string{"北京", "上海"}
	slice = append(slice, m2)
	data, err := json.Marshal(slice)
	if err != nil {
		fmt.Printf("序列化错误 err = %v\n", err)
	}
	//输出序列化的结果
	fmt.Printf("testslice 序列化之后 = %v\n", string(data))
}
func testBasis() {
	var number int = 12
	data, err := json.Marshal(number)
	if err != nil {
		fmt.Printf("序列化错误 err = %v\n", err)
	}
	//输出序列化的结果
	fmt.Printf("testbasis 序列化之后 = %v\n", string(data))

}

func main() {
	//对map进行序列化
	testMap()
	//切片
	testSlice()
	//结构体序列化
	testStruct()
	//基本类型序列化
	testBasis()
}
//运行结果演示
testmap 序列化之后 = {"adress":"花果山","age":2956,"naem":"孙行者"}
testslice 序列化之后 = [{"adress":"北京","age":18,"name":"jack"},{"adress":["北京","上海"],"age":18,"name":"jack"}]
monster序列化结果 = {"Name":"牛魔王","Age":596,"Birthday":"2011-9-6","Sal":8000,"Skill":"芭蕉扇"}                  
testbasis 序列化之后 = 12          

• 注意事项

  对于结构体的序列化，我们希望序列化后的key的名字，又我们重新定制，哪儿买我们可以给struct指定一个tag标签

type Monster struct {
	Name     string `json:"monster_name"`
	Age      int    `json:"age"`
	Birthday string
	Sal      float64
	Skill    string
}
//运行结果
monster序列化结果 = {"monster_name":"牛魔王","age":596,"Birthday":"2011-9-6","Sal":8000,"Skill":"芭蕉扇"} 

json反序列化

基本介绍：将json字符串反序列化称为对应的数据类型（比如结构体，map、切片）的操作

使用案例：

package main

import (
	"encoding/json"
	"fmt"
)

type Monster struct {
	Name     string
	Age      int
	Birthday string
	Sal      float32
	Skill    string
}

func unmarshalStruct() {
	str := "{\"Name\": \"牛魔王\",\"Age\": 596, \"Birthday\": \"2011-9-6\", \"Sal\": 8000.0, \"Skill\": \"芭蕉扇\"}"

	//定义一个Monster结构体
	var monster Monster
	err := json.Unmarshal([]byte(str), &monster)
	if err != nil {
		fmt.Printf("unmarshal err = %v\n", err)
	}
	fmt.Printf("反序列化 monster = %v monster.Name = %v\n", monster, monster.Name)

}

//演示将json字符串，反序列化成map
func unmarshalMap() {
	str := "{\"adress\":\"花果山\",\"age\":36,\"name\":\"孙行者\"}"

	var a map[string]interface{}

	err := json.Unmarshal([]byte(str), &a)
	if err != nil {
		fmt.Printf("unmarshal err = %v\n", err)
	}
	fmt.Printf("发序列化后 map = %v\n", a)
}

func main() {
	unmarshalMap()
	unmarshalStruct()
}

• 对上面的代码说明，

1）在反序列化一个json字符串时，要确保反序列化后的数据类型和序列化之前的数据类型相同一致

2）如果json字符串时通过程序获取的，则不需要转义处理

&a)
if err != nil {
fmt.Printf(“unmarshal err = %v\n”, err)
}
fmt.Printf(“发序列化后 map = %v\n”, a)
}

func main() {
unmarshalMap()
unmarshalStruct()
}

* 对上面的代码说明，

1）在反序列化一个json字符串时，要确保反序列化后的数据类型和序列化之前的数据类型相同一致

2）如果json字符串时通过程序获取的，则不需要转义处理