Go module

1.配置方法
安装完 go 之后通过 go env 查看当前的环境
image.png

开启go module

  1. go env -w GO111MODULE=on
  2. 或者
  3. export GO111MODULE=on

GoPROXY配置镜像

默认GoPROXY配置是：GOPROXY=https://proxy.golang.org,direct，由于国内访问不到[https://proxy.golang.org](https://proxy.golang.org)，所以我们需要换一个PROXY

  1. # 阿里云镜像
  2. GOPROXY=https://mirrors.aliyun.com/goproxy/
  3. #中国golang镜像
  4. GOPROXY=https://goproxy.io
  5. #七牛云为中国的gopher提供了一个免费合法的代理goproxy.cn，其已经开源。只需一条简单命令就可以使用该代理：
  6. GOPROXY=https://goproxy.cn,direct

初始化go module环境

带git的项目

直接从github上面clone一个项目下来。
直接执行 go mod init 会自动生成带git地址的packagename
执行命令：
go mod init
不带git的项目
切换到当前目录下：
cd mysql
直接执行
go mod init mysql
可以看到当前文件夹下多了go.mod 文件
image.png

运行项目
go run main.go
就可以自动下载依赖包，也可以手动通过 go get github.com/go-sql-driver/mysql 来下载
但是注意：
由于go的一些官方文档被墙的原因，会导致网络连接超时，下载失败。
要通过代理地址来下载
执行命令：

  1. go env -w GOPROXY=https://goproxy.cn

再次执行下载就成功了。
下载成功之后就多了一个go.sum文件
image.png
https://www.cnblogs.com/wongbingming/p/12941021.html
https://studygolang.com/articles/24517?fr=sidebar

基础语法

一、变量声明以及使用

  1. 变量名 变量类型 a int，声明后若不赋值，就是用默认值 ```javascript package main

    import ( “fmt” “math” ) // 变量名 变量类型 没有初始值的情况下 int 默认是0，string默认是 “” func variable() { var a int var s string fmt.Printf(“%d %q\n”, a, s) // Printf可以打印空值 0 “” }

// 函数外面定义变量必须用 var 不能用 := func main() { fmt.Println(“yyyy”) variable() }

  2. 2. 可同时声明多个变量 a, b int = 3, 4
  3. ```javascript
  4. // 同时定义多个变量并且赋初始值
  5. func variableInitialValue(){
  6.     var a, b int = 3, 4
  7.     var s string = "abc"
  8.     fmt.Println(a, b, s) // 3， 4， abc
  9. }

  1. 省略类型，编译器可根据初始值推测出类型

    1. // 省略类型，并且多类型可以一起定义，通过赋的初始值，编译器可推测出类型
    2. func variableTypeDeduction() {
    3.  var a, b, c, s = 3, 4, true, "def" 
    4.  fmt.Println(a, b, c, s)
    5. }

  2. 省略var，使用 := 定义变量

    1. // 函数内部使用 := 定义变量, 省略var, 可以重复赋值
    2. func variableShorter()  {
    3.  a, b, c, s := 3, 4, true, "def"
    4.  fmt.Println(a,b,c,s)
    5. }

    注意：这种方式定义变量仅限于函数内部，全局定义变量不能使用 :=

  3. 定义常量，使用const 关键字

    1. // 常量的定义
    2. func consts() {
    3.  const filename = "abc.txt"
    4.  fmt.Println(filename)
    5. }

  4. 使用常量定义枚举类型，通过const 块来定义 ```javascript // 使用常量定义枚举类型 通过const块来定义 func enums() { //普通枚举 // const ( // filename = “abc” // a, b = 3, 4 // ) // 自增值枚举 const (

    1.  cpp = iota // iota 表示自增值
    2.  java
    3.  pyhton
    4.  golang

    ) fmt.Println(cpp, java, pyhton, golang) // 0, 1, 2, 3 }

func enums2() { const ( cpp = iota // iota 表示自增值 _ // 表示跳过 1 java pyhton golang ) fmt.Println(cpp, java, pyhton, golang) // 0, 1, 2, 3 }

  1. iota表示自增， _ 表示跳过
  3. 7. 类型转换， go只有强制类型转换，没有隐式类型转换
  4. ```javascript
  5. // 强制类型转换,没有隐式类型转换
  6. func triangle()  {
  7.     var a, b int = 3, 4
  8.     var c int
  9.     c = int(math.Sqrt(float64(a*a + b*b))) // Sqrt 接收的参数是 float64，返回的也是 float64
  10.     fmt.Println(c)
  11. }

二、条件语句

  1. if if条件里不需要括号

    1. func main(){
    2.   const filename = "abc.txt"
    3.   contents, err := ioutil.ReadFile(filename) // ioutil.ReadFile 返回两个参数，第一个是文件内容、第二个是报错信息
    4.   if err != nil {
    5.       fmt.Println(err) // open abc.txt: no such file or directory
    6.   }else {
    7.       fmt.Printf("%s\n", contents)
    8.   }
    9. }

    if语句还支持初始化语句，初始化语句和条件表达式之间用分号隔开

    1. func main(){
    2.   const filename = "abc.txt"
    3.  if contents, err := ioutil.ReadFile(filename); err != nil {
    4.      fmt.Println(err)
    5.  }else {
    6.      fmt.Printf("%s\n", contents)
    7.  }
    8. }

  2. swich

