一、flag包之命令行解析

1、os.Args

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

var Args []string

案例演示：

package main

import (
    "fmt"
    "os"
)

func main() {
    // 获取命令行参数
    fmt.Printf("命令行参数个数为：%v \n", len(os.Args))

    // 打印每一个参数
    for i, v := range os.Args {

        fmt.Printf("第%v个参数是：%v \n", i, v)
    }

}

对上述文件进行编译：

go build  .\main.go

执行编译程序，带上参数：

.\main.exe 123 a

输出：

命令行参数个数为：3 
第0个参数是：D:\go_project\src\go_tutorial\day17\flagDemo01\main.exe 
第1个参数是：123
第2个参数是：a

可以看到我输入的是2个参数，但是默认的总会有第一个参数，就是程序名称。

2、命令行解析

上述方式是比较原生的方式，它存在的比较明显的缺点就是参数位置需要按照指定的进行接收，否则就会出现问题，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, "p", "", "密码默认为空")
    flag.StringVar(&host, "h", "localhost", "主机名默认为localhost")
    flag.IntVar(&port, "P", 3306, "端口号默认为3306")

    // 接收值后需要进行解析
    flag.Parse()

    // 输出
    fmt.Printf("user=%v, pwd=%v, host=%v, port=%v", user, pwd, host, port)

}

对上述文件进行编译：

go build  .\main.go

执行编译程序，带上参数：

.\main.exe -u root -p 123456

输出：

user=root, pwd=123456, host=localhost, port=3306

如果执行的命令有误就会出现说明：

Usage of D:\go_project\src\go_tutorial\day17\flagDemo02\main.exe:
  -P int
        端口号默认为3306 (default 3306)
  -h string
        主机名默认为localhost (default "localhost")
  -p string
        密码默认为空
  -u string
        用户名默认为空

二、序列化与反序列化

（一）基本操作

JSON是一种轻量级的语言交换格式，可以使不同编程语言具有同一种标准的数据交换 格式。而序列化就是将数据对象（数组、结构体、map等）转成json字符串以便接收者接收，而反序列化就是将json字符串转成数据对象（数组、结构体、map等）的过程。

下面三种对象用的比较广泛，其余基本数据类型类似。

• 结构体
• 切片
• map

序列化需要借助于encoding/json包：

func Marshal(v interface{}) ([]byte, error) //Marshal函数返回v的json编码

反序列化需要借助于encoding/json包：

func Unmarshal(data []byte, v interface{}) error // Unmarshal函数解析json编码的数据并将结果存入v指向的值

1、结构体

package main

import (
    "encoding/json"
    "fmt"
)

// 定义一个结构体
type User struct {
    Name string
    Age  int
}

func main() {

    // 创建结构体变量
    user := User{
        Name: "lily",
        Age:  20,
    }

    // 1、对结构体变量进行序列化
    data, err := json.Marshal(user)
    if err != nil {
        fmt.Printf("序列化错误 %v", err)
        return
    }
    // data是字节切片需要转成字符串
    str := string(data)
    fmt.Println(str)

    // 2、反序列化
    // 声明一个User结构体变量
    var user1 User
    err = json.Unmarshal([]byte(str), &user1)
    if err != nil {
        fmt.Printf("反序列化错误 %v", err)
    }
    fmt.Println(user1)
}

2、切片

package main

import (
    "encoding/json"
    "fmt"
)

// 定义一个结构体
type User struct {
    Name string
    Age  int
}

func main() {

    // 创建结构体变量
    user := User{
        Name: "lily",
        Age:  20,
    }

    // 定义一个切片
    var userSlice []User

    // 将结构体变量加入到切片中
    userSlice = append(userSlice, user)
    // 1、对切片进行序列化
    data, err := json.Marshal(userSlice)
    if err != nil {
        fmt.Printf("序列化错误 %v", err)
        return
    }
    // data是字节切片需要转成字符串
    str := string(data)
    fmt.Println(str)

    // 2、反序列化
    // 声明一个待反序列化的切片
    var userSlice1 []User
    err = json.Unmarshal([]byte(str), &userSlice1)
    if err != nil {
        fmt.Printf("反序列化错误 %v", err)
    }
    fmt.Println(userSlice1)
}

3、map

package main

import (
    "encoding/json"
    "fmt"
)

func main() {

    // 定义一个map类型
    var userMap map[string]interface{}

    //map使用前需要进行make
    userMap = make(map[string]interface{}, 5)

    userMap["UserName"] = "Alice"
    userMap["Age"] = 18

    // 1、对切片进行序列化
    data, err := json.Marshal(userMap)
    if err != nil {
        fmt.Printf("序列化错误 %v", err)
        return
    }
    // data是字节切片需要转成字符串
    str := string(data)
    fmt.Println(str)

    // 2、反序列化
    // 声明一个待反序列化的map，反序列化map不需要make，因为已经被封装到内部了
    var userMap1 map[string]interface{}
    err = json.Unmarshal([]byte(str), &userMap1)
    if err != nil {
        fmt.Printf("反序列化错误 %v", err)
    }
    fmt.Println(userMap1)
}

（二）tag标签

tag标签相当于给字段别名，它可以解决以下问题：

• 私有变量跨包
• 返回给前端数据字段名自定义

package main

import (
    "encoding/json"
    "fmt"
)

// 定义一个结构体
type User struct {
    Name string `json:"name"` // tag别名 name
    Age  int    `json:"age"`  // tag别名 age
}

func main() {

    // 创建结构体变量
    user := User{
        Name: "lily",
        Age:  20,
    }

    // 对结构体变量进行序列化，可以看到输出的字段名是tag别名
    data, err := json.Marshal(user)
    if err != nil {
        fmt.Printf("序列化错误 %v", err)
        return
    }
    // data是字节切片需要转成字符串
    str := string(data)
    fmt.Println(str) // {"name":"lily","age":20}

}