定义变量

变量类型写在变量名之后

  1. var a int = 2
  2. var a, b int = 3, 4
  4. // 使用 ":=" 来代替var，这个语法只能在func内使用，在保内变量是不能使用的
  5. // 可以不声明参数类型，编译器会自动判断类型
  6. a, b, c, d := 1, 2, true, "def"
  7. // 在包内部可以使用var批量定义
  8. var (
  9.     aa = 3
  10.     bb = "ss"
  11. )

内建变量类型

  1. bool、string
  2. (u)int,(u)int8,(u)int16,(u)int32,(u)int64,uintptr：指针;        u代表无符号,正数
  3. byte：8位, rune：32位，rune等同于char
  4. float32, float64, complex64, complex128；complex为复数
  7.     // 十进制
  8.     i1 := 10
  9.     fmt.Printf("%d\n", i1)
  10.     fmt.Printf("%b\n", i1) // 十进制转二进制
  11.     fmt.Printf("%o\n", i1) // 十进制转八进制
  12.     fmt.Printf("%x\n", i1) // 十进制转十六进制
  13.     fmt.Printf("%T\n", i1) // 查看类型
  14.     // 强制转换
  15.     i2 := int8(i1)
  16.     i3 := int16(i1)
  17.     fmt.Printf("%T\n", i2)
  18.     fmt.Printf("%T\n", i3)

强制类型转换

  1. func triangle() {
  2.     var a, b int = 3, 4
  3.     var c int
  4.     // Sqrt的参数为float64
  5.     c = int(math.Sqrt(float64(a*a + b*b)))
  6.     fmt.Println(c)
  7. }

常量

使用const定义常量，go语言中常量不使用全部大写

  1. func consts() {
  2.     const fileName = "a.txt"
  3.     const a, b = 3, 4
  4.     var c int
  5.     c = int(math.Sqrt(a*a + b*b))
  6.     fmt.Println(c)
  7. }

枚举常量

iota是自增值，

  1. // 如果后面没有赋值，则都是第一个元素的值
  2. const(
  3.     n1 = 100
  4.     n2 
  5.     n3
  6. )
  8. func enums() {
  9.     const (
  10.         java = iota
  11.         php
  12.         python
  13.         golang
  14.     )
  16.     const (
  17.         b = 1 << (10 * iota)
  18.         kb
  19.         mb
  20.         gb
  21.         tb
  22.         pb
  23.     )
  24.     fmt.Println(java, php, python, golang)
  25.     // 0 1 2 3
  26.     fmt.Println(b, kb, mb, gb, tb, pb)
  27.     // 1 1024 1048576 1073741824 1099511627776 1125899906842624
  28. }

判断

go语言中是没有括号的

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6. )
  8. func main() {
  9.     const filename = "a.txt"
  10.     contents, err := ioutil.ReadFile(filename)
  11.     // go语言中是没有括号的
  12.     if err != nil {
  13.         fmt.Println(err)
  14.     } else {
  15.         fmt.Printf("%s\n", contents)
  16.     }
  18.     // 也可以一起写，弊端就是返回的参数只能在if中使用，因为他的作用域就是if判断
  19.     if contents, err := ioutil.ReadFile(filename); err != nil {
  20.         fmt.Println(err)
  21.     } else {
  22.         fmt.Printf("%s\n", contents)
  23.     }
  24. }

switch

不需要break，默认就有

  1. func grade(score int) string {
  2.     g := ""
  3.     switch {
  4.     case score < 60:
  5.         g = "F"
  6.     case score < 80:
  7.         g = "C"
  8.     case score < 90:
  9.         g = "B"
  10.         fallthrough  // 如果是用该函数,则满足score<90以后会继续执行下一个case,也就是score<=100
  11.     case score <= 100:
  12.         g = "A"
  13.     default:
  14.         // panic会中断执行，进行报错
  15.         panic(fmt.Sprintf("Wrong score：%d", score))
  16.     }
  17.     return g
  18. }

for

go语言中没有括号，并且可以省略初始条件、递增条件

  1. func convertToBin(n int) string {
  2.     res := ""
  3.     for ; n > 0; n /= 2 {
  4.         lsb := n % 2
  5.         res = strconv.Itoa(lsb) + res
  6.     }
  7.     return res
  8. }
  10. func readFile(filename string) {
  11.     file, err := os.Open(filename)
  12.     if err != nil {
  13.         panic(err)
  14.     }
  15.     scanner := bufio.NewScanner(file)
  16.     for scanner.Scan() {
  17.         fmt.Println(scanner.Text())
  18.     }
  19. }
  21. func forever() {
  22.     // 什么条件都没有就是死循环
  23.     for {
  24.         fmt.Println("死循环")
  25.     }
  26. }
  28. for i := 0; i < 10; i++ {
  29.     if i == 5 {
  30.         // 跳出for循环
  31.         break
  32.     }
  33.     fmt.Println(i)
  34. }
  36. for i := 0; i < 10; i++ {
  37.     if i == 5 {
  38.         // 跳过本次循环
  39.         continue
  40.     }
  41.     fmt.Println(i)
  42. }