switch会自动break，除非使用 fallthrough

  1. func grade(score int) string { // 传入 int类型的参数，返回值是string类型
  2.     g := ""
  3.     switch{
  4.     case score < 0 || score > 100 :
  5.         panic(fmt.Sprintf("Wrong score: %d", score))
  6.     case score < 60:
  7.         g = "F"
  8.     case score < 80:
  9.         g = "C"
  10.     case score < 90:
  11.         g = "B"
  12.     case score <= 100:
  13.         g = "A"
  14.     }
  15.     return g
  16.  }

panic，停止程序，并报错

三、for循环

for 的条件里不需要括号
for的条件里可以省略初始条件，结束条件，递增表达式
整数转二进制：

  1.  package main
  3.  import (
  4.      "fmt"
  5.      "strconv"
  6.  )
  8. func covertToBin(n int) string {
  9.     result := ""
  10.     for ; n > 0; n/=2 { // 
  11.         lsb := n % 2
  12.         result = strconv.Itoa(lsb) + result
  13.     }
  14.     return result
  15. }
  17. func main() {
  18.     fmt.Println(covertToBin(13)) // 1101
  19. }

省略结束条件就会成为死循环

四、函数

1.函数定义
函数名在前，函数返回值的类型在后

  1. package main
  3. import (
  4.     "fmt"
  5. )
  6. // 参数 a, b int, op string 返回值 int
  7. func eval(a, b int, op string) (int, error) { // 可以让它返回两个值，一个是成功时返回的值，一个是出错时返回的值可以处理错误，而不用中断程序的执行
  8.     switch op {
  9.     case "+":
  10.         return a + b, nil
  11.     case "-":
  12.         return a - b, nil
  13.     case "*":
  14.         return a * b, nil
  15.     case "/":
  16.         return a / b, nil
  17.     default:
  18.         // panic("unsupported operation:" + op)
  19.         return 0, fmt.Errorf(
  20.             "unsupported operation: %s", op,
  21.         )
  22.     }
  23. }
  24. func main() { 
  25.     fmt.Println(eval(2, 5, "l")) // 0 unsupported operation: l
  26. }

2.多返回值

  1. // 多个返回值
  2. func div1(a, b int) (q, r int) {
  3.     return a / b, a % b
  4. }
  5. // 函数返回多个值时可以起名字，仅用于非常简单的函数
  6. func div2(a, b int) (q, r int) {
  7.     q = a / b
  8.     r = a % b
  9.     return 
  10. }

3.可变参数列表

  1. // 可变参数列表
  2. func sum(numbers ...int) int { // ... int 表示numbers里面可以有任意多个参数
  3.     fmt.Println(numbers) // [1 2 3 4 5]
  4.     s := 0
  5.     for i := range numbers {
  6.         s += numbers[i]
  7.     }
  8.     return s
  9. } 
  10. func main() { 
  11.     fmt.Println(sum(1,2,3,4,5)) // 15
  12. }

五、指针

go参数传递只有值传递
相当于拷贝了一份新的值，这份新的可以任意修改，都不会影响到旧的
通过指针可以实现 引用传递的效果

  1. int类型

image.png
&a 和 pa的指针同时指向 a

当修改了 pa 的同时也修改了 a

  1. object

cache本身是一个指向data的指针，参数传递的时候相当于是拷贝了一份指针，都指向 data

image.png

go语言中的自定义类型在定义的时候就需要考虑到我们定义的是当作值来用呢还是指针呢

像第二个例子就可以当作值来用，拷贝一份新的，让它修改data
但如果cache维护的状态比较多那就不能当作指针来用。
值交换，要改变变量的值必须传指针进去

  1. // 指针参数传递
  2. func swap(a, b *int) {
  3.     // b, a = a, b // 这么不生效，因为是值传递，怎么修改都不会改变原始值
  4.     *b, *a = *a, *b 
  5. }
  7. func main() { 
  8.     a, b := 3, 4
  9.     swap(&a, &b)
  10.     fmt.Println(a, b) // 4, 3
  11. }

第二种方式：

  1. // 有返回值的可以
  2. func swap(a, b int) (int, int){
  3.     return b, a
  4. }
  6. func main() {
  7.     a, b := 3, 4
  8.     a, b = swap(a, b)
  9.     fmt.Println(a, b) // 4, 3
  10. }

六、数组

1.数组的定义 数组名 [数组长度] 数组类型，若不给数组长度就是slice切片

  1. package main
  3.  import ("fmt")
  5.  func main() {
  6.      var arr1 [5]int 
  7.      arr2 := [3]int{1, 2, 3}
  8.      arr3 := [...]int{2,4,6,8,10}
  9.      var grid [4][5]int
  11.     fmt.Println("array definitions:")
  12.     fmt.Println(arr1, arr2, arr3)
  13.     fmt.Println(grid)
  14.  }

