【笔记】Go语言趣学指南

只是笔记，断断续续写Go也有大半年时间了，看看书顺便记一下老是容易忘的地方。

Go Playground 可以在线写一些代码

一、真值

1. 对Go来说，true是唯一的真值，而false是唯一的假值

变量作用域

    var count = 0
    for count = 10; count > 0; count-- {
        fmt.Println(count)
    }
    fmt.Println(count) // count 仍处于作用域内

    for count := 10; count > 0; count-- {
        fmt.Println(count)
    }
    fmt.Println(count) // undefined: count

二、浮点数

1. 默认为 float64

days := 365.2425
answer := 42.0

2. 整数去初始化时需要指定

var answer float64 = 42

3. 单精度浮点数
   float32 占用4字节内存，也就是32位，需手动指定

var pi64 = math.Pi
var pi32 float32 = math.Pi

4. 零值

    var price float64
    var price2 float32
    fmt.Println(price2 == 0) // true
    fmt.Println(price == 0) // true

三、整数

1. 有符号

• int8 [-128 -> 127]
• int16 [-32768 -> 32767]
• int32 [-2,147,483,648 -> 2,147,483,647]
• int64 [-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807]

2. 无符号

• uint8 [255]
• uint16[0 -> 65,535]
• uint32[0 -> 4,294,967,295]
• uint64[0 -> 18,446,744,073,709,551,615]

因为int和uint类型会根据目标硬件选择最合适的位长，所以它们未被包含在里面。

3. 了解类型
   利用fmt.Printf

    year := 2018
    fmt.Printf("Type %T for %v\n", year, year) // Type int for 2018
    
    year2 := int64(2018)
    fmt.Printf("Type %T for %v\n", year2, year2) // Type int64 for 2018

四、字符串

1. 原始字符串字字面量
   比如 想 真正的显示 "\n" 而不是 转译成换行，可以用``来包裹字符串

fmt.Println("Hello \n world")  
// Hello 
//   world
fmt.Println(`Hello \n world`)
// Hello \n world

2. Go和Python、Java、JavaScript中字符串一样，都是不可变的，不能修改Go中的字符串

3. 数字转字符串
   不能直接用string转

fmt.Println(string(120))  // x

可以采用以下的方法

str1 := strconv.Itoa(120)
str2 := strconv.FormatInt(int64(120), 10)
str3 := fmt.Sprintf("%d", 120)

五、 函数

1. 声明函数类型

type sensor func() float64

这样能简化以下的代码

func measureTemperature(samples int, s func() float64)
func measureTemperature(samples int, s sensor)

2. 闭包和匿名函数
   匿名函数也就是没有名字的函数，在Go中也被称为函数字面量。跟普通函数不一样的是，因为函数字面量需要保留外部作用域的变量引用，所以函数字面量都是闭包的。

var f = func() {
  fmt.Println("Dress up for the masquerade")
}

六、数组

1. 声明数组

var planets [8]string

2. 使用复合字面量初始化数组

dwarfs := [5]string{"123", "312", "das", "dsa", "2341edwq"}
// or
dwarf2 := [...]string{"123", "312", "das", "dsa", "2341edwq"}

3. 迭代数组

for i, drarf := range dwarfs {
  fmt.Pringln(i, draft)
}
// 0 123
// 1 312

4. 复制数组
   无论是将数组赋值给新的变量还是将它传递给函数，都会产生一个完整的数组副本

    list1 := [...]string{
        "a",
        "b",
    }

    list2 := list1
    list2[1] = "c"
    fmt.Println(list2, list1) // [a c] [a b]

七、切片

1. 切片是指向数组的窗口和视图

    arr := [...]string{
        "a",
        "b",
        "c",
        "d",
        "e",
        "f",
    }

    slice1 := arr[3:5]
    slice1[0] = "hahaha"
    fmt.Println(slice1, arr)  // [hahaha e] [a b c hahaha e f]

slice1 是 arr数组的视图，对切片中的任意一个元素赋予新的值都会导致arr数组发送变化

2. 创建切片

    arr := [...]string{"a","b","c"}
        arrSlice := arr[:]

        // 更简单一点
        arrSlice2 ：= []string{"a", "b", "c"}

3. append、长度和容量

    test := []int32{1, 2, 3}
    test2 := append(test, 4)
    test3 := append(test2, 5)
    fmt.Println(len(test), cap(test))   // 3  3
    fmt.Println(len(test2), cap(test2)) // 4  8
    fmt.Println(len(test3), cap(test3)) // 5  8
    
    test2[0] = 123
    fmt.Println(test, test3)

因为支撑test的底层数组没有足够的空间（容量）执行追加操作，因此append函数把test包含的元素复制到新分配的数组里面，新空间的容量是2倍，用来为后续可能的append操作留下空间
对test2 append时由于空间足够，所以不必再开辟新的空间，所以test2和test3指向同一个空间，修改时会同时生效。

4. 三索引切分操作
   首先看下面的场景，原本想只是给slice1新增一个元素，结果影响了test切片，因为执行slice2 := append(slice1, 90)时，slice2容量将增加，但是不会因为追加元素而分配新的数组，而是会覆盖原数组中的 5

    test := []int32{1, 2, 3, 4, 5, 6, 7}
    
    slice1 := test[0:4]
    
    slice2 := append(slice1, 90)
    
    fmt.Println(test, slice2) // [1 2 3 4 90 6 7] [1 2 3 4 90]

想要避免这种情况，可以使用切片的第三个参数

    test := []int32{1, 2, 3, 4, 5, 6, 7}
    
    slice1 := test[0:4:4]
    
    slice2 := append(slice1, 90)
    
    fmt.Println(test, slice2) // [1 2 3 4 5 6 7] [1 2 3 4 90]

5. 使用make函数对切片实行预分配
   当切片的容量不足以执行append操作时，Go必须创建新数组并复制旧数组中的内容。但是通过内置的make函数对切片实行预分配策略，我们可以避免额外的内存分配和数组复制操作。

    test := make([]int32, 0, 10)
    test = append(test, 1, 2, 3, 4, 5)
    fmt.Println(test)

make函数的容量参数是可选的，执行make([]string, 10)将创建长度和容量都为10的切片，其中每一个切片元素都包含一个与类型对应的零值。

6. 声明可变参数函数

func terraform(prefix string, worlds ...string) []string {
    newWorlds := make([]string, len(worlds))
    for i := range worlds {
        newWorlds[i] = prefix + " " + worlds[i] + ", "
    }
    return newWorlds
}

    ori := []string{"123", "456", "789"}
    test2 := terraform("haha", ori...)
    fmt.Println(test2) // [haha 123,  haha 456,  haha 789, ]