title: golang学习记录
tags:

  • go
  • 学习
    abbrlink: 74fdcb9a
    date: 2021-09-25 14:53:21

0x01 值

字符串可以通过+连接

  1. package main
  3. import "fmt"
  5. func main() {
  7.     fmt.Println("go" + "lang")
  9.     fmt.Println("1+1 =", 1+1)
  10.     fmt.Println("7.0/3.0 =", 7.0/3.0)
  12.     fmt.Println(true && false)
  13.     fmt.Println(true || false)
  14.     fmt.Println(!true)
  15. }

0x02 变量

可以使var声明1个或多个变量，也可以一次性声明多个变量，Go可以自动判断其数据类型，声明时如果无初值，则会初始化为零值

例如var f string = "short"可以写为f := "short"

  1. package main
  3. import "fmt"
  5. func main() {
  7.     var a = "initial"
  8.     fmt.Println(a)
  10.     var b, c int = 1, 2
  11.     fmt.Println(b, c)
  13.     var d = true
  14.     fmt.Println(d)
  16.     var e int
  17.     fmt.Println(e)
  19.     f := "short"
  20.     fmt.Println(f)
  21. }

0x03 常量

const用于声明一个常量，可以出现在任何var语句可以出现的地方，常数表达式可以执行任意精度的运算，数值型常量没有确定的类型，直到被给定某个类型。

一个数字可以根据上下文的需要（变量赋值，常数调用）自动确定类型。例如下文math.Sin需要一个float64的参数，n会自动确定类型。

  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. const s string = "constant"
  10. func main() {
  11.     fmt.Println(s)
  13.     const n = 500000000
  15.     const d = 3e20 / n
  16.     fmt.Println(d)
  18.     fmt.Println(int64(d))
  20.     fmt.Println(math.Sin(n))
  21. }

0x04 For循环

for是Go中唯一的循环结构，用法类同于C类语言

  1. package main
  3. import "fmt"
  5. func main() {
  7.     i := 1
  8.     for i <= 3 {
  9.         fmt.Println(i)
  10.         i = i + 1
  11.     }
  13.     for j := 7; j <= 9; j++ {
  14.         fmt.Println(j)
  15.     }
  17.     for {
  18.         fmt.Println("loop")
  19.         break
  20.     }
  22.     for n := 0; n <= 5; n++ {
  23.         if n%2 == 0 {
  24.             continue
  25.         }
  26.         fmt.Println(n)
  27.     }
  28. }

0x05 If/Else分支

用法类同于C类语言

需要注意的是，在 Go 中，条件语句的圆括号不是必需的，但是花括号是必需的。Go 没有三目运算符， 即使是基本的条件判断，依然需要使用完整的 if 语句。

  1. package main
  3. import "fmt"
  5. func main() {
  7.     if 7%2 == 0 {
  8.         fmt.Println("7 is even")
  9.     } else {
  10.         fmt.Println("7 is odd")
  11.     }
  13.     if 8%4 == 0 {
  14.         fmt.Println("8 is divisible by 4")
  15.     }
  17.     if num := 9; num < 0 {
  18.         fmt.Println(num, "is negative")
  19.     } else if num < 10 {
  20.         fmt.Println(num, "has 1 digit")
  21.     } else {
  22.         fmt.Println(num, "has multiple digits")
  23.     }
  24. }

0x06 Switch语句

Go中switch可以不使用常量，从而达到实现if/else逻辑的另一种方式