通过var定义的数组可以不给初始值，通过 := 定义的数组必须给初始值，也可以通过 […] 的方式定义不定长度的数组
2.遍历数组的方法
有传统 for 循环和 range 方法

  1. // 不推荐
  2.     for i:= 0; i < len(arr3); i++ {
  3.         fmt.Println(arr3[i])
  4.     }
  5.     // range 关键字可同时获取到 index和value
  6.     for i, v := range arr3 {
  7.         fmt.Println(i, v)
  8.     }
  9.     // 可通过 _ 省略变量 若不想获取 i 可使用 _ 忽略
  10.     for _, v := range arr3 {
  11.         fmt.Println(v)
  12.     }

3.数组是值传递类型

  1. package main
  3. import "fmt"
  5. func printArray(arr [5]int) {
  6.     arr[0] = 100
  7.     for i, v := range arr {
  8.         fmt.Println(i, v)
  9.     }
  10. }
  12. func main() {
  13.     var arr1 [5]int
  14.     arr2 := [3]int{1, 3, 5}
  15.     arr3 := [...]int{2, 4, 6, 8, 10}
  16.     var grid [4][5]int
  18.     fmt.Println("printArray(arr1)")
  19.     printArray(arr1)
  21.     fmt.Println("printArray(arr3)")
  22.     printArray(arr3)
  24.     fmt.Println("arr1 and arr3")
  25.     fmt.Println(arr1, arr3)
  26. }

如下结果：
image.png
arr1 和 arr3 会拷贝，改变拷贝数组不会影响到原数组
可使用指针改变原数组

  1.  package main
  3.  import ("fmt")
  5.  //数组是值类型
  6.  func printArray(arr *[5]int){
  7.      arr[0] = 100
  8.      for i, v := range arr {
  9.          fmt.Println(i, v)
  10.      }
  11.  }
  13.  func main() {
  14.      var arr1 [5]int 
  15.      arr2 := [3]int{1, 2, 3}
  16.      arr3 := [...]int{2,4,6,8,10}
  17.      var grid [4][5]int
  19.     fmt.Println("printArray(arr1)")
  20.     printArray(&arr1) // 100 
  22.     fmt.Println("printArray(arr3)")
  23.     printArray(&arr3) // 100
  25.     fmt.Println("arr1 and arr3")
  26.     fmt.Println(arr1, arr3) // 不变
  27.  }

结果如下：
image.png
这样就可以改变原数组
但是这样使用数组有些麻烦，go语言中一般不用数组，而是使用切片

七、切片slice

go语言中一般不使用数组，而是用slice
slice 并不是数组或数组指针。而是数组的一个引用，因此是引用类型，但自身是结构体，是值拷贝传递。

1.创建切片

和数组创建的方式唯一不同的是创建数组需要声明数组长度 arr [5] int，切片不用声明数组长度 arr [] int

  1. 全局：
  2. var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  3. var slice0 []int = arr[start:end] 
  4. var slice1 []int = arr[:end]        
  5. var slice2 []int = arr[start:]        
  6. var slice3 []int = arr[:] 
  7. var slice4 = arr[:len(arr)-1]      //去掉切片的最后一个元素
  8. 局部：
  9. arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
  10. slice5 := arr[start:end]
  11. slice6 := arr[:end]        
  12. slice7 := arr[start:]     
  13. slice8 := arr[:]  
  14. slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素
  1. package main
  3. import "fmt"
  4. func main() {
  5.   // 第一种
  6.     arr := [...]int {0, 1, 2, 3, 4, 5, 6, 7}
  7.     fmt.Println("arr[2:6] =", arr[2:6]) // [2 3 4 5]
  8.     fmt.Println("arr[:6] =", arr[:6])   // [0 1 2 3 4 5]
  10.   // 第二种
  11.   var s []int // Zero value for slice is nil
  12.     for i := 0; i < 100; i++ {
  13.         printSlice(s)
  14.         s = append(s, 2*i+1)
  15.     }
  16.     fmt.Println(s)
  18.   // 第三种
  19.     s1 := []int{2, 4, 6, 8} // 创建了一个数组，让 s1 映射 这个数组
  20.     printSlice(s1)
  21.   // 第四种
  22.     s2 := make([]int, 16)  // 创建一个长度 为 16 的slice
  23.     s3 := make([]int, 10, 32) // slice长度为10，cap为32，也就是这个slice可以映射一个长度为 32 的数组
  24.     printSlice(s2)
  25.     printSlice(s3)
  26. }

2.更新slice

  1. package main
  3. import "fmt"
  4. func updataSlice(s []int) {
  5.     s[0] = 100
  6. }
  8. func main() {
  9.     arr := [...]int {0, 1, 2, 3, 4, 5, 6, 7}
  10.     s1 := arr[2:]
  12.     updataSlice(s1)
  13.     fmt.Println("s1 =", s1) // [100 3 4 5 6 7] 
  14.     fmt.Println("arr =", arr) // [0 1 100 3 4 5 6 7] 
  15. }

slice本身是没有数据的，是对底层数组的一个映射，所以改变slice也就改变了原数组

3.slice的扩展

  1. package main
  3. import "fmt"
  4. func updataSlice(s []int) {
  5.     s[0] = 100
  6. }
  8. func main() {
  9.     arr := [...]int {0, 1, 2, 3, 4, 5, 6, 7}
  11.     fmt.Println("Extending slice")
  12.     arr[0], arr[2] = 0, 2
  13.     fmt.Println("arr =", arr)
  14.     s1 := arr[2:6]
  15.     s2 := s1[3:5] 
  16.     fmt.Println(s1)
  17.     fmt.Println(s2)
  18. }

