Golang 一些基本语法

package main

import "fmt"

func main() {
        my_counter := counter()
        fmt.Println(my_counter())
        fmt.Println(my_counter())
        fmt.Println(my_counter())
}

func counter() func() int {
        i := 0
        return func() int {
                i++
                return i
        }
}

// 数组表示一个具有固定长度的序列
var arr = [5]int{1, 2, 3, 4, 5}
var arr1 = [...]int{1, 2, 3, 4, 5}
// 切片表示一个拥有相同类型的可变长序列
var slice = []int{1, 2, 3, 4, 5}
var slice1 = make([]int, 5, 10)
// slice2 的长度为 1, 指针指向 arr[3], 容量为 2
// 对 slice2 的改动会影响 arr
var slice2 = arr[3:4]
slice2[0] = 1
// 此时 arr[3] 为 1

// 切片具有三个属性: 指针 长度 容量
// 指针用于指向一个底层数组
// 长度表示切片允许打印的长度
len(slice)
// 容量表示底层数组的长度
cap(slice)
// 可以修改切片的长度, 但是不能超过容量
// 修改后的切片修改仍然对原数组有影响
slice2 = slice2[:2]
slice2[1] = 2
// 此时 arr[4] 为 2

// append 和 copy
// append 会修改底层数组
// 如果 append 后容量超过, 切片会复制整个底层数组并指向新数组
var new_arr = []int{0, 0, 0, 0, 0}
var new_slice = arr[0:2]

new_slice = append(new_slice, 1)
// 此时 new_arr[2] 为 1

// copy 会修改底层数组
new_slice1 := []int{1, 2, 3, 4, 5}
new_slice2 := []int{0, 0, 0}
new_slice3 := []int{0, 0, 0}

copy(new_slice2, new_slice1)
// 此时 new_slice2 为 {1, 2, 3}
copy(new_slice1, new_slice3)
// 此时 new_slice1 为 {0, 0, 0, 4, 5}

package main

import (
        "fmt"
        "time"
)

func say(s string, ch chan int) {
        for {
                time.Sleep(1 * time.Second)
                // 此处从 ch 通道取出一个到 i 中
                // 如果没有数据会进入等待
                i := <-ch
                fmt.Println(s)
                fmt.Println(i)
        }
}

func main() {
        // chan 为一个通道, 缓存区大小为 10
        // 默认没有缓冲区(0)
        ch := make(chan int, 10)
        // go 关键字表示函数作为一个协程运行
        go say("world", ch)
        i := 0
        for {
                // 此处将 i 放入 ch 缓冲区和通道
                // 会连续打印 10 个 hello
                // 之后由于 ch 的缓冲区和通道都有数据进入阻塞状态
                ch <- i
                fmt.Println("hello")
                i++
        }
        // 关闭通道
        close(ch)
}