Golang语法

变量定义

变量定义语法

使用var关键字，可放在函数内，也可放在包内

// var + 变量名 + 数据类型（有默认值）
var a int
var b string = "string"
// 通过赋值自动判断类型
var c = true
// 集中定义
var (
    x = 1
    y = 2
)

使用:=定义变量，只能在函数内使用

// := 用于赋初值
a, b := 1, 2

内建变量类型（builtin）

bool, string
(u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
byte, rune
float32, float64, complex64, complex128

强制类型转换

Golang要求强制类型转换，无隐式转换

a, b := 3, 4
var c int
c = int(math.Sqrt(float64(a * a + b * b)))

常量

使用const关键字定义常量，const数值可作为各种类型使用。

// 不确定类型
const a = 3
var b float64
b = a
// 合并定义
const (
    c = 1
    d = 2
)

枚举

const (
    spring = 0
    summer = 1
    autumn = 2
    winter = 3
)
// iota用在取值为0的const变量，后续变量依次加1
const (
    spring = iota
    summer
    autumn
    winter
)

变量定义要点

变量类型写在变量名之后
编译器可以推测变量类型
Golang没有char，使用rune
原生支持复数类型

分支

if

const filename = "abc.txt"
contents, err := ioutil.ReadFile(filename)
if err != nil {
    fmt.Println(err)
} else {
    fmt.Println(contents)
}

// 可以在if条件中赋值，赋值变量的作用域在if语句中
if contents, err := ioutil.ReadFile(filename); err != nil {
    fmt.Println(err)
} else {
    fmt.Println(contents)
}

switch

switch后可以没有表达式，case结束后自动break，通过fallthrough不使用自动break。

func grade(score int) {
    grade := ""
    switch {
    case score < 0:
        panic(fmt.Sprintf("Wrong score: %d\n", score))
    case score < 60:
        grade = "C"
    case score < 80:
        grade = "B"
    case score < 90:
        grade = "A"
    case score < 100:
        // 自动break，除非出现fallthrough
        fallthrough
    case score >= 100:
        grade = "S"
    }
    fmt.Println(grade)
}

循环

for条件没有括号，没有while。

func convertToBin(n int) string {
    result := ""
    for ; n > 0; n /= 2 {
        lsb := n % 2
        result = strconv.Itoa(lsb) + result
    }
    return result
}

func printFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        panic(err)
    }

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

func forever() {
    // while true
    for  {
        fmt.Println("forever")
    }
}

函数

函数声明的顺序为：关键字，函数名，参数，返回类型，函数体。
函数允许有多个返回值，并能在函数体内拿到返回值。
函数可以作为另一个函数的参数
函数支持可变参数列表

func div(a, b int) (q, r int) {
    // q = a / b
    // r = a % b
    // return
    return a / b, a % b
}

// 使用_抛弃返回值
a, _ := div(12, 7)

// 使用另一个函数作为参数
func apply(operation func(a, b int), a, b int) {
    operation(a, b)
}
// 使用匿名函数
apply(func(a, b int) {
    fmt.Println(a, b)
}, 1, 2)

// 可变参数列表
func sum(numbers ...int) int {
    s := 0
    for i := range numbers {
        s += numbers[i]
    }
    return s
}

指针

Golang只有值传递一种方式。

// 使用指针操作
func change(pa *int) {
    *pa++
}
a := 5
change(&a)

func swap(x, y *int) {
    *x, *y = *y, *x
}

数组

数组长度写在类型之前，[10]int和[20]int是不同的类型。数组是值复制。

var arr1 [5]int
arr2 := [3]int{1, 3, 5}
arr3 := [...]int{2, 4, 6}
var arr4 [4][5]int

遍历数组

for i := 0; i < len(arr3); i++ {
    fmt.Println(arr3[i])
}

for i := range arr3 {
    fmt.Println(arr3[i])
}

// 按下标和值遍历
for i, v := range arr3 {
    fmt.Println(i, v)
}

切片

数组切片相当于数据的一个视图，可以通过切片改变数组的值。

func updateSlice(s []int) {
    s[0] = 100
}

func main() {
    array := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := array[2:6]
    s2 := array[2:]
    s3 := array[:6]
    s4 := array[:]
    fmt.Println(s1, s2, s3, s4) // [2 3 4 5] [2 3 4 5 6 7] [0 1 2 3 4 5] [0 1 2 3 4 5 6 7]

    updateSlice(s2)
    fmt.Println(s2) // [100 3 4 5 6 7]
    updateSlice(s3)
    fmt.Println(s3) // [100 1 100 3 4 5]
    
    // 切片扩展
    s5 := s3[6:8]
    fmt.Println(s5)
    
    // 添加元素
    s6 := append(s5, 8)
    fmt.Println(s6, array)
    fmt.Println(array[:8])
    
    // 通过make创建切片
    // 长度为10的切片
    x := make([]int, 10)
    // 长度为10，容量为16的切片
    y := make([]int, 10, 16)

    // 拷贝数组元素
    copy(x, y)

    // 截取数组元素
    z := append(x[:2], x[3:]...)
}

