Go Lang

打印：

fmt.Println("i's value is ", i)
fmt.Printf("i's type is %T, i's value is %v \n", i, i)

格式文档：fmt

主程序入口 package main;

包管理，导入包使用 import, 可单导入 import “fmt”, 也可多导入 import (“fmt”;“math/rand”);

包名与导入路径的最后一个元素一致 import “math/rand”; rand.xxx;

首字母大写为已导出名

声明时类型后置，例如 func add(x int, y int) int, 后置原因：关于go的声明语法

类型相同的声明可只留最后一个，例如 func add(x, y int) int

变量声明 var a, b, c bool

变量声明可有初始值，有初始值时可省略类型：

 var a, b, c = true, 10, 'hello!' 

变量无初始值时将初始为零值0,false或“”

在函数内时，变量声明可用:= 来省略 var:

 a, b, c := true, 10, 'hello!'

基本类型：

bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名 表示一个 Unicode 码点
float32 float64
complex64 complex128

类型转换必须显式转换 T(x)，

var f float64 = 3.14
var i int = int(f)

常量定义:const Pi = 3.14

for循环,没有小括号

for i := 0; i < 10; i++ {
    sum += i
} 

可省略

sum := 0
for ; sum < 10; {
    sum += sum
}

可进一步省略(形似while, go语言没有while)

sum := 0
for sum < 10 {
    sum += sum
}

进一步无限循环

for {
}

if也没有小括号，并且可类似 for 在条件表达式前有一个简单语句, 作用域延伸至else

if v := math.Pow(2, 10); v < 1000{
    fmt.Println(v)
} else {
    fmt.Println("%v < 1000", v)
}

switch 语法， case 默认自带 break, 不会往下一个 case 走，除非显式调用 fallthrough。

case 可带变量或表达式。从上到下顺次执行，一旦匹配成功时停止，不会执行之后的case表达式(除非 fallthrough)。

switch省略表达式时，等同于 switch true, 这种形式能将一长串 if-then-else 写得更漂亮

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("Good morning!")
case t.Hour() < 17:
    fmt.Println("Good afternoon.")
default:
    fmt.Println("Good evening.")
}

go 拥有指针 var p *int = &i, 指针零值为 nil, go没有指针运算。

go 结构体 struct 与 C/C++ 类似。 结构体指针可直接用点号获取结构字段值 p.X

数组array的声明 var a [10]int，操作类似C语言。长度必须声明且不能改变。

长度为空时的声明是数组切片，切片(slice)可理解为数组部分区间的引用 var s []int = a[1:4], 范围左闭右开。范围可缺省,a[:],等价于 a[0:10]。

切片空值为 nil

用 make 来创建“动态”数组, make 函数会分配一个元素为零值的数组并返回一个引用了它的切片

b := make([]int, 0, 5) // len(b)=0, cap(b)=5
b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

用 append 函数来追加切片元素，当底层数组长度不够时，append会默认分配更长的数组并指给切片。

go 切片(slice) 的用法与本质

range 配合 for 循环切片

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
for i, v := range pow {
    fmt.Printf("2**%d = %d\n", i, v)
}

第一个变量i表示下标，第二个v标识值，可用_来忽略其中一个：for _, v := range pow，或只留一个变量来表示下标for i := range pow。

map 的声明 var m map[string]int, 可用 make 初始化 m := make(map[string]int)

map 赋值 m[key] = elem; 获取 elem = m[key]; 删除 delete(m, key)

map 双赋值

elem, ok = m[key]

若 key 在 m 中，ok 为 true ；否则，ok 为 false, elem 为该值类型的零值。

字符串库函数strings

转换字符串strconv, fmt.Sprint, fmt.Sprintf, fmt.Sprintln

函数(func)也为值，可传递，可作为参数与返回值

支持函数闭包(Function closures)

func adder() func(int) int { //<oak>: 这类型后置也有点绕眼
    sum := 0  //<oak>: 这sum的作用域也有点绕脑
    return func(x int) int {
        sum += x
        return sum
    }
}
 
func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 3; i++ {
        fmt.Println(pos(i), neg(-2*i))
    }
}
/* 输出
0 0
1 -2
3 -6
*/

没有类的概念，但是可以定义带reciever(接收者)的函数作为自定义类型的方法：