s1 = [2, 3, 4, 5]
s2 只能取到第3个，也就是 5，但是实际的结果是 s2 = [5, 6]，这是怎么回事呢？
看下图
image.png
这是因为slice是对底层数组的映射，引用，虽然 s1 不包含 5，6，但是它依然能映射到 5，6

4.slice的底层实现

image.png
slice底层实现包含这三个。
ptr 指向slice的开始位置，
len是slice的长度，通过下标取值的时候不能超过len，
cap 是 整个 arr ，所以扩展 slice 的时候，只要不超过cap就可以。所以上面的slice扩展例子可以取到 5，6
注意：slice只能向后扩展，不能向前扩展

5.向slice添加元素

  1. package main
  3. import "fmt"
  4. func updataSlice(s []int) {
  5.     s[0] = 100
  6. }
  8. func main() {
  9.     arr := [...]int {0, 1, 2, 3, 4, 5, 6, 7}
  11.     s1 = arr[2:6]
  12.     s2 := s1[3:5]
  13.     fmt.Println(s1) // [2 3 4 5]
  14.     fmt.Println(s2) // [5 6]
  15.     // 向slice添加元素
  16.     s3 := append(s2, 10)
  17.     s4 := append(s3, 11)
  18.     s5 := append(s4, 12)
  19.     fmt.Println("s3, s4, s5 =", s3, s4, s5)
  20.     // s4 and s5 no longer view arr.
  21.     fmt.Println("arr =", arr)
  22. }

image.png
s3 append 10 ,就会把 原数组的 7 改变成 10
s4, s5 append的元素超出了arr 的长度，也就是alice里面的 cap， 所以就不再在arr里面映射，系统会重新分配一个 更大的底层 arr，新的arr 的长度会是旧的长度的2倍，并把原来的arr拷贝过去，如果原数组没被引用就会垃圾回收掉，否则依旧存在。
由于值传递的关系，必须接收append的返回值。

6.slice的其他操作

  1. package main
  3. import "fmt"
  5. func printSlice(s []int) {
  6.     fmt.Printf("%v, len=%d, cap=%d\n",
  7.         s, len(s), cap(s))
  8. }
  10. func sliceOps() {
  11.     fmt.Println("Creating slice")
  12.     // 创建slice的方法
  13.     var s []int // Zero value for slice is nil
  15.     for i := 0; i < 100; i++ {
  16.         printSlice(s)
  17.         s = append(s, 2*i+1)
  18.     }
  19.     fmt.Println(s)
  21.     s1 := []int{2, 4, 6, 8} // 创建了一个数组，让 s1 映射 这个数组
  22.     printSlice(s1)
  24.     s2 := make([]int, 16)  // 创建一个长度 为 16 的slice
  25.     s3 := make([]int, 10, 32) // slice长度为10，cap为32，也就是这个slice可以映射一个长度为 32 的数组
  26.     printSlice(s2)
  27.     printSlice(s3)
  28.   // copy
  29.     fmt.Println("Copying slice")
  30.     copy(s2, s1) 
  31.     printSlice(s2) // [2,4,6,8,0,0,0,0,0]
  33.     fmt.Println("Deleting elements from slice")
  34.     // 删掉 8 
  35.     s2 = append(s2[:3], s2[4:]...)
  36.     printSlice(s2)
  38.     fmt.Println("Popping from front")
  39.     front := s2[0]
  40.     s2 = s2[1:]
  42.     fmt.Println(front)
  43.     printSlice(s2)
  45.     fmt.Println("Popping from back")
  46.     tail := s2[len(s2)-1]
  47.     s2 = s2[:len(s2)-1]
  49.     fmt.Println(tail)
  50.     printSlice(s2)
  51. }

八、Map

1.创建

有两种创建方式

  1. package main
  3. import "fmt"
  5. func main() {
  6.     m := map[string]string{
  7.         "name":    "ccmouse",
  8.         "course":  "golang",
  9.         "site":    "imooc",
  10.         "quality": "notbad",
  11.     }
  12.   // 第一种
  13.     m2 := make(map[string]int) // m2 == empty map
  14.   // 第二种
  15.     var m3 map[string]int // m3 == nil   nil类似与 null 但是可进行运算
  17.     fmt.Println("m, m2, m3:")
  18.     fmt.Println(m, m2, m3)
  20. }

推荐使用第二种

2.获取元素 m[key]

当key不存在时，获得的 value是初始值或者是默认值，不会报错。

  1. package main
  3. import "fmt"
  5. func main() {
  6.     m := map[string]string{
  7.         "name":    "ccmouse",
  8.         "course":  "golang",
  9.         "site":    "imooc",
  10.         "quality": "notbad",
  11.     }
  13.     m2 := make(map[string]int) // m2 == empty map
  15.     var m3 map[string]int // m3 == nil   nil类似与 null 但是可进行运算
  17.     fmt.Println("m, m2, m3:")
  18.     fmt.Println(m, m2, m3)
  21.     fmt.Println("Getting values")
  22.     courseName := m["course"] // 获取 course 名字
  23.     // courseName := m["couse"]  // 不存在的key，依旧会打印出空值，go语言不初始化也能用，拿到的值就是默认值
  24.     fmt.Println(`m["course"] =`, courseName)
  25.     if causeName, ok := m["cause"]; ok {
  26.         fmt.Println(causeName)
  27.     } else {
  28.         fmt.Println("key 'cause' does not exist")
  29.     }
  30. }

