本教程全面涵盖了Go语言基础的各个方面。一共80个例子，每个例子对应一个语言特性点，非常适合新人快速上手。
教程代码示例来自go by example，文字部分来自本人自己的理解。

本文是教程系列的第一部分，共计20个例子、约1万字。

1. Hello World

下面的例子演示了如何打印经典的“Hello world”语句，以及运行和编译go代码的方法。

package main
import "fmt"func main() {// 打印语句并换行fmt.Println("hello world")
}

// 可以通过go run命令直接从代码运行
$ go run hello-world.go
hello world// 也可以先通过go build先编译成可执行文件
$ go build hello-world.go
$ ls
hello-world    hello-world.go// 再运行可执行文件
$ ./hello-world
hello world

2. Values

下面的代码演示了打印不同类型变量的方法。

package mainimport "fmt"func main() {// 支持字符串通过加号拼接 fmt.Println("go" + "lang")// Println支持多个不同类型参数，参数之间会用空格拼接起来输出fmt.Println("1+1 =", 1+1)fmt.Println("7.0/3.0 =", 7.0/3.0)// 支持输出bool类型变量fmt.Println(true && false)fmt.Println(true || false)fmt.Println(!true)
}

$ go run values.go
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

3. Variables

下面的例子演示了定义和初始化变量的方法。Go的编译器可以做类型推导，无需显示指定类型。若对变量不做显式初始化，则会自动赋值为零值。

package mainimport "fmt"func main() {// 定义并初始化一个变量（类型会被自动推导为string）var a = "initial"fmt.Println(a)// 可以一次定义多个变量var b, c int = 1, 2fmt.Println(b, c)// 定义并初始化一个bool变量var d = truefmt.Println(d)// 定义变量并指定类型，但不显式初始化（自动初始化为零值，0）var e intfmt.Println(e)// 更简洁的变量定义语法，推荐f := "apple"fmt.Println(f)
}

$ go run variables.go
initial
1 2
true
0
apple

附：Go中的类型分类及零值大全

Go中的变量类型分为值类型、指针类型和引用类型三类。它们在函数传参时的表现有差异：值类型传递时是拷贝复制，而指针类型实际存储的是所指向变量的地址，经过拷贝复制后，在函数内部对所指变量的任何修改都能生效，外部变量会实际改变。至于引用类型，它并非是Go中的原生概念，而是一个语法糖，实际在内部封装了一个指针，例如map类型本质上就是 *hmap；这样做的好处是无需再显式使用指针，使用更方便。

4. Constants

下面的例子演示了用const关键字定义的常量。