type Vertex struct {
	X, Y float64
}
func (v Vertex) Abs() float64 {  // reciever (v Vertex) 放置在 func 与  函数名之间
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
} // 本质上，方法与函数没有区别，即这个方法与 func Abs(v Vertex) float64 没有本质区别，仅仅是可以使用语法糖 v.Abs() 
func main() {
	v := Vertex{3, 4}
	fmt.Println(v.Abs())
}

只能为在同一包内定义的类型的接收者声明方法，而不能为其它包内定义的类型（包括 int 之类的内建类型）的接收者声明方法。

方法的 reciever 也是值传递，所以如果要修改 reciever 原值，需要把 reciever 定义为指针。在使用指针接收者方法时，默认不需要指针，即 v.scale() 等效于 (&v).scale()；反过来也成立，对于指针p := &v, p.Abs() 等效于 (*p).Abs()。

go 使用 interface type (接口类型)，接口类型变量可赋值实现了该接口方法的类型的变量，不需要像其它语言需要专门关键字 implement 接口，只要有对应的方法存在即可。fmt 包中定义的 Stringer 是最普遍的接口之一.

即便接口的具体值为 nil(接口本身不为nil)，方法仍然会正常调用，此时 reciever 为 nil。

指定了零个方法的接口值被称为 空接口, 空接口可赋予任意类型的值，可用来处理未知类型的值

type assertion类型断言：t := i.(T) 或 t, ok := i.(T)，判断一个接口值是否保存了一个特定的类型

var i interface{} = "hello"
s, ok := i.(string)
fmt.Println(s, ok) // hello true

type switch类型选择

switch v := i.(type) {  // 这里 type 为固定关键字
case T:
    // v 的类型为 T
case S:
    // v 的类型为 S
default:
    // 没有匹配，v 与 i 的类型相同
}

多值返回，函数可返回任意数量返回值，也可对返回值命名 func split(sum int) (x, y int)，没有参数的 return 语句返回已命名的返回值。

defer 语句会将函数推迟到外层函数返回之后执行。推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

defer 栈 defer panic and recover

接口 error; 通常 fmt 包库函数会返回error, error 为 nil 时表示成功；非 nil 的 error 表示失败

i, err := strconv.Atoi("42") 
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}
fmt.Println("Converted integer:", i)

goroutine 是由 Go 运行时管理的轻量级线程。

信道(channel)操作符 ←

ch := make(chan int, 1) // 创建int值信道, 第二个参数为缓冲区大小
ch <- v    // 将 v 发送至信道 ch。
v := <-ch  // 从 ch 接收值并赋予 v
 

信道缓冲区(默认1)满时阻塞发送端，空时阻塞接收端。这让 goroutine 可以在没有显式的锁或竞态变量的情况下进行同步。

发送者可通过 close 关闭一个信道,只有发送者可关闭信道。

接收者可以通过表达式第二个参数来测试信道是否被关闭：若没有值可以接收且信道已被关闭，那么在执行完

v, ok := <-ch

之后 ok 会被设置为 false。

循环 for i := range ch 会不断从信道接收值，直到它被关闭

select 语句使一个 goroutine 协程可以等待多个通信操作。select 会阻塞到某个分支可以继续执行为止，这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。如果有 default, 则在所有分支阻塞时执行 default。

sync.Mutex 互斥锁

在Go 1.4 之前, 当创建一个goroutine时，Go运行时会分配一段8K字节的内存用于栈供goroutine运行使用, 如果不够, 则使用分段栈(Segmented Stacks)来扩展

分段栈(Segmented Stacks)方式, 在栈缩小时的操作代价比较高(要频繁处理分段间的跨越).

在Go 1.4 中, 使用栈拷贝(stack copying)方式来处理栈伸缩, 新方案创建一个两倍于原stack大小的新stack，并将旧栈拷贝到其中。这意味着当栈实际使用的空间缩小为原先的大小时，go不用做额外操作,此时栈缩小是一个无任何代价的操作。

栈拷贝需把原栈指针重定向,而获取原栈指针依靠的是垃圾回收机制(会记录栈指针).但是使用C代码写的运行时调用不参与go的垃圾回收机制, 将会缺失栈指针信息而使用老机制(分段栈)