# Golang

:Go 语言,一种编译型语言。

  • 官方文档 (opens new window)
  • 于 2009 年由 Google 公司发布。
  • 是强类型语言、静态语言。
  • 提供了协程机制,处理并发任务的效率高。因此常用于服务器应用开发、云计算领域。

# 语法特点

  • 语法与 C 语言相似,支持定义结构体、指针。
  • 源文件的扩展名为 .go 。
  • 每个语句的末尾以换行符或分号 ; 作为分隔符。
  • // 声明单行注释,用 /**/ 声明多行注释。
  • 支持定义函数,不支持定义类,但可以通过结构体(struct)实现面向对象编程。
  • 会自动回收垃圾内存。

# 编译

  • 安装编译器:

    yum install golang
    
  • 使用编译器:

    go
        run test.go     # 编译并执行一个源文件
        run .           # 指定一个目录时,会自动执行该目录下包含 main 包及 main 函数的源文件
    
        build test.go   # 编译一个源文件,这会生成一个名为 test 的可执行文件
    

# 程序示例

编写一个源文件 test.go :

package main      // 声明当前文件属于一个名为 main 的包

import "fmt"      // 导入名为 fmt 的包

func main() {
    var x = "Hello World!"
    fmt.Println(x)
}
  • 启动一个 Golang 程序时,会找到其中名为 main 的包,执行其中名为 main 的函数。
  • 包 fmt 提供了一些输入输出的函数,如下:
    fmt.Print("Hello")                    // 打印一个值到终端
    fmt.Println("Hello")                  // 打印一个值并换行
    fmt.Println("Hello\nWorld", 1, 3.14)  // 可以打印任意个值
    fmt.Printf("%d, %d\n", 1, 2)        // 格式化输出
    
  • Golang 要求左花括号 { 不能独占一行,如下:
    func main()
    {                           // 编译时会报错:unexpected semicolon or newline before {
        fmt.Println("Hello")
    }
    

# 变量

  • 用关键字 var 可以创建变量。

    • 常见的几种格式如下:
      var x int       // 创建变量,在变量名之后声明其数据类型,但不赋值。此时变量采用默认值
      
      var x int = 1   // 创建变量,声明数据类型,并赋值
      
      var x = 1       // 创建变量,省略数据类型,并赋值。此时会根据赋值自动确定数据类型
      
    • 可以同时创建多个变量:
      var x, y int
      var a, b, c = 1, true, "Hello"
      
    • 可以通过括号写成多行的格式:
      var (
          a int
          b bool
          c string
      )
      
      var (
          a int
          b bool = true
          c = "Hello"
      )
      
    • 创建变量时,如果该变量名已存在,则编译时会报错:variable redeclared
    • 如果创建了一个局部变量,但并没有在其作用域内读取其值,则编译时会报错:variable declared and not used
  • 在函数内可以用 := 创建变量:

    x := 1      // 相当于 var x = 1
    
    • 函数外的每个语句都必须以关键字开头,因此不能使用 :=
  • 用关键字 const 可以创建常量,格式与 var 相似:

    const LENGTH int = 10
    const a, b, c = 1, true, "Hello"
    
  • _ 是一个特殊的标识符,可以作为变量被赋值,但不能被读取。因此通常将一些不需要保存的值赋值给它。如下:

    result, _ := do_sth()
    fmt.Println(_)          // 不能读取 _ 的值,编译时会报错:cannot use _ as value
    
  • 变量的作用域:

    • 全局变量:在函数外、包内创建。
    • 局部变量:在函数、for 语句块等区域内创建。

# 数据类型

# 基本数据类型

int         // 整型
int8        // 别名为 byte
int16
int32       // 别名为 rune
int64

uint        // 无符号整型 ,还有 uint8、uint16、uint32、uint64
uintptr     // 无符号整型,用于存储指针

float32     // 浮点型
float64

complex64   // 复数,比如 c := 1 + 2i
complex128

bool        // 布尔类型,取值为 true 或 false

string      // 字符串类型,采用 UTF-8 编码
  • int、uint、uintptr 在 32 位系统上容量为 4 bytes ,在 64 位系统上容量为 8 bytes 。
  • 创建不同数据类型的变量时,其默认值如下:
    • 数值类型,默认值为 0 。
    • 布尔类型,默认值为 false 。
    • 字符类型,默认值为 '' 。
    • 字符串类型,默认值为 "" 。
  • 通过定界符区分字符、字符串常量:
    c := 'H'        // 定界符为单引号,因此视作字符类型,存储为 rune 型
    c := 'Hello'    // 字符类型只能包含单个字符,这里编译时会报错:invalid character literal (more than one character)
    s := "Hello"    // 定界符为双引号,因此视作字符串类型,存储为 string 型
    

# 类型转换

  • 不支持自动类型转换:
    i := 42     // 创建的变量为 int 型
    i  = 3.14   // int 型变量不能被 float 型常量赋值,此时会报错:constant 3.14 truncated to integer
    
    f := 3.14   // 创建的变量为 float64 型
    f  = 42     // float64 型变量可以被 int 型常量赋值
    f  = i      // 不同类型的变量不能相互赋值。此时会报错:cannot use i (type int) as type float64 in assignment
    
  • 支持强制类型转换:
    var i int     = 42
    var f float64 = float64(i)  // 相当于 f := float64(i)
    

# 数组

  • 数组(array):用 [n]type 的格式创建,长度固定。
  • 创建数组:
    var array [10] int                // 创建一个指定长度的数组,不赋值
    array2 := [10]int{0, 1, 2, 3}     // 创建一个指定长度的数组,并赋值部分元素
    
    • 数组中的元素必须属于同一数据类型。
  • 访问数组:
    array[0] = 10   // 给指定位置的元素赋值
    array[0]        // 读取指定位置的元素
    len(inArr)      // 获取数组的长度
    

# 切片

  • 切片(slice):引用数组的某个区间的元素,也可以用 []type 的格式创建,长度可变。
    • 修改数组的元素时,其切片看到的元素也会改变。反之也成立。
  • 获取数组的切片:
    array := []int{0, 1, 2, 3}
    array[0:3]      // 获取区间 [0, 3) 的切片,这里会返回一个数组 [0 1 2]
    array[0:0]      // 获取区间 [0, 0) 的切片,这里会返回一个数组 []
    
    • 切片的上标、下标可以缺省,默认值分别为 0、len(array) ,因此支持以下写法:
      array[0:]     // 这里会返回一个数组 [0 1 2 3]
      array[:3]     // 这里会返回一个数组 [0 1 2]
      array[:]      // 这里会返回一个数组 [0 1 2 3]
      
    • 切片的上标、下标出错的几种情况:
      array[-1:0]   // 上标、下标不能为负数,这里编译时会报错:invalid slice index -1 (index must be non-negative)
      array[1:0]    // 上标不能大于下标,这里编译时会报错:invalid slice index: 1 > 0
      array[0:6]    // 下标不能大于数组长度,这里运行时会报错:runtime error: slice bounds out of range [:6] with capacity 5
      
  • 创建切片:
    slice := []int{0, 1, 2, 3}      // 这会先创建一个数组 [4]int{0, 1, 2, 3} ,再返回其切片
    
  • 对切片追加元素:
    slice = append(slice, 4)        // 追加一个元素
    slice = append(slice, 5, 6, 7)  // 可以同时追加多个元素
    fmt.Println(slice)              // 这里会打印:[0 1 2 3 4 5 6 7]
    
  • 调用 make 函数可以创建 slice、Map、channel 等类型的内存空间。
    slice := make([]int, 4)         // 创建一个切片,长度为 4
    

# 结构体

  • 用关键字 type ... struct 可以定义一个结构体,从而自定义一种数据类型。
  • 定义结构体:
    type Book struct {  // 定义一个结构体,名为 Book
        id int          // 给该结构体定义一个成员,名为 id ,数据类型为 int
        title string
        author string
    }
    
  • 使用结构体:
    var book1 Book      // 创建结构体 Book 的一个实例,名为 book1
    book1.id            // 读取结构体的成员。这里 id 还未赋值,所以采用 int 型变量的默认值
    book1.id = 1        // 给成员赋值
    fmt.Println(book1)  // 打印结构体时,会按顺序打印各个成员的值。这里会打印:{0  }
    
    book2 := Book{2, "Hello", "unknown"}   // 创建一个实例,并赋值。此时如果只给部分成员赋值,则编译时会报错:too few values in Book literal
    
    book3 := Book{title: "Hello", author: "unknown"}   // 可以通过键值对的形式赋值,并且此时可以只给部分成员赋值
    fmt.Println(book3)  // 这里会打印:{0 Hello unknown}
    

# Map

  • Map(映射)是包含一组键值对的集合,类似于 Python 的字典类型。
    • 各键值对是无序存储的。
  • 创建 Map :
    m := make(map[string]int) // 创建一个 Map 变量,名为 m ,键值对的数据类型分别为 string、int
    m["A"] = 1                // 添加一个键值对
    m["B"] = 2
    delete(m, "B")            // 从 Map 中删除一个 key 及其值。如果该 key 不存在,并不会报错
    
  • 检查一个 key 是否存在:
    value, ok := m["A"]
    if (ok) {
        fmt.Println("key 存在", value)
    } else {
        fmt.Println("key 不存在", value)
    }
    
    • 读取一个 key 对应的值时,如果该 key 不存在,则读取到的值为其数据类型的默认值,但并不会报错。
  • 遍历 Map :
    for key := range m {
        fmt.Println(key, "=", m[key])
    }
    
    for key, value := range m {
        fmt.Println(key, "=", value)
    }
    

# 指针

  • 使用指针:

    x := 42
    var p *int          // 创建一个变量,并声明为 *int 型指针
    p = &x              // 用 & 运算符获取一个变量的地址,赋值给指针变量
    fmt.Println(p)      // 获取指针变量本身的值,即十六进制地址,这里会打印:0xc000086020
    fmt.Println(*p)     // 用 * 运算符取消指针的引用,读取其引用地址的值。这里会打印:42
    
    • 创建指针时可简写为:
      x := 42
      p := &x
      
  • 取值为 nil 的指针称为空指针,相当于 C 语言的 null 指针。

    • 刚创建的指针变量,默认值都为 nil 。
    • 例:
      p = nil
      fmt.Println(p)    // 这里会打印: nil
      fmt.Println(*p)   // 空指针不能读取其引用地址的值,这里运行时会报错:runtime error: invalid memory address or nil pointer dereference
      
  • 与 C 语言相比,Golang 禁止了一些指针运算:

    x := 42
    y := 3.14
    p := &x
    p = &y      // 指针不能存储其它数据类型的地址,这里编译时会报错:cannot use &y (type *float64) as type *int in assignment
    p += 1      // 指针存储的值不能进行算术运算,这里编译时会报错:invalid operation: p += 1 (mismatched types *int and int)
    
  • 使用结构体指针:

    var book1 Book
    book_p := &book1
    
    fmt.Println(book1)    // 这里会打印:{0  }
    fmt.Println(book_p)   // 这里会打印:&{0  }
    
    (*book_p).id          // 用 * 运算符取消引用,再访问结构体的成员
    book_p.id             // 也可以用 book_p.id 直接访问结构体的成员,它会被 Golang 当作 (*book_p).id 处理
    

# 流程控制

# if 语句

  • 例:

    if x := 1; x < 2 {    // 可以在条件表达式之前加上一个子句
        fmt.Println(true)
    } else {
        fmt.Println(false)
    }
    
  • 多层判断:

    x := 1
    if x == 1 {
        fmt.Println(1)
    } else if x == 2 {
        fmt.Println(2)
    } else {
        fmt.Println(0)
    }
    

# for 语句

  • 例:

    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
    
    • 当条件表达式的布尔值为 false 时,for 循环才结束。
  • 可以省略初始化子句、后置子句,只留下条件表达式子句:

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

    还可以再省略分号,格式相当于 Python 的 while 循环:

      sum := 1
      for sum < 10 {
      	  sum += sum
      }
    
  • 可以省略所有子句,写成无限循环:

    for {
    }
    
  • 可以将 for 与 range 搭配使用,进行遍历:

    for index, value := range "Hello" {
        fmt.Println(index, value)
    }
    // 打印如下:
    // 0 72
    // 1 101
    // 2 108
    // 3 108
    // 4 111
    
    • 每次遍历时会返回两个值:元素的索引、元素的值。可以只获取其中一个:
      for index := range "Hello" { }
      for _, value := range "Hello" { }
      

# 函数

  • 例:

    func fun1(x int, y int){    // 定义一个函数,名为 fun1 ,形参为 (x int, y int)
        fmt.Println(x, y)
    }
    
    fun1(1, 2)                  // 调用函数
    
    • 函数可以没有形参,或声明多个形参。
    • 函数可以没有返回值,或者返回多个值。
    • 函数不支持嵌套,不能在一个函数内定义另一个函数。
  • 如果函数有返回值,则必须在函数头末尾声明返回值列表:

    func fun1() (int, int) {
        return 1, 2
    }
    
    fmt.Println(fun1())
    
    • 这里声明了返回值列表为 (int, int) ,因此函数必须返回两个 int 类型的值,否则编译时会报错。
  • 可以在返回值列表中指定变量名:

    func fun1() (a, b int) {
        a = 1
        return
        // return 1, 2
    }
    
    fmt.Println(fun1())
    
    • 这里声明了返回值列表为 (a, b int) ,因此会在函数开始时就创建这两个局部变量。
    • 如果 return 语句的内容为空,则会返回 a、b 两个变量作为返回值。
  • 用关键字 defer 调用一个函数,会推迟执行它:

    func fun1(){
        defer fmt.Println("defer...")   // 使用 defer 语句
        fmt.Println("function end")
    }
    
    fun1() 
    
    • defer 语句只能在一个函数内使用,在该函数退出时才执行。
    • 如果有多个 defer 语句,则按后进先出的顺序执行。

# package

  • 导入包:
    import "fmt"
    import "math"
    
    • 可以通过括号写成多行的格式:
      import (
          "fmt"
          "math"
      )
      
  • Golang 根据包内的成员是否以大写字母开头,控制包外的访问权限。
    • 以大写字母开头的成员会被导出(export),可以被外部调用,相当于 Java 的 public 权限。
    • 其它成员不会被导出,对外部不可见,相当于 Java 的 protected 权限。
    • 例:
      fmt.Println(math.Pi)    // 可以访问
      fmt.Println(math.pi)    // 不可以访问,编译时会报错:cannot refer to unexported name
      

# 协程

  • Golang 提供了 Goroutines 机制,用于创建轻量级的协程。还提供了 Channels 机制,用于协程之间的通信。

  • 用关键字 go 调用一个函数,会创建一个协程去执行它:

    func fun1(x int){
        fmt.Println(x)
    }
    
    go fun1(1)
    
    • 创建协程的当前线程,称为主线程。
    • 协程会共享主线程的内存,但不会共享 stdin、stdout 。
    • 当主线程退出时,其下的所有协程会被自动终止。
  • 协程之间可以通过 channel 类型的变量进行通信:

    func fun1(ch chan int){
        for i := 0; i < 100; i++ {
            ch <- i               // 写入一个值到通道。如果通道的缓冲区没有可用空间,则一直等待,陷入阻塞
        }
        close(ch)                 // 关闭通道。只有发送者能关闭通道
    }
    
    func main() {
        ch := make(chan int, 10)  // 用关键字 chan 创建一个通道,其数据类型为 int ,缓冲区可存储 10 个 int 型值
        go fun1(ch)               // 创建协程,并传递通道以便通信
        for value := range ch {   // 遍历通道。如果通道为空,则一直等待,陷入阻塞,除非通道被关闭
            fmt.Println(value)
        }
    }
    
    • 可以主动判断通道是否关闭:
      value, ok := <-ch           // 从通道取出一个值,如果 ok 为 false 则说明通道已被关闭
      
  • 可以用 select 语句同时处理多个通道:

    for {
        select {
        case ch <- 1:
            fmt.Println("写入一次")
        case <- quit:
            fmt.Println("终止执行")
            return
        default:
            fmt.Println("sleep ...")
            time.Sleep(1000 * time.Millisecond)
        }
        }
    }
    
    • select 语句会检查哪个 case 条件满足,都不满足则执行 default 语句块。
    • 如果没有 default 语句,则 select 语句会保持阻塞,直到某个 case 条件满足,才执行相应的语句块。