Go 语法 #

变量 #

var a string = "short"

// Go 会自动推断已经有初始值的变量的类型。
var b = true

// 声明后却没有给出对应的初始值时，变量将会初始化为零值 。
// 例如，`int` 的零值是 `0`。
var c int

// `:=` 语法是声明并初始化变量的简写，
d := "short"

常量 #

const 语句可以出现在任何 var 语句可以出现的地方

一个数字可以根据上下文的需要（比如变量赋值、函数调用）自动确定类型。

// 这里的 `math.Sin` 函数需要一个 `float64` 的参数，`n` 会自动确定类型。
const n = 500000000
fmt.Println(math.Sin(n))

for 循环 #

for 是 Go 中唯一的循环结构。

// 最基础的方式，单个循环条件。
i := 1
for i <= 3 {
    fmt.Println(i)
    i = i + 1
}

// 经典的初始/条件/后续 `for` 循环。
for j := 7; j <= 9; j++ {
    fmt.Println(j)
}

// 不带条件的 `for` 循环将一直重复执行，
// 直到在循环体内使用了 `break` 或者 `return` 跳出循环。
for {
    fmt.Println("loop")
    break
}

// 你也可以使用 `continue` 直接进入下一次循环。
for n := 0; n <= 5; n++ {
    if n%2 == 0 {
        continue
    }
    fmt.Println(n)
}

switch #

case 表达式可以不使用常量

不带表达式的 switch 是实现 if/else 逻辑的另一种方式。

t := time.Now()
switch {
case t.Hour() < 12:
	fmt.Println("It's before noon")
default:
	fmt.Println("It's after noon")
}

类型开关 (type switch) 比较类型而非值。可以用来发现一个接口值的类型。

// 在这个例子中，变量 `t` 在每个分支中会有相应的类型。
whatAmI := func(i interface{}) {
    switch t := i.(type) {
    case bool:
        fmt.Println("I'm a bool")
    case int:
        fmt.Println("I'm an int")
    default:
        fmt.Printf("Don't know type %T\n", t)
    }
}
whatAmI(true)
whatAmI(1)
whatAmI("hey")

map #

//创建一个空 map
m := make(map[string]int)
m["k1"] = 7
m["k2"] = 13

// 内建函数 `delete` 可以从一个 map 中移除键值对
delete(m, "k2")

// 可以 选择 使用第二个参数，判断是否存在 key
v2, ok := m["k2"]

// 声明并初始化
n := map[string]int{"foo": 1, "bar": 2}

range #

kvs := map[string]string{"a": 1, "b": 2}
for k, v := range kvs {

}

// `range` 也可以只遍历 map 的键
for k := range kvs {

}

// `range` 在字符串中迭代 unicode 码点(code point)。
// 第一个返回值是字符的起始字节位置，然后第二个是字符本身。
// 输出：
// 0 103
// 1 111
// 2 103
// 3 111
for i, c := range "gogo" {
    fmt.Println(i, c)
}

// 输出：
// 0
// 1
// 2
// 3
for i := range "gogo" {
    fmt.Println(i)
}