类型开关 (type switch) 比较类型而非值。可以用来发现一个接口值的类型。 在这个例子中，变量 t 在每个分支中会有相应的类型。

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  10.     i := 2
  11.     fmt.Print("write ", i, " as ")
  12.     switch i {
  13.     case 1:
  14.         fmt.Println("one")
  15.     case 2:
  16.         fmt.Println("two")
  17.     case 3:
  18.         fmt.Println("three")
  19.     }
  21.     switch time.Now().Weekday() {
  22.     case time.Saturday, time.Sunday:
  23.         fmt.Println("It's the weekend")
  24.     default:
  25.         fmt.Println("It's a weekday")
  26.     }
  28.     t := time.Now()
  29.     switch {
  30.     case t.Hour() < 12:
  31.         fmt.Println("It's before noon")
  32.     default:
  33.         fmt.Println("It's after noon")
  34.     }
  36.     whatAmI := func(i interface{}) {
  37.         switch t := i.(type) {
  38.         case bool:
  39.             fmt.Println("I'm a bool")
  40.         case int:
  41.             fmt.Println("I'm an int")
  42.         default:
  43.             fmt.Printf("Don't know type %T\n", t)
  44.         }
  45.     }
  46.     whatAmI(true)
  47.     whatAmI(1)
  48.     whatAmI("hey")
  49. }

0x07 数组

在Go中，数组是一个具有编号且长度固定的元素序列，数组默认值均为零值，内置len函数可以返回数组的长度。

注意，使用 fmt.Println 打印数组时，会按照 [v1 v2 v3 ...] 的格式打印。

  1. package main
  3. import "fmt"
  5. func main() {
  7.     var a [5]int
  8.     fmt.Println("emp:", a)
  10.     a[4] = 100
  11.     fmt.Println("set:", a)
  12.     fmt.Println("get:", a[4])
  14.     fmt.Println("len:", len(a))
  16.     b := [5]int{1, 2, 3, 4, 5}
  17.     fmt.Println("dcl:", b)
  19.     var twoD [2][3]int
  20.     for i := 0; i < 2; i++ {
  21.         for j := 0; j < 3; j++ {
  22.             twoD[i][j] = i + j
  23.         }
  24.     }
  25.     fmt.Println("2d: ", twoD)
  26. }

0x08 切片Slice

除了基本操作外，slice 支持比数组更丰富的操作。比如 slice 支持内建函数 append， 该函数会返回一个包含了一个或者多个新值的 slice。 注意由于 append 可能返回一个新的 slice，我们需要接收其返回值。

slice 还可以 copy。这里我们创建一个空的和 s 有相同长度的 slice——c， 然后将 s 复制给 c。

slice 支持通过 slice[low:high] 语法进行“切片”操作。 例如，右边的操作可以得到一个包含元素 s[2]、s[3] 和 s[4] 的 slice。

我们可以在一行代码中声明并初始化一个 slice 变量。

Slice 可以组成多维数据结构。内部的 slice 长度可以不一致，这一点和多维数组不同。

slice虽然和数组是不同的类型，但是通过fmt.Println打印的输出结果是类似的

  1. package main
  3. import "fmt"
  5. func main() {
  7.     s := make([]string, 3)
  8.     fmt.Println("emp:", s)
  10.     s[0] = "a"
  11.     s[1] = "b"
  12.     s[2] = "c"
  13.     fmt.Println("set:", s)
  14.     fmt.Println("get:", s[2])
  16.     fmt.Println("len:", len(s))
  18.     s = append(s, "d")
  19.     s = append(s, "e", "f")
  20.     fmt.Println("apd:", s)
  22.     c := make([]string, len(s))
  23.     copy(c, s)
  24.     fmt.Println("cpy:", c)
  26.     l := s[2:5]
  27.     fmt.Println("sl1:", l)
  29.     l = s[:5]
  30.     fmt.Println("sl2:", l)
  32.     l = s[2:]
  33.     fmt.Println("sl3:", l)
  35.     t := []string{"g", "h", "i"}
  36.     fmt.Println("dcl:", t)
  38.     twoD := make([][]int, 3)
  39.     for i := 0; i < 3; i++ {
  40.         innerLen := i + 1
  41.         twoD[i] = make([]int, innerLen)
  42.         for j := 0; j < innerLen; j++ {
  43.             twoD[i][j] = i + j
  44.         }
  45.     }
  46.     fmt.Println("2d: ", twoD)
  47. }
  1. $ go run slices.go
  2. emp: [  ]
  3. set: [a b c]
  4. get: c
  5. len: 3
  6. apd: [a b c d e f]
  7. cpy: [a b c d e f]
  8. sl1: [c d e]
  9. sl2: [a b c d e]
  10. sl3: [c d e f]
  11. dcl: [g h i]
  12. 2d:  [[0] [1 2] [2 3 4]]

