导入包

1
2
3
4
5
6
import (
	"fmt"
	"math/rand"
)
import "fmt"
import "math"

导出名

如果一个名字以大写字母开头，那么它就是已导出的

变量

1
2
3
4
var x int = 3 // 显示定义变量 和对应类型 + 初始化
x := 3  // 隐式定义变量和初始化，只能用于函数内部
x, y := 1, 2 // 定义多个
const Pi = 3.14

函数

1
2
3
4
5
6
7
8
func add(x, y int) int {
    return x + y
}
func test() (x, y int) {
    x = 1
    y = 2
    return // 1, 2
}

类型

  • 整数：int int8~int16 uint uint8~uint64
  • 浮点数: float32 float64
  • 复数：complex64 complex128
  • 字符串: string
  • 布尔值：bool
  • 字符：byte(一个字节,等于uint8) rune(一个Unicode字符,等于int32)

类型转换：var i int = 42 var f float64 = float64(i)

循环

1
2
3
4
5
for i := 0; i < 10; i++ { // 初始化，条件表达式，后置语句 都可以省略 大括号必须要
    // todo
}
for i < 10 {} // 类似 while
for {}  // 无限循环

条件判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if i = 1; i < 10 {} // 初始化可省略 大括号必须要

switch i = 1; i { // 类似更便捷的 if else
    case 1 + 1 : 
        fmt.Printf(3)
    case 1:
        fmt.Printf(1)
        fallthrough // 以这个结尾会进入下一个分支，默认直接退出
    case 2:
        fmt.Printf(2)
    default:
        fmt.Printf(0)
}
// 打印 1 2

switch { // 比 if else 更清晰
    case t.Hour() < 12:
		fmt.Println("早上好！")
	case t.Hour() < 17:
		fmt.Println("下午好！")
	default:
		fmt.Println("晚上好！")
}

defer 延迟执行

1
2
3
4
5
6
7
func main() {
	defer fmt.Println("world1") // 函数最后执行
    defer fmt.Println("world2") // 函数最后执行

	fmt.Println("hello")
}
// hello world2 world1

可以用于 资源释放 释放锁 关闭文件 处理错误等

指针

1
2
3
4
5
var p *int
i := 42
p = &i
fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

结构体

1
2
3
4
5
6
7
8
9
type Vertex struct {
	X int
	Y int
}

var v = Vertex{1, 2} // v = Vertex{X:1}, v = Vertex{}
fmt.Println(v.X, v.Y)
p := &v // 结构体指针
fmt.Println(p.X)  // 结构体指针会隐式解引用 不需要写 (*p).X