设置 value ok， 当key不存在的时候 ok 为 false，存在时 ok为 true

3.判断某个键是否存在

Go语言中有个判断map中键是否存在的特殊写法，格式如下:

  1. value, ok := map[key]

4.delete

  1. package main
  3. import "fmt"
  5. func main() {
  6.     m := map[string]string{
  7.         "name":    "ccmouse",
  8.         "course":  "golang",
  9.         "site":    "imooc",
  10.         "quality": "notbad",
  11.     }
  13.     m2 := make(map[string]int) // m2 == empty map
  15.     var m3 map[string]int // m3 == nil   nil类似与 null 但是可进行运算
  17.     fmt.Println("Getting values")
  18.     courseName := m["course"] // 获取 course 名字
  19.     // courseName := m["couse"]  // 不存在的key，依旧会打印出空值，go语言不初始化也能用，拿到的值就是默认值
  20.     fmt.Println(`m["course"] =`, courseName)
  21.     if causeName, ok := m["cause"]; ok {
  22.         fmt.Println(causeName)
  23.     } else {
  24.         fmt.Println("key 'cause' does not exist")
  25.     }
  27.     fmt.Println("Deleting values")
  28.     name, ok := m["name"]
  29.     fmt.Printf("m[%q] before delete: %q, %v\n",
  30.         "name", name, ok)
  32.     delete(m, "name")
  33.     name, ok = m["name"]
  34.     fmt.Printf("m[%q] after delete: %q, %v\n",
  35.         "name", name, ok)
  36. }

5.使用range遍历

使用range遍历key，或者遍历key，value

  1. func main() {
  2.     m := map[string]string{
  3.         "name":    "ccmouse",
  4.         "course":  "golang",
  5.         "site":    "imooc",
  6.         "quality": "notbad",
  7.     }
  9.     m2 := make(map[string]int) // m2 == empty map
  11.     var m3 map[string]int // m3 == nil   nil类似与 null 但是可进行运算
  13.     fmt.Println("m, m2, m3:")
  14.     fmt.Println(m, m2, m3)
  16.     fmt.Println("Traversing map m")
  17.     for k, v := range m {
  18.         fmt.Println(k, v) // map是无序的，是一个哈希map
  19.     }
  21. }

不能保证遍历顺序，如需顺序，需要手动对key排序，取出所有的key，放进一个 slice中进行排序

  1. func main() {
  2.     rand.Seed(time.Now().UnixNano()) //初始化随机数种子
  4.     var scoreMap = make(map[string]int, 200)
  6.     for i := 0; i < 100; i++ {
  7.         key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
  8.         value := rand.Intn(100)          //生成0~99的随机整数
  9.         scoreMap[key] = value
  10.     }
  11.     //取出map中的所有key存入切片keys
  12.     var keys = make([]string, 0, 200)
  13.     for key := range scoreMap {
  14.         keys = append(keys, key)
  15.     }
  16.     //对切片进行排序
  17.     sort.Strings(keys)
  18.     //按照排序后的key遍历map
  19.     for _, key := range keys {
  20.         fmt.Println(key, scoreMap[key])
  21.     }
  22. }

6.map的key

map使用哈希表，必须可以比较相等
除了slice，map，function 的内建类型都可以作为key
struct类型不包含上述字段，也可也作为key

7.Map的底层实现

九、面向对象

go语言只支持封装，不支持多态和继承

go语言没有class，只有struct

1.结构体

以下是新建一个结构体的方法

  1.  package main //
  2.  import "fmt"
  4.  type Node struct {
  5.      Value int
  6.      left, right *Node
  7.  }
  9.  func main() {
  10.      var root Node
  11.      root = Node{Value: 3}
  12.      root.left = &Node{} // 通过 & 获取指针
  13.      root.right = &Node{5, nil, nil}
  14.      root.right.left = new(Node)
  16.      nodes := []Node{
  17.          {Value: 3},
  18.          {},
  19.          {6, nil, &root},
  20.      }
  21.      fmt.Println(nodes) // [{3 <nil> <nil>} {0 <nil> <nil>} {6 <nil> 0xc00000c060}]
  22.  }

2.自定义工厂函数

  1.  package main //
  2.  import "fmt"
  4.  type Node struct {
  5.      Value int
  6.      left, right *Node
  7.  }
  8.  // 自定义工厂函数
  9.  func creatNode(value int) *Node {
  10.      return &Node{Value: value} // 返回了一个局部变量
  11.  }
  13.  func main() {
  14.      var root Node
  15.      root = Node{Value: 3}
  16.      root.left = &Node{} // 通过 & 获取指针
  17.      root.right = &Node{5, nil, nil}
  18.      root.right.left = new(Node)
  19.      root.left.right = creatNode(2)
  20.      fmt.Println(root.left.right) // {2 <nil> <nil>}
  21.      nodes := []Node{
  23.          {Value: 3},
  24.          {},
  25.          {6, nil, &root},
  26.      }
  27.      fmt.Println(nodes) // [{3 <nil> <nil>} {0 <nil> <nil>} {6 <nil> 0xc00000c060}]
  28.  }