0x09 Map

map与C++的STL的map类似

要创建一个空 map，需要使用内建函数 make：make(map[key-type]val-type)。使用fmt.Println可以输出它的所有键值，内建len获取长度和delete移除一个键值对

当从一个 map 中取值时，还有可以选择是否接收的第二个返回值，该值表明了 map 中是否存在这个键。 这可以用来消除 键不存在 和 键的值为零值 产生的歧义， 例如 0 和 ""。这里我们不需要值，所以用 空白标识符(blank identifier) _ 将其忽略。

注意，使用 fmt.Println 打印一个 map 的时候， 是以 map[k:v k:v] 的格式输出的。

  1. package main
  3. import "fmt"
  5. func main() {
  7.     m := make(map[string]int)
  9.     m["k1"] = 7
  10.     m["k2"] = 13
  12.     fmt.Println("map:", m)
  14.     v1 := m["k1"]
  15.     fmt.Println("v1: ", v1)
  17.     fmt.Println("len:", len(m))
  19.     delete(m, "k2")
  20.     fmt.Println("map:", m)
  22.     _, prs := m["k2"]
  23.     fmt.Println("prs:", prs)
  25.     n := map[string]int{"foo": 1, "bar": 2}
  26.     fmt.Println("map:", n)
  27. }
  1. $ go run maps.go 
  2. map: map[k1:7 k2:13]
  3. v1:  7
  4. len: 2
  5. map: map[k1:7]
  6. prs: false
  7. map: map[foo:1 bar:2]

0x10 Range遍历

range 在数组和 slice 中提供对每项的索引和值的访问。 有时我们不需要索引，所以我们使用 空白标识符 _ 将其忽略。

  1. package main
  3. import "fmt"
  5. func main() {
  7.     nums := []int{2, 3, 4}
  8.     sum := 0
  9.     for _, num := range nums {
  10.         sum += num
  11.     }
  12.     fmt.Println("sum:", sum)
  14.     for i, num := range nums {
  15.         if num == 3 {
  16.             fmt.Println("index:", i)
  17.         }
  18.     }
  20.     kvs := map[string]string{"a": "apple", "b": "banana"}
  21.     for k, v := range kvs {
  22.         fmt.Printf("%s -> %s\n", k, v)
  23.     }
  25.     for k := range kvs {
  26.         fmt.Println("key:", k)
  27.     }
  29.     for i, c := range "go" {
  30.         fmt.Println(i, c)
  31.     }
  32. }
  2. $ go run range.go
  3. sum: 9
  4. index: 1
  5. a -> apple
  6. b -> banana
  7. key: a
  8. key: b
  9. 0 103
  10. 1 111

0x11 函数

Go 需要明确的 return，也就是说，它不会自动 return 最后一个表达式的值

当多个连续的参数为同样类型时， 可以仅声明最后一个参数的类型，忽略之前相同类型参数的类型声明。

  1. package main
  3. import "fmt"
  5. func plus(a int, b int) int {
  7.     return a + b
  8. }
  10. func plusPlus(a, b, c int) int {
  11.     return a + b + c
  12. }
  14. func main() {
  16.     res := plus(1, 2)
  17.     fmt.Println("1+2 =", res)
  19.     res = plusPlus(1, 2, 3)
  20.     fmt.Println("1+2+3 =", res)
  21. }

0x12 多返回值

