0.快速输入输出
br=bufio.NewReader(os.Stdin)
bw=bufio.NewWriter(os.Stdout)
fmt.Fprintln(bw,x,y,z)
fmt.Fscan(br,&x,&y,&z)
1.变量
    var x int
    var x = 10
    x := 10

2.数组
    var a = [5]int{}
    var a [5]int = [5]int{}
    a := [...]int{1,2,3}
    a := [5]int{1:2,4:2}    //声明数组长度可以指定下标赋值
    f := [][]int{}
    append(f,a)     //往二维数组f中添加一维数组a
    f := [2][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
    }

3.for
    for i:=0;i<n;i++ { }
    for true { }
    for { }

4.内置函数
    len()
    cap()
    unsafe.Sizeof()

5.指针
    var p *int
    var q [5]*int
    var r **int = &p    //指向指针的指针

6.结构体
    person := Person{
        age: 12,
        name: "tyl",
    }
    person := Person{12,"tyl"}
    person := new(Person)

7.切片（动态数组）
     var a []int = make([]int,len,cap)
     a = append(a,1)
     b := make([]int,len,cap)
     copy(b,a)  //把a拷贝到b中

8.range
    range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。

9.map
    var m map[int]string = make(map[int]string)    //必须要make才可以使用
    m[1] = "abc"
    v, ok := m[1]   //获取值，ok代表是否存在
    delete(m,k)     //删除元素

10.类型转换
    go：int(value)
    java：(int)value
    C++：上面两种都可以

11.channel
    ch := make(chan, int, len)
    v, ok := <-ch
    close(ch)
    有缓冲区先传值再取值
    无缓冲去先取值再传值
12.读入完整一行
    reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象
    text, _ := reader.ReadString('\n') // 读到换行
    text = strings.TrimSpace(text)
    fmt.Printf("%#v\n", text)
13.从字符串中读取数据
    Sscan()
    Sscanf()
    Sscanln()
14.time包
    now := time.Now()
    year := now.Year()     //年
    month := now.Month()   //月
    day := now.Day()       //日
    hour := now.Hour()     //小时
    minute := now.Minute() //分钟
    second := now.Second() //秒
    timestamp1 := now.Unix()     //时间戳
    timestamp2 := now.UnixNano() //纳秒时间戳
    timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
    later := now.Add(time.Hour) // 当前时间加1小时后的时间
    Sub()       //减
    Equal()     //相等
    Before()    //是否在此时间之前
    After()     //是否在此时间之后 
15.log
    func init() {
        logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
        if err != nil {
            fmt.Println("open log file failed, err:", err)
            return
        }
        log.SetOutput(logFile)
        log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
    }
    log.Println("这是一条很普通的日志。")
    v := "很普通的"
    log.Printf("这是一条%s日志。\n", v)
    log.Fatalln("这是一条会触发fatal的日志。")
    log.Panicln("这是一条会触发panic的日志。")
16.文件读取
    // 按照字节大小循环读取
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    defer file.Close()
    // 循环读取文件
    var content []byte
    var tmp = make([]byte, 128)
    for {
        n, err := file.Read(tmp)
        if err == io.EOF {
            fmt.Println("文件读完了")
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        content = append(content, tmp[:n]...)
    }
    fmt.Println(string(content))

    // 按照一行一行的读取
    file, err := os.Open("./xx.txt")
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        line, err := reader.ReadString('\n') //注意是字符
        if err == io.EOF {
            if len(line) != 0 {
                fmt.Println(line)
            }
            fmt.Println("文件读完了")
            break
        }
        if err != nil {
            fmt.Println("read file failed, err:", err)
            return
        }
        fmt.Print(line)
    }

    // 一次性读取整个文件
    content, err := ioutil.ReadFile("./main.go")
    if err != nil {
        fmt.Println("read file failed, err:", err)
        return
    }
    fmt.Println(string(content))

    os.O_WRONLY 只写
    os.O_CREATE 创建文件
    os.O_RDONLY 只读
    os.O_RDWR   读写
    os.O_TRUNC  清空
    os.O_APPEND 追加

    // Write和WriterString写入数据
    file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    str := "hello 沙河"
    file.Write([]byte(str))       //写入字节切片数据
    file.WriteString("hello 小王子") //直接写入字符串数据

    // 输入到缓冲区再写入文件
    file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println("open file failed, err:", err)
        return
    }
    defer file.Close()
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString("hello沙河\n") //将数据先写入缓存
    }
    writer.Flush() //将缓存中的内容写入文件

    // 一次性写入
    str := "hello 沙河"
    err := ioutil.WriteFile("./xx.txt", []byte(str), 0666)
    if err != nil {
        fmt.Println("write file failed, err:", err)
        return
    }