工厂函数是一个普通函数，返回一个指针，这个指针是一个局部变量的地址。
通过以上代码我们创建了一棵如下的 树：
image.png

3.内存分配

结构的创建是在堆上还是栈上？
其他语言，像局部变量分配在栈上，函数退出局部变量就会立即销毁，如果要穿出去就需要在堆上，C++ 需要手动释放，其他语言会进行GC垃圾回收。
go语言中编译器会根据运行环境自动分配，如果变量没有取地址并且没有返回出去就会在栈上分配，如果返回出去就会分配在堆中，会参与垃圾回收。

3.方法

定义方法不能写在结构体里面，而是写在结构体外面。
它的特点是需要有一个接收者。

  1.  package main //
  2.  import "fmt"
  4.  type Node struct {
  5.      Value int
  6.      left, right *Node
  7.  }
  9.  func (node Node) Print() {
  10.      fmt.Print(node.Value, " ")
  11.  }
  13.  func main() {
  14.      var root Node
  15.      root = Node{Value: 3}
  16.      root.Print()
  17.  }

go语言的方法是需要有一个接收者，node Node 就是Print的接收者。
相当于下面的写法：

  1.  package main //
  2.  import "fmt"
  4.  type Node struct {
  5.      Value int
  6.      left, right *Node
  7.  }
  8.  // 方法
  9.  func (node Node) Print() {
  10.      fmt.Print(node.Value, " ")
  11.  }
  12.  // 上面的写法等价与下面的
  13.  func Print1(node Node) {
  14.     fmt.Print(node.Value, " ")
  15.  }
  17.  func main() {
  18.      var root Node
  19.      root = Node{Value: 3}
  20.      root.Print()
  21.      Print(root)
  22.  }

4.值传递和指针传递

  1.  package main //
  2.  import "fmt"
  4.  type Node struct {
  5.      Value int
  6.      left, right *Node
  7.  }
  8.  // 自定义工厂函数
  9.  func creatNode(value int) *Node {
  10.     return &Node{Value: value} // 返回了一个局部变量
  11.  }
  13.  // 方法
  14.  func (node Node) Print1() {
  15.      fmt.Print(node.Value, " ")
  16.  }
  17.  // 上面的写法等价与下面的
  18.  func Print2(node Node) {
  19.     fmt.Print(node.Value, " ")
  20.  }
  21.  // 值传递
  22.  func (node Node) setValue(value int){
  23.      node.Value = value
  24.  }
  26.  func main() {
  27.      var root Node
  28.      root = Node{Value: 3}
  29.      root.left = &Node{} // 通过 & 获取指针
  30.      root.right = &Node{5, nil, nil}
  31.      root.right.left = new(Node)
  32.      root.left.right = creatNode(2)
  33.      Print2(root)
  34.      root.setValue(13)
  35.      root.Print1() // 依旧是 3
  36.      root.right.left.setValue(10)
  37.      root.right.left.Print1() // 依旧是 0 
  38.  }

方法里面的参数都是值传递，改变拷贝参数并不能修改原参数。要想改变原参数必须使用指针，通过指针可以修改原参数，如下：

  1.  package main //
  2.  import "fmt"
  4.  type Node struct {
  5.      Value int
  6.      left, right *Node
  7.  }
  8.  // 自定义工厂函数
  9.  func creatNode(value int) *Node {
  10.     return &Node{Value: value} // 返回了一个局部变量
  11.  }
  13.  // 方法
  14.  func (node Node) Print1() {
  15.      fmt.Print(node.Value, " ")
  16.  }
  17.  // 上面的写法等价与下面的
  18.  func Print2(node Node) {
  19.     fmt.Print(node.Value, " ")
  20.  }
  21.  // 值传递
  22.  func (node *Node) setValue(value int){
  23.      node.Value = value
  24.  }
  26.  func main() {
  27.      var root Node
  28.      root = Node{Value: 3}
  29.      root.left = &Node{} // 通过 & 获取指针
  30.      root.right = &Node{5, nil, nil}
  31.      root.right.left = new(Node)
  32.      root.left.right = creatNode(2)
  33.      Print2(root)
  34.      root.setValue(13)
  35.      root.Print1() // 依旧是 3
  36.      root.right.left.setValue(10)
  37.      root.right.left.Print1() // 依旧是 0 
  38.  }

*Node 指针引用传递之后，调用 setValue 就是将 root.right.left 的地址传递给了参数，从而可以改变原值。

5.包和封装

封装：
名字一般使用 驼峰写法
首字母大写：public
首字母小写：private
包：
每个目录一个包，包名可以和目录名不同。
main包包含可执行入口，一个目录下只能有一个main包。
为结构定义的方法必须放在同一个包内，可以不是同一个文件。

结构名不用重复 包名
image.png

