Go语言学习笔记 package

待我称王封你为后i 2021-09-19 03:30 410阅读 0赞

**加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号：96933959**

# strings #

`import "strings"`

strings包实现了用于操作字符的简单函数。

strings.Index("suoning", "n")        //3(子串第一次出现的位置，不存在则返回-1)
    strings.LastIndex("suoning", "n")    //5(子串最后一次出现的位置，不存在则返回-1)
    
    strings.Replace("suoning", "ning", "nick", -1) //suonick(替换，n为替换次数，<0替换所有子串)
    strings.HasPrefix("suoning", "suo")            //true(判断s是否有前缀字符串prefix)
    strings.HasSuffix("suoning", "ning")           //true(判断s是否有后缀字符串suffix)
    strings.Contains("suoning", "suoni")           //true(判断字符串s是否包含子串substr)
    
    strings.Count("nnnnnn", "n")         //6(字符串中有几个不重复的子串)
    strings.Repeat("n", 6)               //nnnnnn(返回count个s串联的字符串)
    
    strings.ToLower("SuoNing")           //suoning(将所有字母都转为对应的小写版本的拷贝)
    strings.ToUpper("suoning")           //SUONING(将所有字母都转为对应的大写版本的拷贝)
    
    strings.TrimSpace("  \nsuoning\n  ") //suoning(去掉前后端所有空白)
    strings.Trim("!!suoning!!", "!")     //suoning(将s前后端所有cutset包含的utf-8码值都去掉的字符串)
    strings.TrimLeft("!suoning!", "!")   //suoning!(将s前端所有cutset包含的utf-8码值都去掉的字符串)
    strings.TrimRight("!suoning!", "!")  //!suoning(将s后端所有cutset包含的utf-8码值都去掉的字符串)
    
    strings.Fields(" suo ning ")                   //[suo ning](按照空白分割的多个字符串)
    strings.Split(",suo,ning,", ",")               //[ suo ning ](去掉s中出现的sep的方式进行分割)
    strings.Join([]string{"suo", "ning"}, " ")     //suo ning(用sep来拼接为一个字符串)

# bytes #

`import "bytes"`

bytes包实现了操作\[\]byte的常用函数。本包的函数和strings包的函数相当类似。

s1 := []byte("索宁")
    s2 := []byte("索")
    fmt.Println(bytes.Equal(s1, s2)) //false(切片的内容是否完全相同)
    
    //Runes函数返回和s等价的[]rune切片。（将utf-8编码的unicode码值分别写入单个rune）
    r1 := bytes.Runes(s1)
    r2 := bytes.Runes(s2)
    fmt.Println(r1)             //[32034 23425]
    fmt.Println(r2)             //[32034]
    fmt.Println(r1[0] == r2[0]) //true(可以判断中文)

# strconv #

`import "strconv"`

strconv包实现了基本数据类型和其字符串表示的相互转换。

//返回字符串表示的整数值
    fmt.Println(strconv.ParseInt("-999", 0, 0)) //-999 <nil>
    fmt.Println(strconv.ParseUint("999", 0, 0)) //999 <nil>
    fmt.Println(strconv.Atoi("999"))            //999 <nil>
    //base指定进制（2到36），如果base为0，则会从字符串前置判断，"0x"是16进制，"0"是8进制，否则是10进制；
    //bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；
    
    //返回i的base进制的字符串表示
    fmt.Println(strconv.FormatInt(-520, 10)) //-520
    fmt.Println(strconv.FormatUint(520, 10)) //520
    fmt.Println(strconv.Itoa(520))           //520
    //base 必须在2到36之间，结果中会使用小写字母'a'到'z'表示大于10的数字。
    
    //返回字符串表示的bool值
    fmt.Println(strconv.ParseBool("false"))         //false <nil>
    fmt.Println(strconv.FormatBool(true))           //true
    fmt.Println(strconv.AppendBool([]byte{}, true)) //[116 114 117 101]
    //它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。
    
    //返回字符串表示的bool值
    fmt.Println(strconv.ParseFloat("520.1314", 10))        //520.1314 <nil>
    fmt.Println(strconv.FormatFloat(520.1314, 'f', 6, 32)) //520.131409
    //fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。
    //prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
    //bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