17.strconv
    strconv.Atoi()
    strvonv.Itoa()
    b, err := strconv.ParseBool("true")
    f, err := strconv.ParseFloat("3.1415", 64)
    i, err := strconv.ParseInt("-2", 10, 64)
    u, err := strconv.ParseUint("2", 10, 64)
    strconv.FormatInt(i, 10)    //int64转string
18.math
    Abs(-1)
    Max()
    Min()
19.sort
    必须实现三个函数才能排序
        Len()
        Swap()
        Less()  //比较函数
    sort.Sort(sort.IntSlice(a))
    sort.Ints(a []int)
    sort.Strings(s []string)
    sort.Reverse(sort.IntSlice(a))
    sort.Stable(sort.IntSlice(a))   //稳定排序
20.container/heap
    需要实现：
        sort.Interface
        Push()
        Pop()
    Init(h Interface)
    Push(h Interface, x interface{})
    Pop(h Interface, x interface{})
    Remove(h Interface, i int)
    Fix(h Interface, i int)
21.Strings
    Strings.Index(s string, sub string)
    Strings.Split(s, sep string)
    Strings.Join(a []string,sep strings)
    Strings.Contains(s, sub string)
22.container/list
    a := list.New()
    a.PushBack(x)
    l.Front().val
    l.Back().val
    l.len()
    l.PushFront(x)
    l.Remove(e *Element)
23.reflect
    reflect.ValueOf(interface{})    //获得接口的数值
    reflect.TypeOf(interface{})     //获得接口的类型
    reflect.DeepEqual(x, y) //slice不能直接比较，借助反射包进行比较
23.单元测试
    go test     测试所有test函数
    go test -v  测试所有test函数并显示详细信息
    go test -v -run="Func/testItem" //测试Func函数下的一个用例testItem
    go tets -cover //查看覆盖率
    go test -cover -coverprofile=c.out  //生成一个文件c.out,可通过网页查看该文件，看到哪些被覆盖
    go test -bench=Func -benchmem //显示执行次数，用时，内存消耗，申请内存次数

    func TestName(t *testing.T){...}    
    func  BenchmarkName(b *testing.B){...}    //性能测试
    func RunParallel(func(){})  //并行测试
24.生成随机数
    rand.Seed(time.Now().UnixNano())
    x := rand.Intn(10)  //生成0~9整数
25.断言
    token.Claims.(*MyClaims)    //判断token结构里里的Claims接口是不是*MyClaims结构体类型，是就返回该结构体
    x是结构体指针类型：
        x.(*y)      返回&{...}, true
        x.(y)       返回{0, "", nil}, false
    x是结构体类型:
        x.(*y)      返回{0, "", nil}, false
        x.(y)       返回{...}, true
26.get/post提取数据
    1.c.Request.FormValue           //获取post中的参数，获取布到再获取url中的
    2.c.Request.PostFormValue       //
    3.c.Query                       //get URL请求中的参数
    4.c.PostForm                    //post请求form表中的参数
    5.c.GetRawData()                //post请求body中的参数
    6.c.Param("name")               //url中的这种参数localhost:9090/user/tyl/password/123456

    参数类型        可以获取到该参数的方法
    Query Params    1  3
    form-data1      2  4  
    body json       5
27.select优先级写法：如果两个chanel同时可以执行，则先执行ch1再执行ch2
for {
    select {
    case <-stopCh:
        return
    case job1 := <-ch1:
        fmt.Println(job1)
    case job2 := <-ch2:
    priority:
        for {
            select {
            case job1 := <-ch1:
                fmt.Println(job1)
            default:
                break priority
            }
        }
        fmt.Println(job2)
    }
}

28.regexp包
    reg1 := regex.MustCompile(`a.c`)    //解析正则表达式是否正确，成功则返回解释器，否则panic
    rst1 := reg1.FindAllStringSubmatch("abc azc a7c aac 888 a9c  tac", -1) //从字符串中找到所有匹配的子串result1 =  [[abc] [azc] [a7c] [aac] [a9c]]　　
    reg1.ReplaceAll()   //将匹配的全部替换