6.扩展已有类型

定义别名或者使用组合

  1. func (myNode *myTreeNode) postOrder() {
  2.     if myNode == nil || myNode.node == nil {
  3.         return
  4.     }
  6.     left := myTreeNode{myNode.node.Left}
  7.     right := myTreeNode{myNode.node.Right}
  9.     left.postOrder()
  10.     right.postOrder()
  11.     myNode.node.Print()
  12. }

十、面向接口

1.接口的定义

实现者和使用者

接口由使用者定义

实现一个接口 interface

在接口里面定义方法，

只要某个结构体实现了这个接口里的方法，就实现了这个接口。

如下：

  1. package main 
  3. import "fmt"
  4. // 接口
  5. type Sayer interface {
  6.     say()
  7. }
  8. // dog 是结构体 实现了接口的 say方法
  9. func ( d dog) say {
  10.     fmt.Println("哇哇哇")
  11. }
  12. // cat 是结构体 实现了接口的 say方法
  13. func (c cat) say {
  14.     fmt.Println("喵喵喵")
  15. }
  17. func main() {
  18.     var x Sayer
  19.     d := dog{}
  20.     x = d
  21.     fmt.Println(x.say())
  22. }
  2. type Cat struct{}
  4. type Dog struct{}

十一、函数式编程

十二、并发

1.goroutine

2.runtime

3.channel

4.Goroutine

5.select

十三、http

1.服务端

通过 ListenAndServe 使用指定的监听地址和处理器启动一个HTTP服务端。处理器参数通常是nil，这表示采用包变量 DefaultServeMux 作为处理器。
Handle和HandleFunc函数可以向DefaultServeMux添加处理器。

  1. package main
  3. import "net/http"
  5. func f1(w http.ResponseWriter, r *http.Request) {
  6.     str := `<h1>hello world</h1>`
  7.     w.Write([]byte(str))
  8. }
  10. func main() {
  11.     http.HandleFunc("/posts/Go/15_socket/", f1) // 处理端口下的某个路径
  12.     http.ListenAndServe("127.0.0.1:9000", nil) // 监听端口并开启服务
  13. }

将上面的代码编译之后执行，打开你电脑上的浏览器在地址栏输入127.0.0.1:9000//posts/Go/15_socket/回车，此时就能够看到hello world。

2.客户端

2.1 get

客户端发送get请求

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "net/http"
  7. )
  9. func main() {
  10.     resp, err := http.Get("http://127.0.0.1:9000/test/?name=lyt&age=18")
  11.     if err != nil {
  12.         fmt.Printf("get url failed")
  13.         return
  14.     }
  15.     defer resp.Body.Close() // 关闭连接
  16.     body, err := ioutil.ReadAll(resp.Body)
  17.     if err != nil {
  18.         fmt.Println("read from resp.Body failed")
  19.         return
  20.     }
  21.     fmt.Println(string(body))
  22. }

resp是客户端发送过来的响应体，通过 ioutil.ReadAll(resp.Body) 就可以拿到想要的响应内容。
服务端监听请求

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "net/http"
  7. )
  9. func f1(w http.ResponseWriter, r *http.Request) {
  10.     //str := `<h1>hello world</h1>`
  11.     res, err := ioutil.ReadFile("./test.txt") // ioutil.ReadFile 读文件
  12.     if err != nil {
  13.         w.Write([]byte(fmt.Sprintf("%v", err)))
  14.     }
  15.     w.Write(res) // 响应内容
  16. }
  18. func f2(w http.ResponseWriter, r *http.Request) {
  19.     fmt.Println(r.URL) // 请求url
  20.     // 对于Get请求，参数都放在Url上，
  21.     queryParam := r.URL.Query()
  22.     name := queryParam.Get("name")
  23.     age :=queryParam.Get("age")
  24.     fmt.Println(name)
  25.     fmt.Println(age)
  26.     fmt.Println(r.Method) // 请求方法
  27.     fmt.Println(ioutil.ReadAll(r.Body)) // 请求体
  28.     w.Write([]byte("ok")) // 响应内容
  29. }
  31. func main() {
  32.     http.HandleFunc("/posts/Go/15_socket/", f1) // 处理端口下的某个路径
  33.     http.HandleFunc("/test/", f2)
  34.     http.ListenAndServe("127.0.0.1:9000", nil) // 监听端口并开启服务
  35. }

服务端要处理客户端传参可以使用 URL.Query() 拿到参数体。
w.Write([]byte(“ok”)) 发送响应内容。

2.2 post请求

客户端发送post请求

  1. func postRequest() {
  2.     url := "http://127.0.0.1:9000/posttest"
  3.     contentType := "application/json"
  4.     data := `{"name": "小王子", "age": 18}`
  5.     resp, err := http.Post(url, contentType, strings.NewReader(data))
  6.     if err != nil {
  7.         fmt.Println("post failed")
  8.         return
  9.     }
  10.     defer resp.Body.Close()
  11.     b, err := ioutil.ReadAll(resp.Body)
  12.     if err != nil {
  13.         fmt.Println("get resp failed")
  14.         return
  15.     }
  16.     fmt.Println(string(b)) // b 返回的是字节类型，要转成string
  17. }