切片底层维护了一个数组，ptr指向切片的首个元素，len表示切片的长度，cap表示底层数组的从ptr到最末的元素数量。切片可以向后扩展，不可向前扩展。切片添加元素如果会超过底层数组的cap，Golang会分配更大的底层数组（原容量*2进行扩展），由于值传递的关系，必须接收append方法的返回值。

map

通过map[K]v的形式定义map。除了slice、map、function的内建类型和struct类型都可以作为map的key。

m := map[string]string{
        "name": "wch",
        "age":  "23",
    }
    
m2 := make(map[string]int)

// 无序遍历map
for k, v := range m {
    fmt.Println(k, v)
}

// map读值
name := m["name"]


// 判断key是否存在
grade, exist := m["grade"]

// 删除
delete(m, "name")

rune

Golang的rune相当于java的char，中文字符在Golang中占3个字节，使用 utf8.RuneCountInString 获取字符数，用 len 获取字节长度，使用 []byte 获取字节。

s := "学习Golang！"
fmt.Println(s)

// ch是rune类型，中文字符占3个字节
for i, ch := range s {
    fmt.Printf("(%d %X) ", i, ch)
}
fmt.Println()

fmt.Println("rune count in string:", utf8.RuneCountInString(s))

bytes := []byte(s)
for len(bytes) > 0 {
    ch, size := utf8.DecodeRune(bytes)
    bytes = bytes[size:]
    fmt.Printf("size= %d, rune=%c\n", size, ch)
}

for i, ch := range []rune(s) {
    fmt.Printf("(%d %c)", i, ch)
}
fmt.Println()

面向对象

Golang仅支持封装，不支持继承和多态，没有class，只有struct，通过struct来定义对象。

type treeNode struct {
    value       int
    left, right *treeNode
}

func createNode(value int) *treeNode {
    return &treeNode{value: value}
}

func main() {
    // 通过多种方式声明对象
    var root treeNode
    root = treeNode{value: 0}
    root.left = &treeNode{}
    root.right = &treeNode{1, nil, nil}
    root.right.left = new(treeNode)
    root.right.right = createNode(3)
}

Golang支持显式定义方法接收者，值/指针接收者均可接收值/指针。当需要改变内容或结构过大时需要使用指针接收者，值接收者是Golang特有的

// 指定方法接收者
func (node treeNode) print() {
    fmt.Println(node.value)
}

func (node *treeNode) setValue(value int) {
    node.value = value
}

func main() {
    node := treeNode{}
    node.setValue(100)
    node.print()
    
    pNode := &node
    pNode.setValue(101)
    pNode.print()
}

封装

Golang的可见性（针对包）使用首字母来控制，首字母大写表示public，首字母小写表示private。每个目录都是一个包，main包包含可执行入口。为结构定义的方法必须放在同一个包内，可以是不同的文件。Golang提供了两种扩展系统类型和已封装类型的方法：

定义别名：通过type为已有类型定义一个别名，针对新的结构体进行扩展。

type Queue []int

func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

func (q *Queue) IsEmpty() bool {
    return len(*q) == 0
}

使用组合：定义新的结构体，其中一个成员是需要扩展的类型的指针。

type EnhanceNode struct {
    node *Node
}

func (enhanceNode *EnhanceNode) PostOrder() {
    if nil == enhanceNode || nil == enhanceNode.node {
        return
    }

    left := EnhanceNode{enhanceNode.node.Left}
    right := EnhanceNode{enhanceNode.node.Right}

    left.PostOrder()
    right.PostOrder()
    enhanceNode.PostOrder()
}

GOROOT、GOPATH、go get

GOROOT一般为下载的sdk路径，GOPATH为用户可定义的路径，用户源码和通过go get命令下载的第三方库在GOPATH的src目录下。
gopm是go get的镜像工具，通过 go get -g -v github.com/gpmgo/gopm 下载gopm。

// 下载
gopm get -g -v Golang.org/x/tools/cmd/goimports
// 更新
gopm get -g -v -u Golang.org/x/tools/cmd/goimports
// 安装到GOPATH的bin目录
go install Golang.org/x/tools/cmd/goimports

接口

接口的实现是隐式的，只要实现接口的方法。

duck typing

“像鸭子走路，像鸭子叫（长得像鸭子），那么就是鸭子”，意为描述事物的外部行为而非内部结构。严格说go属于结构化类型系统，类似duck typing。

接口变量里有什么

接口自带指针
接口变量同样采用值传递，几乎不需要使用接口的指针
指针接收者只能以指针的方式使用，值接收者都可以
interface{}可以代表任何类型
定义接口

type Retriever interface {
    Get(url string) string
}

func download(r Retriever) string {
    return r.Get("http://www.baidu.com")
}

实现接口