函数

go是函数式编程，可以返回多个值。通常情况下，第一个值是返回值，第二个值是错误
没有默认参数，可选参数，可以直接写匿名函数传递过去

  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6.     "reflect"
  7.     "runtime"
  8. )
  10. func main() {
  11.     i3, err := eval(1, 2, "1+")
  12.     if err != nil {
  13.         fmt.Println(err)
  14.     }
  15.     fmt.Println(i3)
  17.     i, i2 := div(13, 3)
  18.     fmt.Println(i, i2)
  19.     q, r := div1(13, 3)
  20.     fmt.Println(q, r)
  21.     x, _ := div1(13, 3)
  22.     fmt.Println(x)
  24.     fmt.Println(apply(func(a int, b int) int {
  25.         return int(math.Pow(float64(a), float64(b)))
  26.     }, 3, 4))
  27. }
  29. func eval(a, b int, op string) (int, error) {
  30.     switch op {
  31.     case "+":
  32.         return a + b, nil
  33.     case "-":
  34.         return a - b, nil
  35.     case "*":
  36.         return a * b, nil
  37.     case "/":
  38.         return a / b, nil
  39.     default:
  40.         return 0, fmt.Errorf("unsupported operation: &s" + op)
  41.     }
  42. }
  44. func div(a, b int) (int, int) {
  45.     return a / b, a % b
  46. }
  47. func div1(a, b int) (q, r int) {
  48.     q = a / b
  49.     r = a % b
  50.     return
  51. }
  53. func apply(op func(int, int) int, a, b int) int {
  54.     p := reflect.ValueOf(op).Pointer()
  55.     opName := runtime.FuncForPC(p).Name()
  56.     fmt.Printf("Calling function %s with atgs (%d, %d)\n", opName, a, b)
  57.     return op(a, b)
  58. }

指针、数传递

“”代表指针
Go语言只有值传递一种方式
var a int = 1
&a 代表内存地址
pa int 引用a

  1.     a, b := 1, 2
  2.     swap(&a, &b)
  3.     fmt.Println(a, b)
  5. func swap(a, b *int) {
  6.     *a, *b = *b, *a
  7. }

数组

定义数组可以使用var来定义，也可以是用:=来定义。如果是用:=来定义后面需要跟上具体设置的值。
也可以不写前面的数组大小，但是需要把具体数值使用[…]来代替
数组是值类型，会拷贝数组，在调用方法中修改值，原始值是不会被修改的，可以是用指针，将内存地址传递过去修改值

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var arr1 [5]int
  7.     arr2 := [2]int{1, 2}
  8.     arr3 := [...]int{2, 3, 4}
  9.     fmt.Println(arr1, arr2, arr3)
  11.     // 二维数组
  12.     var gaid [4][5]int
  13.     fmt.Println(gaid)
  14.     printArray(arr3)
  15.     printArray1(&arr3)
  16. }
  18. func printArray(arr [3]int) {
  19.     // 循环数组
  20.     for k, v := range arr {
  21.         fmt.Println(k, v)
  22.     }
  23.     arr[1] = 200
  24. }
  26. func printArray1(arr *[3]int) {
  27.     // 循环数组
  28.     for k, v := range arr {
  29.         fmt.Println(k, v)
  30.     }
  31.     arr[1] = 200
  32. }

切片(slice)

Slice本身没有数据，是对底层array的一个view

  1. package main
  3. import "fmt"
  5. func main() {
  6.     arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8}
  7.     fmt.Println("arr[2:6]", arr[2:6])
  8.     fmt.Println("arr[:6]", arr[:6])
  9.     s1 := arr[2:]
  10.     fmt.Println("s1", s1)
  11.     s2 := arr[:]
  12.     fmt.Println("s2", s2)
  14.     fmt.Println("After updateSlice(s1)")
  15.     updateSlice(s1)
  16.     fmt.Println(s1)
  17.     fmt.Println(arr)
  19.     fmt.Println("After updateSlice(s2)")
  20.     updateSlice(s2)
  21.     fmt.Println(s2)
  22.     fmt.Println(arr)
  24.     fmt.Println("Reslice")
  25.     s2 = s2[:5]
  26.     fmt.Println(s2)
  27.     s2 = s2[2:]
  28.     fmt.Println(s2)
  29. }
  31. func updateSlice(s []int) {
  32.     s[0] = 100
  33. }