Go 原生支持 多返回值。 这个特性在 Go 语言中经常用到，例如用来同时返回一个函数的结果和错误信息。(int, int) 在这个函数中标志着这个函数返回 2 个 int。如果你仅仅需要返回值的一部分的话，你可以使用空白标识符 _。

  1. package main
  3. import "fmt"
  5. func vals() (int, int) {
  6.     return 3, 7
  7. }
  9. func main() {
  11.     a, b := vals()
  12.     fmt.Println(a)
  13.     fmt.Println(b)
  15.     _, c := vals()
  16.     fmt.Println(c)
  17. }

0x13 变参

如果你有一个含有多个值的 slice，想把它们作为参数使用， 你需要这样调用 func(slice...)。

  1. package main
  3. import "fmt"
  5. func sum(nums ...int) {
  6.     fmt.Print(nums, " ")
  7.     total := 0
  8.     for _, num := range nums {
  9.         total += num
  10.     }
  11.     fmt.Println(total)
  12. }
  14. func main() {
  16.     sum(1, 2)
  17.     sum(1, 2, 3)
  19.     nums := []int{1, 2, 3, 4}
  20.     sum(nums...)
  21. }
  1. $ go run variadic-functions.go 
  2. [1 2] 3
  3. [1 2 3] 6
  4. [1 2 3 4] 10

0x14 闭包

intSeq 函数返回一个在其函数体内定义的匿名函数。 返回的函数使用闭包的方式 隐藏 变量 i。 返回的函数 隐藏 变量 i 以形成闭包。

  1. package main
  3. import "fmt"
  5. func intSeq() func() int {
  6.     i := 0
  7.     return func() int {
  8.         i++
  9.         return i
  10.     }
  11. }
  13. func main() {
  15.     nextInt := intSeq()
  17.     fmt.Println(nextInt())
  18.     fmt.Println(nextInt())
  19.     fmt.Println(nextInt())
  21.     newInts := intSeq()
  22.     fmt.Println(newInts())
  23. }
  1. $ go run closures.go
  2. 1
  3. 2
  4. 3
  5. 1

0x15 递归

  1. package main
  3. import "fmt"
  5. func fact(n int) int {
  6.     if n == 0 {
  7.         return 1
  8.     }
  9.     return n * fact(n-1)
  10. }
  12. func main() {
  13.     fmt.Println(fact(7))
  14. }

0x16 指针

与C类语言相同

  1. package main
  3. import "fmt"
  5. func zeroval(ival int) {
  6.     ival = 0
  7. }
  9. func zeroptr(iptr *int) {
  10.     *iptr = 0
  11. }
  13. func main() {
  14.     i := 1
  15.     fmt.Println("initial:", i)
  17.     zeroval(i)
  18.     fmt.Println("zeroval:", i)
  20.     zeroptr(&i)
  21.     fmt.Println("zeroptr:", i)
  23.     fmt.Println("pointer:", &i)
  24. }
  1. $ go run pointers.go
  2. initial: 1
  3. zeroval: 1
  4. zeroptr: 0
  5. pointer: 0x42131100

0x17 结构体

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  12.     fmt.Println(person{"Bob", 20})
  14.     fmt.Println(person{name: "Alice", age: 30})
  16.     fmt.Println(person{name: "Fred"})
  18.     fmt.Println(&person{name: "Ann", age: 40})
  20.     s := person{name: "Sean", age: 50}
  21.     fmt.Println(s.name)
  23.     sp := &s
  24.     fmt.Println(sp.age)
  26.     sp.age = 51
  27.     fmt.Println(sp.age)
  28. }
  1. $ go run structs.go
  2. {Bob 20}
  3. {Alice 30}
  4. {Fred 0}
  5. &{Ann 40}
  6. Sean
  7. 50
  8. 51

0x18 方法

