在写代码的时候，在运行程序做一些初始化操作的时候，往往会通过命令行传参数到程序中，那么就会用到命令行参数
例如，指定程序运行的模式和级别：
go run HTTPServer.go --mode survival --level 1
os.Args
可以通过 os 包的 Args 变量来获取所有命令行参数，得到的是一个 string 切片类型（[]string），第一个命令行参数就是执行文件本身
package main
import (
"fmt"
"os"
)
func main (){
fmt.Println(os.Args)
}
运行结果：
[C:\Users\chenkai\AppData\Local\Temp\___go_build_main_go__3_.exe]
flag 包
使用 flag 包解析命令行参数的方法有两类，下面记录一下用法
1）对已初始化的变量进行赋值（推荐使用）
package main
import (
"flag"
"fmt"
)
func main (){
var mode string
var level int
var onOff bool
flag.StringVar(&mode,"mode", "survival", "game pattern")
flag.IntVar(&level, "level", 1, "game level")
flag.BoolVar(&onOff, "onOff", true, "game onOff")
//解析命令行参数
flag.Parse()
fmt.Printf("%v\t%v\t%v\t", mode, level, onOff)
}
运行结果：
survival 0 true
2）使用指针变量接收
package main
import (
"flag"
"fmt"
)
func main (){
var mode *string = flag.String("mode", "survival", "game pattern")
var level *int = flag.Int("level", 1, "game level")
var onOff *bool = flag.Bool("onOff", true, "game onOff")
//解析命令行参数
flag.Parse()
fmt.Printf("%v\t%v\t%v\t\n", mode, level, onOff)
fmt.Printf("%v\t%v\t%v\t", *mode, *level, *onOff)
}
运行结果：
0xc00004e200 0xc0000620c0 0xc0000620c8
survival 0 true
json 是跨平台的一种数据格式，当然，Go 也是支持 json 协议的，分为 json 序列化 和 反序列化
1）序列化（json.Marshal）
结构体转 json：
package main
import (
"encoding/json"
"fmt"
)
type User struct {
UserName string
NickName string
Age int
Sex string
Email string
}
func main (){
var userA User = User{
UserName: "托尼",
NickName: "tony",
Age: 36,
Sex: "男",
Email: "tony@163.com",
}
var jsonData []byte
//func Marshal(v interface{}) ([]byte, error)
jsonData, err := json.Marshal(userA)
if err != nil {
fmt.Printf("json marshal error[%v]", err)
}
fmt.Println(string(jsonData))
}
运行结果：
{"UserName":"托尼","NickName":"tony","Age":36,"Sex":"男","Email":"tony@163.com"}
如果想要更改 json 字符串的 key，可以设置结构体 json 标签：
package main import ( "encoding/json" "fmt" ) type User struct { UserName string `json:"username"` NickName string `json:"nickname"` Age int `json:"age"` Sex string `json:"sex"` Email string `json:"email"` } func main (){ var userA User = User{ UserName: "托尼", NickName: "tony", Age: 36, Sex: "男", Email: "tony@163.com", } var jsonData []byte //func Marshal(v interface{}) ([]byte, error) jsonData, err := json.Marshal(userA) if err != nil { fmt.Printf("json marshal error[%v]", err) } fmt.Println(string(jsonData)) } 运行结果： {"username":"托尼","nickname":"tony","age":36,"sex":"男","email":"tony@163.com"}
map 转 json：
package main
import (
"encoding/json"
"fmt"
)
func main (){
var mapA map[string]string = make(map[string]string)
mapA["name"] = "johny"
mapA["email"] = "johny@163.com"
var jsonData []byte
jsonData, err := json.Marshal(mapA)
if err != nil {
fmt.Printf("json marshal error[%v]", err)
}
fmt.Println(string(jsonData))
}
运行结果：
{"email":"johny@163.com","name":"johny"}
2）反序列化（json.Unmarshal）
json 返序列化为结构体：先获取一个结构体的 json 数据，然后赋值给另一个 结构体类型
package main
import (
"encoding/json"
"fmt"
)
type User struct {
UserName string `json:"username"`
NickName string `json:"nickname"`
Age int `json:"age"`
Sex string `json:"sex"`
Email string `json:"email"`
}
func marshalData() string {
var userA User = User{
UserName: "托尼",
NickName: "tony",
Age: 36,
Sex: "男",
Email: "tony@163.com",
}
var jsonData []byte
//func Marshal(v interface{}) ([]byte, error)
jsonData, err := json.Marshal(userA)
if err != nil {
fmt.Printf("json marshal error[%v]", err)
}
return string(jsonData)
}
func main (){
jsonData := marshalData()
var userB User = User{}
fmt.Println(userB)
//func Unmarshal(data []byte, v interface{}) error
err := json.Unmarshal([]byte(jsonData), &userB)
if err != nil {
fmt.Printf("json unmarshal error[%v]", err)
}
fmt.Println(userB)
}
运行结果：
{ 0 } //空白部分是空字符串，string 类型默认值是空字符串，int 类型默认值是 0
{托尼 tony 36 男 tony@163.com}
自定义错误内容一般用的很少，不过也需要了解一下，主要是实现一个 Error() 方法，成为 error 接口类型即可实现自定义的错误类型
实现了 error 接口，就是 error 类型，error 接口定义如下：
type error interface {
Error() string
}
demo：打开文件错误时，返回自定义的错误内容
package main
import (
"encoding/json"
"fmt"
"os"
"time"
)
type OpenError struct {
path string
operation string
createTime time.Time
message string
}
func (openErr *OpenError) Error() string {
var jsonData []byte
jsonData, err := json.Marshal(*openErr)
if err != nil {
fmt.Printf("json marshal error[%v]", err)
}
return string(jsonData)
}
func openFile(filepath string) error {
var openErr = &OpenError{}
file, err := os.Open(filepath)
if err != nil {
openErr.path = filepath
openErr.operation ="read"
openErr.createTime = time.Now()
openErr.message = err.Error()
return openErr
}
defer file.Close()
return openErr
}
func main(){
//err := openFile("D:\\golang_workspace\\file_test\\source.txt")
err := openFile("D:\\golang_workspace\\file_testsdafs")
//fmt.Println(err.Error())
//fmt.Println(err)
if err != nil {
fmt.Println(err.Error())
}
}
ending ~
原文：https://www.cnblogs.com/kaichenkai/p/11223439.html