运行结果

  1. arr[2:6] [2 3 4 5]
  2. arr[:6] [0 1 2 3 4 5]
  3. s1 [2 3 4 5 6 7 8]
  4. s2 [0 1 2 3 4 5 6 7 8]
  5. After updateSlice(s1)
  6. [100 3 4 5 6 7 8]
  7. [0 1 100 3 4 5 6 7 8]
  8. After updateSlice(s2)
  9. [100 1 100 3 4 5 6 7 8]
  10. [100 1 100 3 4 5 6 7 8]
  11. Reslice
  12. [100 1 100 3 4]
  13. [100 3 4]

slice扩展

slice可以向后扩展，不可以向前扩展。
s[i]不可以超越len[s]，向后扩展不可以超越底层数组cap(s)
append添加的时候如果超过原始数组的大小，继续append的话就无法匹配到原始数组

  1.     fmt.Println("Extending slice")
  2.     arr1 := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
  3.     s11 := arr1[2:6]
  4.     fmt.Printf("s11=%v, len(s11)=%d, cap(s11)=%d\n",
  5.         s11, len(s11), cap(s11))
  6.     s22 := s11[3:5]
  7.     fmt.Printf("s22=%v, len(s22)=%d, cap(s22)=%d\n",
  8.         s22, len(s22), cap(s22))
  10.     s3 := append(s22, 10)
  11.     s4 := append(s3, 11)
  12.     s5 := append(s4, 12)
  13.     fmt.Println(s3, s4, s5)
  14.     fmt.Println(arr1)

结果

  1. Extending slice
  2. s11=[2 3 4 5], len(s11)=4, cap(s11)=6
  3. s22=[5 6], len(s22)=2, cap(s22)=3
  4. [5 6 10] [5 6 10 11] [5 6 10 11 12]
  5. [0 1 2 3 4 5 6 10]
  1. package main
  3. import "fmt"
  5. func main() {
  6.     // Zero value for slice is nil
  7.     var s []int
  8.     for i := 0; i < 100; i++ {
  9.         printSlice(s)
  10.         s = append(s, 2*i+1)
  11.     }
  12.     fmt.Println(s)
  14.     s1 := []int{2, 4, 6, 8}
  15.     printSlice(s1)
  17.     // 创建空slice
  18.     s2 := make([]int, 16)
  19.     s3 := make([]int, 10, 32)
  20.     printSlice(s2)
  21.     printSlice(s3)
  23.     fmt.Println("Copying slice")
  24.     copy(s2, s1)
  25.     printSlice(s2)
  27.     fmt.Println("Deleting elements from slice")
  28.     s2 = append(s2[:3], s2[4:]...)
  29.     printSlice(s2)
  31.     fmt.Println("Popping from front")
  32.     front := s2[0]
  33.     fmt.Println(front)
  34.     s2 = s2[1:]
  35.     printSlice(s2)
  37.     fmt.Println("Popping from back")
  38.     tail := s2[len(s2)-1]
  39.     fmt.Println(tail)
  40.     s2 = s2[:len(s2)-1]
  41.     printSlice(s2)
  42. }
  44. func printSlice(s []int) {
  45.     fmt.Printf("%v, len=%d, cap=%d\n", s, len(s), cap(s))
  46. }

结果

  1. [1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179 181 183 185 187 189 191 193 195 197 199]
  2. [2 4 6 8], len=4, cap=4
  3. [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], len=16, cap=16
  4. [0 0 0 0 0 0 0 0 0 0], len=10, cap=32
  5. Copying slice
  6. [2 4 6 8 0 0 0 0 0 0 0 0 0 0 0 0], len=16, cap=16
  7. Deleting elements from slice
  8. [2 4 6 0 0 0 0 0 0 0 0 0 0 0 0], len=15, cap=16
  9. Popping from front
  10. 2
  11. [4 6 0 0 0 0 0 0 0 0 0 0 0 0], len=14, cap=15
  12. Popping from back
  13. 0
  14. [4 6 0 0 0 0 0 0 0 0 0 0 0], len=13, cap=15

Map