type Retriever struct {
    UserAgent string
    Timeout   time.Duration
}

func (r *Retriever) Get(url string) string {
    resp, err := http.Get(url)
    if nil != err {
        panic(err)
    }

    result, err := httputil.DumpResponse(resp, true)
    resp.Body.Close()

    if nil != err {
        panic(err)
    }

    return string(result)
}

调用接口

var r Retriever
r = &real.Retriever{
    UserAgent: "Mozilla/5.0",
    Timeout:   time.Minute,
}
fmt.Println(download(r))

// Type Assertion
if retriever, ok := r.(*real.Retriever); ok {
    fmt.Printf("%T %v\n", retriever, retriever)
}

接口组合

type HttpExecute interface {
    Retriever
    Poster
}

函数式编程

函数是一等公民：参数，变量，返回值都可以是函数。
高阶函数：函数的参数可以是函数
函数->闭包

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

func main() {
    // f中不仅是一个函数，还有对变量sum的引用
    f := adder()
    for i := 0; i < 10; i++ {
        fmt.Println(f(i))
    }
}

错误处理和资源管理

defer

用于指定在函数结束之前执行，可以用于关闭文件、释放锁等。

func tryDefer() {
    // 在函数借结束之前执行
    defer fmt.Println("execute last...")
    defer fmt.Println("execute before last...")
    fmt.Println("execute")
}

panic

停止当前函数执行
一直向上返回，执行每一层的defer
如果没有遇见recover，程序退出

recover

仅在defer调用中使用
获取panic的值
如果无法处理，重新panic

func tryRecover() {
    defer func() {
        r := recover()
        if err, ok := r.(error); ok {
            fmt.Println("error:", err)
        } else {
            panic(fmt.Sprintf("unknown error: %v", r))
        }
    }()

    panic(errors.New("this is an error"))
}

测试

测试格式

测试文件与待测试代码放在同一目录下
测试文件名以 _test.go 结尾
测试函数名为 TestXxx 或 Test_xxx 的格式，使用其它类型测试，如性能测试则函数名为BenchmarkXxx 或 ```Benchmark_xxx`` 的格式

传统测试

传统测试数据与逻辑混在一起
传统测试的出错信息不明确
传统测试一旦出错测试即全部结束

表格驱动测试

测试代码

func calcTriangle(a, b int) int {
    return int(math.Sqrt(float64(a*a + b*b)))
}

表格驱动测试
分离了测试数据和测试逻辑，明确了出错信息，可以部分失败。

func TestCalcTriangle(t *testing.T) {
    tests := []struct{ a, b, c int }{
        {3, 4, 5},
        {5, 12, 13},
        {8, 15, 18},
    }

    for _, tt := range tests {
        if actual := calcTriangle(tt.a, tt.b); actual != tt.c {
            t.Errorf("calcTriangle(%d %d); got %d; expected %d", tt.a, tt.b, actual, tt.c)
        }
    }
}

性能测试

执行b.N次，由Golang决定具体次数，测试完成后在控制台打印执行次数和平均执行时间。

func BenchmarkTriangle(b *testing.B) {
    x, y, z := 8, 15, 17
    for i := 0; i < b.N; i++ {
        actual := calcTriangle(x, y)
        if actual != z {
            b.Errorf("calcTriangle(%d %d); got %d; expected %d", x, y, actual, z)
        }
    }
}

测试命令行工具

# 测试命令
go test
# 代码覆盖率测试
go test -cover
# 生成代码测试覆盖率文件
go test -coverprofile c.out
# 代码覆盖率测试html
go tool cover -html=c.out
# 性能测试
go test -bench .
# 生成性能报告
go test -bench . -cpuprofile cpu.out

文档

Golang提供 go doc 命令查看由注释组成的文档，通过 godoc -http :6060 命令在本地6060端口生成html文档。在test文件中建立名为 ExampleXxx_xxx 的函数，通过特定格式生成代码实例文档。

func ExampleQueue_Pop() {
    queue := Queue{}
    queue.Push(1)
    fmt.Println(queue.Pop())

    // Output:
    // 1
}

go routine

协程Coroutine

轻量级“线程”
非抢占式多任务处理，由协程主动交出控制权
编译器/解释器/虚拟机层面的多任务
多个协程可能在一个或多个线程上运行

goroutine定义

调用任何函数前只需加上 go 关键字就可以交给调度器执行
不需要在定义时区分是否为异步函数
调度器会在合适的点进行切换（I/O、select、channel、等待锁、函数调用等），或手动调用 runtime.Gosched() 进行切换
使用race来检测数据访问冲突， go run -race xxx.go

channel

相对于通过共享内存来通信，channel通过通信来共享内存。

chanel可以作为参数传递
可以设置channel的buffer
发送方负责关闭channel，接收方通过可以通过 range 判断channel是否传递完毕

使用select进行调度

select可以用来监听IO操作，可以同时监听多个channel的消息状态。