个人感觉类似于C++里面的class类内的public函数吧

  1. package main
  3. import "fmt"
  5. type rect struct {
  6.     width, height int
  7. }
  9. func (r *rect) area() int {
  10.     return r.width * r.height
  11. }
  13. func (r rect) perim() int {
  14.     return 2*r.width + 2*r.height
  15. }
  17. func main() {
  18.     r := rect{width: 10, height: 5}
  20.     fmt.Println("area: ", r.area())
  21.     fmt.Println("perim:", r.perim())
  23.     rp := &r
  24.     fmt.Println("area: ", rp.area())
  25.     fmt.Println("perim:", rp.perim())
  26. }
  1. $ go run methods.go
  2. area:  50
  3. perim: 30
  4. area:  50
  5. perim: 30

0x19 接口

可以通过接口实现对所有类似抽象问题的求解方法进行集合，从而简化程序的编写逻辑

  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. type geometry interface {
  9.     area() float64
  10.     perim() float64
  11. }
  13. type rect struct {
  14.     width, height float64
  15. }
  16. type circle struct {
  17.     radius float64
  18. }
  20. func (r rect) area() float64 {
  21.     return r.width * r.height
  22. }
  23. func (r rect) perim() float64 {
  24.     return 2*r.width + 2*r.height
  25. }
  27. func (c circle) area() float64 {
  28.     return math.Pi * c.radius * c.radius
  29. }
  30. func (c circle) perim() float64 {
  31.     return 2 * math.Pi * c.radius
  32. }
  34. func measure(g geometry) {
  35.     fmt.Println(g)
  36.     fmt.Println(g.area())
  37.     fmt.Println(g.perim())
  38. }
  40. func main() {
  41.     r := rect{width: 3, height: 4}
  42.     c := circle{radius: 5}
  44.     measure(r)
  45.     measure(c)
  46. }
  1. $ go run interfaces.go
  2. {3 4}
  3. 12
  4. 14
  5. {5}
  6. 78.53981633974483
  7. 31.41592653589793

0x20 错误处理

符合 Go 语言习惯的做法是使用一个独立、明确的返回值来传递错误信息。 这与 Java、Ruby 使用的异常（exception） 以及在 C 语言中有时用到的重载 (overloaded) 的单返回/错误值有着明显的不同。 Go 语言的处理方式能清楚的知道哪个函数返回了错误，并使用跟其他（无异常处理的）语言类似的方式来处理错误。

errors.New 使用给定的错误信息构造一个基本的 error 值。返回错误值为 nil 代表没有错误。还可以通过实现 Error() 方法来自定义 error 类型。

  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6. )
  8. func f1(arg int) (int, error) {
  9.     if arg == 42 {
  11.         return -1, errors.New("can't work with 42")
  13.     }
  15.     return arg + 3, nil
  16. }
  18. type argError struct {
  19.     arg  int
  20.     prob string
  21. }
  23. func (e *argError) Error() string {
  24.     return fmt.Sprintf("%d - %s", e.arg, e.prob)
  25. }
  27. func f2(arg int) (int, error) {
  28.     if arg == 42 {
  30.         return -1, &argError{arg, "can't work with it"}
  31.     }
  32.     return arg + 3, nil
  33. }
  35. func main() {
  37.     for _, i := range []int{7, 42} {
  38.         if r, e := f1(i); e != nil {
  39.             fmt.Println("f1 failed:", e)
  40.         } else {
  41.             fmt.Println("f1 worked:", r)
  42.         }
  43.     }
  44.     for _, i := range []int{7, 42} {
  45.         if r, e := f2(i); e != nil {
  46.             fmt.Println("f2 failed:", e)
  47.         } else {
  48.             fmt.Println("f2 worked:", r)
  49.         }
  50.     }
  52.     _, e := f2(42)
  53.     if ae, ok := e.(*argError); ok {
  54.         fmt.Println(ae.arg)
  55.         fmt.Println(ae.prob)
  56.     }
  57. }
  1. $ go run errors.go
  2. f1 worked: 10
  3. f1 failed: can't work with 42
  4. f2 worked: 10
  5. f2 failed: 42 - can't work with it
  6. 42
  7. can't work with it