# time #

`import "time"`

time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。

fmt.Println(time.Now())        //2017-08-03 22:35:36.45766459 +0800 CST
    fmt.Println(time.Now().Unix()) //时间戳1501771053
    fmt.Println(time.Sunday)       //Sunday
    fmt.Println(time.Stamp)        //Jan _2 15:04:05
    fmt.Println(time.Date(2008, time.November, 11, 23, 0, 0, 0, time.UTC))
    //2008-11-11 23:00:00 +0000 UTC
    
    //格式化输出
    now := time.Now()
    fmt.Println(now.Format("02/1/2006 15:04:05")) //03/8/2017 22:37:58
    fmt.Println(now.Format("2006/02/1 15:04"))    //2017/03/8 22:37
    fmt.Println(now.Format("2006-1-02 15:04:05")) //2017-8-03 22:37:58
    
    m, _ := time.ParseDuration("-10m") //10分钟前
    fmt.Println(now.Add(m))            //2017-08-03 22:34:55.810202385 +0800 CST
    d, _ := time.ParseDuration("-24h") //1天前
    fmt.Println(now.Add(d))            //2017-08-02 22:46:28.742383801 +0800 CST
    hh, _ := time.ParseDuration("1h")  //1小时后
    fmt.Println(now.Add(hh))           //2017-08-03 23:47:21.458974014 +0800 CST
    
    time.Sleep(time.Second) //睡一秒
    //定时器
    t := time.NewTicker(time.Second)
    for v := range t.C { //每一秒执行一次, 这是个死循环
        fmt.Println(v) //2017-08-03 22:53:13.849203492 +0800 CST
    }
    t.Stop()

# math/rand #

`import "math/rand"`

rand包实现了伪随机数生成器。

随机数从资源生成。包水平的函数都使用的默认的公共资源。该资源会在程序每次运行时都产生确定的序列。如果需要每次运行产生不同的序列，应使用Seed函数进行初始化。默认资源可以安全的用于多go程并发。

func init() {
        rand.Seed(time.Now().UnixNano()) //使用给定的seed来初始化生成器到一个确定的状态。
    }
    
    func main() {
        fmt.Println(rand.Int())     //9153536921449289609(返回一个非负的伪随机int值)
        fmt.Println(rand.Int31())   //2037735069(返回一个int32类型的非负的31位伪随机数)
        fmt.Println(rand.Int63())   //1132646811815532030(返回一个int64类型的非负的63位伪随机数)
    
        fmt.Println(rand.Intn(100)) //95(取值范围在[0,n)的伪随机int值，n<=0会panic)
        fmt.Println(rand.Float32()) //0.09178123(取值范围在[0.0, 1.0)的伪随机float32值)
    
        fmt.Println(rand.Perm(5))   //[0 4 1 2 3](有n个元素的，[0,n)范围内整数的伪随机排列的切片)
    }

# os #

`import "os"`

os包提供了操作系统函数的不依赖平台的接口。设计为Unix风格的，虽然错误处理是go风格的；失败的调用会返回错误值而非错误码。通常错误值里包含更多信息。