创建使用：make(map[string]in)
获取元素：m[key]
map使用哈希表，必须可以比较相等
除了slice，map，function的内建类型都可以作为key
struct类型不包含上述字段，也可作为key

  1. package main
  3. import "fmt"
  5. func main() {
  6.     m := map[string]string{
  7.         "name":    "李四",
  8.         "course":  "golang",
  9.         "site":    "imooc",
  10.         "quality": "notbad",
  11.     }
  13.     m2 := make(map[string]int)
  15.     var m3 map[string]int
  17.     fmt.Println(m, m2, m3)
  19.     fmt.Println("Traversing map")
  20.     for k, s := range m {
  21.         fmt.Println(k, s)
  22.     }
  24.     fmt.Println("Getting values")
  25.     courseName := m["course"]
  26.     fmt.Println(courseName)
  27.     // 当值不存在时不会报错，打印为空
  28.     coursName := m["cours"]
  29.     fmt.Println(coursName)
  30.     // 当值不存在时不会报错，打印为空，接收第二个参数
  31.     coursName1, ok := m["cours"]
  32.     fmt.Println(coursName1, ok)
  34.     fmt.Println("Deleting values")
  35.     name, ok := m["name"]
  36.     fmt.Println(name, ok)
  37.     delete(m, "name")
  38.     name, ok = m["name"]
  39.     fmt.Println(name, ok)
  40. }

结果

  1. map[course:golang name:李四 quality:notbad site:imooc] map[] map[]
  2. Traversing map
  3. quality notbad
  4. name 李四
  5. course golang
  6. site imooc
  7. Getting values
  8. golang
  10.  false
  11. Deleting values
  12. 李四 true
  13.  false

Map实例：寻找最长不含有重复字符的字串

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println(
  7.         lengthOfNonRepeatingSubStr("abcabcbb"),
  8.         lengthOfNonRepeatingSubStr("aaaaaaa"),
  9.         lengthOfNonRepeatingSubStr("123456"),
  10.         lengthOfNonRepeatingSubStr("123456pwwkew"),
  11.         lengthOfNonRepeatingSubStr("121234w"),
  12.     )
  13. }
  15. func lengthOfNonRepeatingSubStr(s string) int {
  16.     lastOccurred := make(map[byte]int)
  17.     start := 0
  18.     maxLength := 0
  19.     for i, ch := range []byte(s) {
  20.         if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
  21.             start = lastOccurred[ch] + 1
  22.         }
  23.         if i-start+1 > maxLength {
  24.             maxLength = i - start + 1
  25.         }
  26.         lastOccurred[ch] = i
  27.     }
  28.     return maxLength
  29. }

结果

  1. 3 1 6 8 5

rune：go语言的char

使用range遍历pos、rune
使用utf8.RuneCountInString获得字符数量
使用len获得字节长度
使用[]byte获得字节

  1. package main
  3. import (
  4.     "fmt"
  5.     "unicode/utf8"
  6. )
  8. func main() {
  9.     s := "a一个字符串!."
  10.     fmt.Println(len(s))
  11.     fmt.Printf("%s\n", []byte(s))
  13.     for _, b := range []byte(s) {
  14.         fmt.Printf("%X ", b)
  15.     }
  16.     fmt.Println()
  18.     for i, ch := range s {
  19.         fmt.Printf("(%d %X) ", i, ch)
  20.     }
  21.     fmt.Println()
  23.     fmt.Println("Rune count:", utf8.RuneCountInString(s))
  25.     bytes := []byte(s)
  26.     for len(bytes) > 0 {
  27.         ch, size := utf8.DecodeRune(bytes)
  28.         bytes = bytes[size:]
  29.         fmt.Printf("%c ", ch)
  30.     }
  31.     fmt.Println()
  33.     for i, ch := range []rune(s) {
  34.         fmt.Printf("(%d %c) ", i, ch)
  35.     }
  36.     fmt.Println()
  37. }

结果

  1. 18
  2. a一个字符串!.
  3. 61 E4 B8 80 E4 B8 AA E5 AD 97 E7 AC A6 E4 B8 B2 21 2E 
  4. (0 61) (1 4E00) (4 4E2A) (7 5B57) (10 7B26) (13 4E32) (16 21) (17 2E) 
  5. Rune count: 8
  6. a 一 个 字 符 串 ! . 
  7. (0 a) (1 一) (2 个) (3 字) (4 符) (5 串) (6 !) (7 .)

面向对象