package mainimport ("fmt""math"
)// 定义常量时用const代替var
const s string = "constant"func main() {fmt.Println(s)// 定义常量时也可不指定类型，此时无类型const n = 500000000// numeric常量支持任意精度的运算const d = 3e20 / nfmt.Println(d)// 可以通过强制转型赋予常量类型fmt.Println(int64(d))// 通过传参也可以为常量指定类型，如Sin函数指定float64fmt.Println(math.Sin(n))// 不能将非const变量的运算结果赋值给const变量，否则会编译报错！// i := 100// const j = 100// const k = i + j}

$ go run constant.go 
constant
6e+11
600000000000
-0.28470407323754404

5. For

下面例子展示了用for关键字实现的循环。Go中没有其他语言通常使用的while关键字，所有循环都通过for来实现。

package mainimport "fmt"func main() {i := 1// 类似于其他语言中的whilefor i <= 3 {fmt.Println(i)i = i + 1}// 常规for循环for j := 7; j <= 9; j++ {fmt.Println(j)}// 类似于其他语言中的while(true)for {fmt.Println("loop")break}for n := 0; n <= 5; n++ {if n%2 == 0 {continue}fmt.Println(n)}
}

$ go run for.go
1
2
3
7
8
9
loop
1
3
5

6. If/Else

下面例子展示了用if/else关键字实现的条件判断。

package mainimport "fmt"func main() {// if条件句无需加括号if 7%2 == 0 {fmt.Println("7 is even")// 注意}和else必须在同一行，否则会编译报错} else {fmt.Println("7 is odd")}if 8%4 == 0 {fmt.Println("8 is divisible by 4")}// if可支持多条语句，用分号分隔if num := 9; num < 0 {fmt.Println(num, "is negative")} else if num < 10 {fmt.Println(num, "has 1 digit")} else {fmt.Println(num, "has multiple digits")}
}

$ go run if-else.go 
7 is odd
8 is divisible by 4
9 has 1 digit

7. Switch

下面例子展示了switch关键字实现的分支条件判断。

package mainimport ("fmt""time"
)func main() {i := 2fmt.Print("Write ", i, " as ")switch i {case 1:fmt.Println("one")// 注意这里无需加break，一个条件命中后自动退出，否则继续遍历其他条件case 2:fmt.Println("two")case 3:fmt.Println("three")}switch time.Now().Weekday() {case time.Saturday, time.Sunday:fmt.Println("It's the weekend")default:fmt.Println("It's a weekday")}t := time.Now()switch {case t.Hour() < 12:fmt.Println("It's before noon")default:fmt.Println("It's after noon")}// 可以用于类型判断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")
}

$ go run switch.go 
Write 2 as two
It's a weekday
It's after noon
I'm a bool
I'm an int
Don't know type string

8. Arrays

下面例子展示了Go中数组的用法。数组用于存储有序、固定数量的元素。

package mainimport "fmt"func main() {// 定义数组变量，需要指明元素类型var a [5]int// 数组类型作为参数，可以直接打印出所有元素变量fmt.Println("emp:", a)a[4] = 100fmt.Println("set:", a)fmt.Println("get:", a[4])// 用len方法获取数组长度fmt.Println("len:", len(a))// 也可以在定义时直接初始化b := [5]int{1, 2, 3, 4, 5}fmt.Println("dcl:", b)// 二维数组的定义方法var twoD [2][3]intfor i := 0; i < 2; i++ {for j := 0; j < 3; j++ {twoD[i][j] = i + j}}fmt.Println("2d: ", twoD)
}

$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

9. Slices

下面例子介绍了切片的用法。切片是有序、不定长的数据结构，它的用法和数组非常类似，区别在于前者是不定长，后者是定长的。另一个区别是，前者是引用类型，后者是值类型，在函数传参时需要注意区分。

package mainimport "fmt"func main() {// slice需要用make初始化，否则会赋成零值nils := make([]string, 3)fmt.Println("emp:", s)s[0] = "a"s[1] = "b"s[2] = "c"fmt.Println("set:", s)fmt.Println("get:", s[2])fmt.Println("len:", len(s))// 可以动态往尾部添加元素s = append(s, "d")s = append(s, "e", "f")fmt.Println("apd:", s)c := make([]string, len(s))// copy可用于拷贝slicecopy(c, s)fmt.Println("cpy:", c)// 可以灵活按下标生成新slicel := s[2:5]fmt.Println("sl1:", l)l = s[:5]fmt.Println("sl2:", l)l = s[2:]fmt.Println("sl3:", l)// slice可以和array一样在定义时初始化t := []string{"g", "h", "i"}fmt.Println("dcl:", t)twoD := make([][]int, 3)for i := 0; i < 3; i++ {innerLen := i + 1twoD[i] = make([]int, innerLen)for j := 0; j < innerLen; j++ {twoD[i][j] = i + j}}fmt.Println("2d: ", twoD)
}

$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

10. Maps

下面例子展示了map的用法。map用于key-value二元关系数据的存储。

package mainimport "fmt"func main() {// map是引用类型，也需要用make初始化m := make(map[string]int)m["k1"] = 7m["k2"] = 13fmt.Println("map:", m)v1 := m["k1"]fmt.Println("v1: ", v1)fmt.Println("len:", len(m))delete(m, "k2")fmt.Println("map:", m)// 可以通过返回的第二个参数判断key是否存在于map中_, prs := m["k2"]fmt.Println("prs:", prs)// 可以在定义时直接初始化n := map[string]int{"foo": 1, "bar": 2}fmt.Println("map:", n)
}

$ go run maps.go 
map: map[k1:7 k2:13]
v1:  7
len: 2
map: map[k1:7]
prs: false
map: map[bar:2 foo:1]

11. Range

下面例子展示了range关键字在遍历slice、map和string时的用法。

package mainimport "fmt"func main() {nums := []int{2, 3, 4}sum := 0for _, num := range nums {sum += num}fmt.Println("sum:", sum)// 遍历slice返回的变量，第一个是下标，第二个是对应下标的元素for i, num := range nums {if num == 3 {fmt.Println("index:", i)}}// 遍历map返回的变量，第一个是key，第二个是valuekvs := map[string]string{"a": "apple", "b": "banana"}for k, v := range kvs {fmt.Printf("%s -> %s\n", k, v)}for k := range kvs {fmt.Println("key:", k)}// 遍历string返回的变量，第一个是对应rune的byte的起始下标，第二个是对应的runefor i, c := range "go" {fmt.Println(i, c)}for i, c := range "我们" {fmt.Println(i, c)}
}

$ go run range.go
sum: 9
index: 1
a -> apple
b -> banana
key: a
key: b
0 103
1 111
0 25105
3 20204

12. Functions

下面例子展示了func关键字定义的函数。

package mainimport "fmt"// 定义函数，顺序：func、函数名、参数列表、返回值类型
func plus(a int, b int) int {return a + b
}func plusPlus(a, b, c int) int {return a + b + c
}func main() {res := plus(1, 2)fmt.Println("1+2 =", res)res = plusPlus(1, 2, 3)fmt.Println("1+2+3 =", res)
}

$ go run functions.go 
1+2 = 3
1+2+3 = 6

13. Multiple Return Values

下面例子展示了拥有多个返回值的函数。

package mainimport "fmt"func vals() (int, int) {return 3, 7
}func main() {a, b := vals()fmt.Println(a)fmt.Println(b)// 可以用_占位，表示这个变量不实际使用_, c := vals()fmt.Println(c)
}

$ go run multiple-return-values.go
3
7
7

14. Variadic Functions

下面例子展示了变长参数函数的用法。变长参数提供了传参的灵活性，可以是多个不定数量的参数，也可以是slice。

package mainimport "fmt"// 用...表示变长参数
func sum(nums ...int) {fmt.Print(nums, " ")total := 0for _, num := range nums {total += num}fmt.Println(total)
}func main() {// 可用于多个参数sum(1, 2)sum(1, 2, 3)// 也可用于slice，注意要加...nums := []int{1, 2, 3, 4}sum(nums...)
}

$ go run variadic-functions.go 
[1 2] 3
[1 2 3] 6
[1 2 3 4] 10

15. Closures

下面的例子展示了闭包的概念。闭包一般与匿名函数相关，匿名函数可以引用外部函数中定义的变量，对其形成闭包。该变量可作为“半全局变量”，生命周期存在于多次匿名函数调用中，任何对它的修改都可在匿名函数中可见。

package mainimport "fmt"func intSeq() func() int {i := 0// 匿名函数对外部定义的i形成闭包return func() int {i++return i}
}func main() {nextInt := intSeq()// 每次调用匿名函数都会将i加1fmt.Println(nextInt())fmt.Println(nextInt())fmt.Println(nextInt())newInts := intSeq()fmt.Println(newInts())
}

$ go run closures.go
1
2
3
1

16. Recursion

下面例子展示了函数递归的用法。

package mainimport "fmt"func fact(n int) int {if n == 0 {return 1}return n * fact(n-1)
}func main() {fmt.Println(fact(7))var fib func(n int) intfib = func(n int) int {if n < 2 {return n}return fib(n-1) + fib(n-2)}fmt.Println(fib(7))
}

$ go run recursion.go 
5040
13

17. Pointers

下面例子展示了指针的用法。对于值类型的变量，如果传参给函数后需要在内部做修改，那么需要使用指针传递。

package mainimport "fmt"// 通过值传递，仅拷贝变量，不会修改实际值
func zeroval(ival int) {ival = 0
}// 通过指针传递，可以修改实际值
func zeroptr(iptr *int) {*iptr = 0
}func main() {i := 1fmt.Println("initial:", i)zeroval(i)fmt.Println("zeroval:", i)// 用&获取指针，即变量i的地址zeroptr(&i)fmt.Println("zeroptr:", i)fmt.Println("pointer:", &i)
}

$ go run pointers.go
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100

18. Strings and Runes

下面例子展示了string与rune的关系。string可以看做是由byte元素组成的slice，默认采用UTF-8编码。rune类似于其他语言中的character，它是code point，即该字符在字符表中的唯一序号。注意它与encoding概念不同，encoding代表不同编码方式，如UTF-8、UTF-16，对同一个字符可以使用不同长度的编码来表示。

package mainimport ("fmt""unicode/utf8"
)func main() {const s = "สวัสดี"// len获取底层byte slice的长度fmt.Println("Len:", len(s))// 打印底层的每个bytefor i := 0; i < len(s); i++ {fmt.Printf("%x ", s[i])}fmt.Println()fmt.Println("Rune count:", utf8.RuneCountInString(s))// 用range遍历，获取的是每个rune及对应的byte起始下标。使用UTF-8编码，每个rune占用3个字节for idx, runeValue := range s {fmt.Printf("%#U starts at %d\n", runeValue, idx)}fmt.Println("\nUsing DecodeRuneInString")for i, w := 0, 0; i < len(s); i += w {// 使用DecodeRuneInString也能达到同样的遍历效果runeValue, width := utf8.DecodeRuneInString(s[i:])fmt.Printf("%#U starts at %d\n", runeValue, i)w = widthexamineRune(runeValue)}
}func examineRune(r rune) {if r == 't' {fmt.Println("found tee")} else if r == 'ส' {fmt.Println("found so sua")}
}

$ go run strings-and-runes.go
Len: 18
e0 b8 aa e0 b8 a7 e0 b8 b1 e0 b8 aa e0 b8 94 e0 b8 b5 
Rune count: 6
U+0E2A 'ส' starts at 0
U+0E27 'ว' starts at 3
U+0E31 'ั' starts at 6
U+0E2A 'ส' starts at 9
U+0E14 'ด' starts at 12
U+0E35 'ี' starts at 15Using DecodeRuneInString
U+0E2A 'ส' starts at 0
found so sua
U+0E27 'ว' starts at 3
U+0E31 'ั' starts at 6
U+0E2A 'ส' starts at 9
found so sua
U+0E14 'ด' starts at 12
U+0E35 'ี' starts at 15

19. Structs

下面例子展示了用struct关键字实现结构体。结构体是一种自定义类型，属于值变量类型，它可以用于多个变量的封装。

package mainimport "fmt"// 定义新struct类型，顺序：type、struct名、struct
type person struct {name stringage  int
}func newPerson(name string) *person {// 定义struct变量p := person{name: name}p.age = 42return &p
}func main() {fmt.Println(person{"Bob", 20})fmt.Println(person{name: "Alice", age: 30})fmt.Println(person{name: "Fred"})fmt.Println(&person{name: "Ann", age: 40})fmt.Println(newPerson("Jon"))s := person{name: "Sean", age: 50}fmt.Println(s.name)sp := &sfmt.Println(sp.age)sp.age = 51fmt.Println(sp.age)
}

$ go run structs.go
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
&{Jon 42}
Sean
50
51

20. Methods

下面例子展示了方法的使用。Go非传统面向对象语言，没有其他语言中的class关键字。但可以使用结构体和方法达到类似的效果。与一般的函数不同，方法需要指定struct类型的值或者指针作为接收者，接收者的角色类似于其他语言中的对象。

package mainimport "fmt"type rect struct {width, height int
}// 方法定义，顺序：func、接收者、方法名、返回值类型
// 接收者可以是struct类型的指针
func (r *rect) area() int {return r.width * r.height
}// 接受者也可以是struct类型的值
func (r rect) perim() int {return 2*r.width + 2*r.height
}func main() {r := rect{width: 10, height: 5}// go可以自动做struct值类型和指针类型的转换，使得与方法定义适配fmt.Println("area: ", r.area())fmt.Println("perim:", r.perim())rp := &rfmt.Println("area: ", rp.area())fmt.Println("perim:", rp.perim())
}

$ go run methods.go 
area:  50
perim: 30
area:  50
perim: 30