fmt.Println(os.Hostname())             //bogon <nil>(返回内核提供的主机名)
    fmt.Println(os.Getpagesize())          //4096(返回底层的系统内存页的尺寸)
    fmt.Println(os.Environ())              //(环境变量的格式为"key=value"的字符串的切片拷贝)
    fmt.Println(os.Getenv("GOPATH"))       //(名为key的环境变量的值,不存在返回空)
    fmt.Println(os.Setenv("Name", "Nick")) //(设置名为key的环境变量)
    os.Clearenv()    //(删除所有环境变量)
    os.Exit(0)       //(以给出的状态码code退出,程序会立刻终止，defer的函数不会被执行)
    
    fmt.Println(os.Getuid())    //501(调用者的用户ID)
    fmt.Println(os.Geteuid())   //501(调用者的有效用户ID)
    fmt.Println(os.Getgid())    //20(调用者的组ID)
    fmt.Println(os.Getegid())   //20(调用者的有效组ID)
    fmt.Println(os.Getgroups()) //[20 701 12 61 79 80 81 ...](调用者所属的所有用户组的组ID)
    fmt.Println(os.Getpid())    //62027(调用者所在进程的进程ID)
    fmt.Println(os.Getppid())   //62020(调用者所在进程的父进程的进程ID)
    
    fmt.Println(os.Getwd())                      //返回一个对应当前工作目录的根路径
    os.Chdir("/tmp/")                            //将当前工作目录修改为dir指定的目录
    os.Mkdir("/tmp/test", 0666)                  //用指定的权限和名称创建一个目录
    os.MkdirAll("/tmp/test1/test2/test3", 0666)  //使用指定的权限和名称创建一个目录,递归上级目录
    os.Rename("/tmp/test", "/tmp/test1/testNew") //修改一个文件的名字，移动一个文件
    os.Remove("/tmp/test1/test2/test3")          //删除name指定的文件或目录
    os.RemoveAll("/tmp/test1/")                  //删除path指定的文件
    
    os.Create("/tmp/test")      //0666,创建文件,存在会清空
    os.Open("/tmp/test")        //O_RDONLY,打开一个文件
    os.OpenFile("/tmp/test", os.O_CREATE|os.O_WRONLY, 0666)
    
    Args保管了命令行参数，第一个是程序名。

# fmt #

`import "fmt"`

mt包实现了类似C语言printf和scanf的格式化I/O。格式化动作（'verb'）源自C语言但更简单。

通用：

%v    值的默认格式表示
    %+v    类似%v，但输出结构体时会添加字段名
    %#v    值的Go语法表示
    %T    值的类型的Go语法表示
    %%    百分号

布尔值：

%t    单词true或false

整数：

%b    表示为二进制
    %c    该值对应的unicode码值
    %d    表示为十进制
    %o    表示为八进制
    %q    该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
    %x    表示为十六进制，使用a-f
    %X    表示为十六进制，使用A-F
    %U    表示为Unicode格式：U+1234，等价于"U+%04X"

浮点数与复数的两个组分：

%b    无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat
    %e    科学计数法，如-1234.456e+78
    %E    科学计数法，如-1234.456E+78
    %f    有小数部分但无指数部分，如123.456
    %F    等价于%f
    %g    根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
    %G    根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

%f:    默认宽度，默认精度
    %9f    宽度9，默认精度
    %.2f   默认宽度，精度2
    %9.2f  宽度9，精度2
    %9.f   宽度9，精度0

字符串和\[\]byte：

%s    直接输出字符串或者[]byte
    %q    该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
    %x    每个字节用两字符十六进制数表示（使用a-f）
    %X    每个字节用两字符十六进制数表示（使用A-F）

指针：

%p    表示为十六进制，并加上前导的0x

# errors #

`import "errors"`

errors包实现了创建错误值的函数。

使用字符串创建一个错误,请类比fmt包的Errorf方法，差不多可以认为是New(fmt.Sprintf(...))。

err := errors.New("emit macho dwarf: elf header corrupted")
    if err != nil {
        fmt.Print(err)    //emit macho dwarf: elf header corrupted
    }

const name, id = "bimmler", 17
    err := fmt.Errorf("user %q (id %d) not found", name, id)
    if err != nil {
        fmt.Print(err)    //user "bimmler" (id 17) not found
    }

# json #

`import "encoding/json"`

json包实现了json对象的编解码。Marshal、Unmarshal函数。

Marshal函数返回v的json编码:

type ColorGroup struct {
        ID     int
        Name   string
        Colors []string
    }
    group := ColorGroup{
        ID:     1,
        Name:   "Reds",
        Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
    }
    b, err := json.Marshal(group)
    if err != nil {
        fmt.Println("error:", err)
    }
    os.Stdout.Write(b)
    //{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}

Unmarshal函数解析json编码的数据并将结果存入v指向的值:

var jsonBlob = []byte(`[
            {"Name": "Platypus", "Order": "Monotremata"},
            {"Name": "Quoll",    "Order": "Dasyuromorphia"}
        ]`)
    type Animal struct {
        Name  string
        Order string
    }
    var animals []Animal
    err := json.Unmarshal(jsonBlob, &animals)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Printf("%+v", animals)
    //[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