对应的服务端代码

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "net/http"
  7. )
  9. func f3(w http.ResponseWriter, r *http.Request) {
  10.     defer r.Body.Close()
  11.     // 1.请求类型是application/x-www-form-urlencoded时解析form数据
  12.     r.ParseForm()
  13.     fmt.Println(r.PostForm) // 打印form数据
  14.     fmt.Println(r.PostForm.Get("name"), r.PostForm.Get("age"))
  15.     // 2. 请求类型是application/json时从r.Body读取数据
  16.     b, err := ioutil.ReadAll(r.Body)
  17.     if err != nil {
  18.         fmt.Printf("read request.Body failed, err:%v\n", err)
  19.         return
  20.     }
  21.     fmt.Println(string(b))
  22.     answer := `{"status": "ok"}`
  23.     w.Write([]byte(answer))
  24. }
  26. func main() {
  27.     http.HandleFunc("/posttest/", f3)
  28.     http.ListenAndServe("127.0.0.1:9000", nil) // 监听端口并开启服务
  29. }

自定义请求

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "net/http"
  7.     "net/url"
  8.     "strings"
  9. )
  10. // 共用一个client连接，适用于请求比较频繁
  11. var (
  12.     client = http.Client{
  13.         Transport: &http.Transport{
  14.             DisableKeepAlives:true,
  15.         },
  16.     }
  17. )
  19. // 自定义请求
  21. func customRequest () {
  22.     data := url.Values{}
  23.     urlObj, _ := url.Parse("http://127.0.0.1:9000/test/")  // Parse函数解析rawurl为一个URL结构体，rawurl可以是绝对地址，也可以是相对地址。
  24.     data.Set("name", "lyt")
  25.     data.Set("age", 18)
  26.     queryStr := data.Encode() // URL Encode转译之后的url
  27.     fmt.Println(queryStr)
  28.     urlObj.RawQuery = queryStr // RawQuery 编码之后的url， 没有 ？
  29.     req, err := http.NewRequest("GET", urlObj.String(), nil)
  30.     resp, err := http.DefaultClient.Do(req) // 造一个客户端
  31.     if err != nil {
  32.         fmt.Println("get url failed")
  33.         return
  34.     }
  35.     defer resp.Body.Close()
  36.     b, err := ioutil.ReadAll(resp.Body)
  37.     if err != nil {
  38.         fmt.Println("read resp.Body failed")
  39.         return
  40.     }
  41.     fmt.Println(string(b))
  42.     //自定义client头部 禁用keepAlive 短连接  适用于请求没那么频繁
  43.     tr := &http.Transport{
  44.         Proxy:                  nil,
  45.         DialContext:            nil,
  46.         Dial:                   nil,
  47.         DialTLS:                nil,
  48.         TLSClientConfig:        nil,
  49.         TLSHandshakeTimeout:    0,
  50.         DisableKeepAlives:      true,
  51.         DisableCompression:     false,
  52.         MaxIdleConns:           0,
  53.         MaxIdleConnsPerHost:    0,
  54.         MaxConnsPerHost:        0,
  55.         IdleConnTimeout:        0,
  56.         ResponseHeaderTimeout:  0,
  57.         ExpectContinueTimeout:  0,
  58.         TLSNextProto:           nil,
  59.         ProxyConnectHeader:     nil,
  60.         MaxResponseHeaderBytes: 0,
  61.     }
  62.     client := http.Client{
  63.         Transport:     tr,
  64.         CheckRedirect: nil,
  65.         Jar:           nil,
  66.         Timeout:       0,
  67.     }
  68.     client.Do(req)
  69. }
  71. func main() {
  72.     getRequest()
  73.     postRequest()
  74.     customRequest ()
  75. }

url.Values{} 创建一个url参数体
url.Parse 解析一个地址为url结构体
data.Encode() 将参数部分转译成一个编码之后的
urlObj.RawQuery = queryStr 将参数拼接到url后并且转译
http.NewRequest 开启一个新的请求
要管理代理、TLS配置、keep-alive、压缩和其他设置，创建一个Transport：

  1. tr := &http.Transport{
  2.         Proxy:                  nil,
  3.         DialContext:            nil,
  4.         Dial:                   nil,
  5.         DialTLS:                nil,
  6.         TLSClientConfig:        nil,
  7.         TLSHandshakeTimeout:    0,
  8.         DisableKeepAlives:      true,
  9.         DisableCompression:     false,
  10.         MaxIdleConns:           0,
  11.         MaxIdleConnsPerHost:    0,
  12.         MaxConnsPerHost:        0,
  13.         IdleConnTimeout:        0,
  14.         ResponseHeaderTimeout:  0,
  15.         ExpectContinueTimeout:  0,
  16.         TLSNextProto:           nil,
  17.         ProxyConnectHeader:     nil,
  18.         MaxResponseHeaderBytes: 0,
  19.     }
  20.     client := http.Client{
  21.         Transport:     tr,
  22.         CheckRedirect: nil,
  23.         Jar:           nil,
  24.         Timeout:       0,
  25.     }
  26.     client.Do(req)

Client和Transport类型都可以安全的被多个go程同时使用。出于效率考虑，应该一次建立、尽量重用。

golang 项目开发实战