go语言仅支持封装，不支持继承和多态，没有构造函数

  1. package main
  3. import "fmt"
  5. type treeNode struct {
  6.     value       int
  7.     left, right *treeNode
  8. }
  10. func main() {
  11.     var root treeNode
  13.     root = treeNode{value: 3}
  14.     root.left = &treeNode{}
  15.     root.right = &treeNode{5, nil, nil}
  16.     root.right.left = new(treeNode)
  17.     root.left.right = createNode(2)
  18.     root.right.left.setValue(4)
  20.     root.traverse()
  21.     //root.print()
  22.     fmt.Println()
  23. }
  24. func (node *treeNode) traverse() {
  25.     if node == nil {
  26.         return
  27.     }
  28.     node.left.traverse()
  29.     node.print()
  30.     node.right.traverse()
  31. }
  32. func createNode(value int) *treeNode {
  33.     return &treeNode{value: value}
  34. }
  36. /**
  37. 和别的语言语法不同，接收的参数在前面，不过也可以写到方法名括号里面。如：
  38. func print(node treeNode)
  39. 如果是上面这种写法的话，调用的时候就是print(参数)
  40. */
  41. func (node treeNode) print() {
  42.     fmt.Print(node.value)
  43. }
  45. func (node *treeNode) setValue(value int) {
  46.     node.value = value
  47. }

值接受者 vs 指针接收者

要改变内容必须使用指针接收者
结构过大也考虑使用指针接收者
一致性：如果有指针接收者，最好都是指针接收者
值接受者是go语言特有

封装

名字一般使用CamelCase
首字母大写：public
首字母小写：private
这里的public、private针对包来说

包

为结构定义的方法必须放在同一个保内
可以是不同文件
go语言没有继承，那如何扩充系统类型
定义别名：最简单
使用组合：最常用
使用内嵌：省下许多代码

依赖管理

依赖管理的三个阶段：GOPATH、GOVENDOR、go mod

go mod由go命令统一的管理，用户不必关心目录结构

  1. go mod tidy // 清洁go.sum
  3. // 拉取依赖
  4. go get -u go.uber.org/zap 
  5. go get -u go.uber.org/zap@v1.11 // 获取指定版本的插件

迁移旧项目至go.mod

  1. 1. 创建go.mod文件
  2.     go mod init ‘包名’
  3. 2. 编译
  4.      go build ./...

接口

go语言是面向接口的语言，go语言中不需要实现就可以使用接口。严格说go属于结构化类型系统，类似duck typing。接口由使用者定义
duck typing：描述事物的外部行为而非内部结构

函数式编程vs函数指针

函数是一等公民：参数、变量、返回值都可以是函数
高阶函数
函数->闭包
“正统”函数式编程
不可变性：不能有状态，只有常量和函数
函数只能有一个参数

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "io"
  7.     "strings"
  8. )
  9. // 斐波那契
  10. func fibonacci() intGen {
  11.     a, b := 0, 1
  12.     return func() int {
  13.         a, b = b, a+b
  14.         return a
  15.     }
  16. }
  18. type intGen func() int
  20. func (g intGen) Read(p []byte) (n int, err error) {
  21.     next := g()
  22.     if next > 10000 {
  23.         return 0, io.EOF
  24.     }
  25.     s := fmt.Sprintf("%d\n", next)
  26.     return strings.NewReader(s).Read(p)
  27. }
  29. func printFileContents(reader io.Reader) {
  30.     scanner := bufio.NewScanner(reader)
  32.     for scanner.Scan() {
  33.         fmt.Println(scanner.Text())
  34.     }
  35. }
  37. func main() {
  38.     f := fibonacci()
  39.     printFileContents(f)
  40. }

资源管理与出错处理

资源管理：比如说打开文件、关闭文件
defer调用来实现资源管理，确保调用结束时发生

测试

传统测试vs表格驱动测试

传统测试：

  1. 测试数据和测试逻辑混在一起
  2. 出错信息不明企鹅
  3. 一旦一个数据出错测试全部结束

表格驱动测试：

  1. 分离的测试数据和测试逻辑
  2. 明确的出错信息
  3. 可以部分失败
  4. go语言的语法是的我们更容易实现表格驱动测试

表格驱动测试demo

  1. package main
  3. import "testing"
  5. func TestTriangle(t *testing.T) {
  6.     tests := []struct{ a, b, c int }{
  7.         {3, 4, 5},
  8.         {8, 15, 17},
  9.         {10, 24, 26},
  10.         {12, 35, 37},
  11.         {30000, 40000, 50000},
  12.     }
  14.     for _, tt := range tests {
  15.         if actual := calcTriangle(tt.a, tt.b); actual != tt.c {
  16.             t.Errorf("calcTriangle(%d, %d); "+
  17.                 "got %d; expected %d",
  18.                 tt.a, tt.b, actual, tt.c)
  19.         }
  20.     }
  21. }