package main
    
    import (
        "encoding/json"
        "fmt"
    )
    
    type User struct {
        Name string `json:"userName"`
        Age  int
    }
    
    
    func main() {
        u1 := &User{Name: "nick", Age: 18}
    
        u1Str, err := json.Marshal(u1)
        fmt.Println(err)
        fmt.Println(u1Str)
    
        var u User
        err = json.Unmarshal([]byte(u1Str), &u)
        fmt.Println(err)
        fmt.Println(u)
    
    }

struct tag 使用：

// 字段被本包忽略
    Field int `json:"-"`
    // 字段在json里的键为"myName"
    Field int `json:"myName"`
    // 字段在json里的键为"myName"且如果字段为空值将在对象中省略掉
    Field int `json:"myName,omitempty"`
    // 字段在json里的键为"Field"（默认值），但如果字段为空值会跳过；注意前导的逗号
    Field int `json:",omitempty"`

# reflect #

# flag #

`import "flag"`

flag包实现了命令行参数的解析。

func main() {
        var confPath string
        var port int
        var b bool
    
        flag.StringVar(&confPath, "conf", "", "input config path.")
        flag.IntVar(&port, "p", 8000, "input port.")
        flag.BoolVar(&b, "b", false, "input bool.")
    
        flag.Parse()    //注册
    
        fmt.Println("config path: ", confPath)
        fmt.Println("port: ", port)
        fmt.Println("bool: ", b)
    }

$ go build -o bin/test go_dev/args/main
    $ bin/test -conf "/tmp/config" -p 9006 -b true
    config path:  /tmp/config
    port:  9006
    bool:  true

# context #

一、传递全局变量

func process(ctx context.Context)  {
        ret, ok := ctx.Value("trace_id").(int)
        if !ok {
            ret = 123456
        }
        fmt.Println(ret)    //111111
    
        s, _ := ctx.Value("name").(string)
        fmt.Println(s)    //suoning
    }
    
    func main()  {
        ctx := context.WithValue(context.Background(), "name", "suoning")
        ctx = context.WithValue(ctx, "trace_id", 111111)
        process(ctx)
    }

func add(ctx context.Context, a, b int) int {
        traceId := ctx.Value("trace_id").(string)
        fmt.Printf("trace_id:%v\n", traceId)
        return a + b
    }
    
    func calc(ctx context.Context, a, b int) int {
        traceId := ctx.Value("trace_id").(string)
        fmt.Printf("trace_id:%v\n", traceId)
        return add(ctx, a, b)
    }
    
    func main() {
        ctx := context.WithValue(context.Background(), "trace_id", "123456")
        s := calc(ctx, 500, 20)
        fmt.Println(s)
    }

二、Goroutine Timeout

package main
    
    import (
        "net/http"
        "context"
        "time"
        "fmt"
        "io/ioutil"
    )
    
    type Result struct {
        r   *http.Response
        err error
    }
    
    func process() {
        ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
        defer cancel()
    
        tr := &http.Transport{}
        client := &http.Client{Transport: tr}
        c := make(chan Result, 1)
        req, err := http.NewRequest("GET", "http://www.google.com", nil)
        if err != nil {
            fmt.Println("http NewRequest failed, err:", err)
            return
        }
    
        go func() {
            resp, err := client.Do(req)
            pack := Result{r: resp, err: err}
            c <- pack
        }()
    
        select {
        case <-ctx.Done():
            tr.CancelRequest(req)
            res := <-c
            fmt.Println("Timeout, err:", res.err)
        case res := <-c:
            defer res.r.Body.Close()
            out, _ := ioutil.ReadAll(res.r.Body)
            fmt.Printf("Server Response: %s", out)
        }
    
        return
    }
    
    func main() {
        process()
    }

# sync #

等待一组Goroutine返回

package main
    
    import (
        "sync"
        "fmt"
        "time"
    )
    
    func calc(w *sync.WaitGroup, i int)  {
        fmt.Println("calc: ", i)
        time.Sleep(time.Second)
        w.Done()
    }
    
    func main()  {
        wg := sync.WaitGroup{}
        for i:=0; i<10; i++ {
            wg.Add(1)
            go calc(&wg, i)
        }
        wg.Wait()
        fmt.Println("all goroutine finish")
    }