Go基础

Love The Way You Lie 2022-04-23 07:48 197阅读 0赞

### Go基础 ###

*  包、变量和函数
 *   *  包
     *  导入
     *  导出名
     *  函数
     *  多值返回
     *  命名返回值
     *  变量的声明
     *  变量的初始化
     *  短变量声明
     *  基本类型
     *  零值
     *  类型转换
     *  类型推导
     *  常量
     *  数值常量
 *  流程控制语句：for、if、else、switch 和 defer
 *   *  for
     *  if
     *  if 的简短语句
     *  if 和 else
     *  switch
     *  switch 的求值顺序
     *  没有条件的 switch
     *  defer
     *  defer 栈
 *  更多类型：struct、slice 和映射
 *   *  指针
     *  结构体
     *   *  结构体字段
         *  结构体指针
         *  结构体文法
     *  数组
     *  切片
     *   *  切片就像数组的引用
         *  切片文法
         *  切片的默认行为
         *  切片的长度与容量
         *  nil 切片
         *  用 make 创建切片
         *  切片的切片
         *  向切片追加元素
         *  Range
         *  练习：切片
     *  映射
     *   *  映射的文法
         *  
         *  练习：映射
     *  函数值
     *   *  函数的闭包
         *  练习：斐波纳契闭包

`来自：https://tour.go-zh.org/list`

# 包、变量和函数 #

学习 Go 程序的基本结构。

## 包 ##

每个 Go 程序都是由包构成的。

程序从 **main 包**开始运行。

本程序通过导入路径 “fmt” 和 “math/rand” 来使用这两个包。

按照约定，包名与**导入路径的最后一个元素**一致。例如，“math/rand” 包中的源码均以 package rand 语句开始。

*注意：* 此程序的运行环境是固定的，因此 rand.Intn 总是会返回相同的数字。

（要得到不同的数字，需为生成器提供不同的种子数，参见 rand.Seed。 练习场中的时间为常量，因此你需要用其它的值作为种子数。）

package main
    
    import (
    	"fmt"
    	"math/rand"
    )
    
    func main() {
        
    	rand.Seed(60)
    	fmt.Println("My favorite number is", rand.Intn(5))
    }

## 导入 ##

此代码用圆括号组合了导入，这是“分组”形式的导入语句。

当然你也可以编写多个导入语句，例如：

import "fmt"
    import "math"

不过**使用分组导入语句是更好的形式**。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    	fmt.Printf("Now you have %g problems.\n", math.Sqrt(7))
    	fmt.Printf("Now you have %g problems.\n", math.Sqrt(9))
    }

## 导出名 ##

在 Go 中，如果一个名字以**大写字母**开头，那么它就是**已导出**的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

pizza 和 pi 并未以大写字母开头，所以它们是未导出的。

在导入一个包时，你**只能引用其中已导出的**名字。任何\*\*“未导出”的名字在该包外均无法访问\*\*。

执行代码，观察错误输出。

然后将 math.pi 改名为 math.Pi 再试着执行一次。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    	// prog.go:9:14: cannot refer to unexported name math.pi
    	// prog.go:9:14: undefined: math.pi
    	// fmt.Println(math.pi)
    	fmt.Println(math.Pi)  // 3.141592653589793
    }

## 函数 ##

函数可以**没有参数**或接受**多个参数**。

在本例中，add 接受两个 int 类型的参数。

注意类型在变量名 之后。

package main
    
    import "fmt"
    
    func add(x int, y int) int {
        
    	return x + y
    }
    
    func main() {
        
    	fmt.Println(add(50, 8))
    }

当连续两个或多个函数的已命名形参**类型相同**时，除最后一个类型以外，其它都可以省略。

在本例中，

x int, y int

被缩写为

x, y int

package main
    
    import "fmt"
    
    
    func add(x, y int) int{
        
    	return x + y
    }
    
    func main() {
        
    	fmt.Println(add(42, 13))
    }

## 多值返回 ##

函数可以**返回任意数量**的返回值。

swap 函数返回了两个字符串。

package main
    
    import "fmt"
    
    func swap(x, y string) (string, string) {
        
    	return y, x
    }
    
    func main() {
        
    	
    	// var a, b string
    	// a, b = swap("hello", "world")
    	// 上面两句可替换为下面一句
    	
    	a, b := swap("hello", "world")
    
    	fmt.Println(a, b) // world hello
    }

## 命名返回值 ##

Go 的返回值**可被命名**，它们会被视作定义在**函数顶部**的变量。

返回值的名称应当具有一定的意义，它可以作为文档使用。

**没有参数的 return** 语句返回**已命名的返回值**。也就是 直接 返回。

直接返回语句应当仅用在下面这样的短函数中。在长的函数中它们会影响代码的可读性。

func split(sum int) (x, y int) {
        
    	x = sum * 4 / 9
    	y = sum - x
    	return 
    }

## 变量的声明 ##

var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

就像在这个例子中看到的一样，var 语句可以出现在**包或函数级别**。

package main
    
    import "fmt"
    
    var c, python, java bool
    
    func main() {
        
    	var i int
    	fmt.Println(i, c, python, java)
    }

## 变量的初始化 ##

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

package main
    
    import "fmt"
    
    var i, j int = 1, 3
    
    func main() {
        
    	var c, python, java = true, false, "no!"
    	j = 1
    	fmt.Println(i, j, c, python, java)
    }

## 短变量声明 ##

在函数中，简洁赋值语句 **:=** 可在**类型明确**的地方**代替 var 声明**。

**函数外**的每个语句都必须**以关键字开始**（var, func 等等），因此 **:= 结构不能在函数外使用**。

package main
    
    import "fmt"
    
    func main() {
        
    	var i, j int = 1, 2
    	k := 3
    	c, python, java := true, false, "no!"
    
    	fmt.Println(i, j, k, c, python, java)
    }

## 基本类型 ##

Go 的基本类型有

bool
    
    string
    
    int  int8  int16  int32  int64
    uint uint8 uint16 uint32 uint64 uintptr
    
    byte // uint8 的别名
    
    rune // int32 的别名
        // 表示一个 Unicode 码点
    
    float32 float64
    
    complex64 complex128 // 复数

本例展示了几种类型的变量。 同导入语句一样，变量声明也可以“分组”成一个语法块。

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

package main
    
    import (
    	"fmt"
    	"math/cmplx"
    )
    
    var (
    	ToBe   bool       = false
    	MaxInt uint64     = 1<<64 - 1
    	z      complex128 = cmplx.Sqrt(-5 + 12i)
    )
    
    func main() {
        
    	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)      // false
    	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)  // 18446744073709551615(2^64-1)
    	fmt.Printf("Type: %T Value: %v\n", z, z)            // (2+3i)
    }

## 零值 ##

没有明确初始值的变量声明会被赋予它们的 零值。

零值是：

数值类型为 0，
    布尔类型为 false，
    字符串为 ""（空字符串）。

package main
    
    import "fmt"
    
    func main() {
        
    	var i int
    	var f float64
    	var b bool
    	var s string
    	fmt.Printf("%v %v %v %q\n", i, f, b, s) // 0 0 false ""
    }

**这里需要补充fmt格式的占位符说明。  
[https://studygolang.com/articles/2644][https_studygolang.com_articles_2644]**

## 类型转换 ##

表达式 T(v) 将值 v 转换为类型 T。

一些关于数值的转换：

var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

或者，更加简单的形式：

i := 42
    f := float64(i)
    u := uint(f)

与 C 不同的是，Go 在不同类型的项之间赋值时需要显式转换。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    	var x, y int = 3, 4
    	var f float64 = math.Sqrt(float64(x*x + y*y))
    	var z uint = uint(f)
    	fmt.Println(x, y, z) // 3 4 5
    }

## 类型推导 ##

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型**由右值推导**得出。

当右值声明了类型时，新变量的类型与其相同：

var i int
    j := i // j 也是一个 int

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度：

i := 42           // int
    f := 3.142        // float64
    g := 0.867 + 0.5i // complex128

package main
    
    import "fmt"
    
    func main() {
        
    	v := 42
    	fmt.Printf("v is of type %T\n", v)  // v is of type int
    	
    	x := 42i 
    	fmt.Printf("x is of type %T\n", x)  // x is of type complex128
    }

## 常量 ##

常量的声明与变量类似，只不过是使用 const 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

package main
    
    import "fmt"
    
    const Pi = 3.14
    
    func main() {
        
    	const World = "世界"
    	fmt.Println("Hello", World)
    	fmt.Println("Happy", Pi, "Day")
    
    	const Truth = true
    	fmt.Println("Go rules?", Truth)
    
    	// Hello 世界
    	// Happy 3.14 Day
    	// Go rules? true
    }

## 数值常量 ##

数值常量是高精度的 值。

一个未指定类型的常量由上下文来决定其类型。

再尝试一下输出 needInt(Big) 吧。

（int 类型最大可以存储一个 64 位的整数，有时会更小。）

（int 可以存放最大64位的整数，根据平台不同有时会更少。）

package main
    
    import "fmt"
    
    const (
    	// 将 1 左移 100 位来创建一个非常大的数字
    	// 即这个数的二进制是 1 后面跟着 100 个 0
    	Big = 1 << 100
    	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
    	Small = Big >> 99
    )
    
    func needInt(x int) int {
         return x*10 + 1 }
    func needFloat(x float64) float64 {
        
    	return x * 0.1
    }
    
    func main() {
        
    	fmt.Println(needInt(Small))
    	// prog.go:20:21: constant 1267650600228229401496703205376 overflows int
    	// fmt.Println(needInt(Big))
    	fmt.Println(needFloat(Small))
    	fmt.Println(needFloat(Big))
    }

# 流程控制语句：for、if、else、switch 和 defer #

学习如何使用条件、循环、分支和推迟语句来控制代码的流程。

## for ##

Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行  
条件表达式：在每次迭代前求值  
后置语句：在每次迭代的结尾执行  
初始化语句通常为一句短变量声明，该变量声明**仅在 for 语句的作用域**中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止。

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号， **大括号 \{ \} 则是必须的**。

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 0
    	for i := 0; i < 10; i++ {
        
    		sum += i
    	}
    	fmt.Println(sum)
    }

**初始化语句和后置语句是可选的。**

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 1
    	for ; sum < 100; {
        
    		sum += sum
    	}
    	fmt.Println(sum) // 128
    }

**for 是 Go 中的 “while”**  
此时你**可以去掉分号**，因为 C 的 while 在 Go 中叫做 for。

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 1
    	for sum < 1000 {
        
    		sum += sum
    	}
    	fmt.Println(sum)
    }

**无限循环**  
如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。

package main
    
    import "fmt"
    
    func main() {
        
    	for {
        
    	}
    }

## if ##

Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 \{ \} 则是必须的。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func sqrt(x float64) string {
        
    	if x < 0 {
        
    		return sqrt(-x) + "i"
    	}
    	return fmt.Sprint(math.Sqrt(x))
    }
    
    func main() {
        
    	fmt.Println(sqrt(2), sqrt(-4))
    }

## if 的简短语句 ##

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的**变量作用域仅在 if 之内**。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func pow(x, n, lim float64) float64 {
        
    	if v := math.Pow(x, n); v < lim {
        
    		return v
    	}
    	return lim
    }
    
    func main() {
        
    	fmt.Println(
    		pow(3, 2, 10),
    		pow(3, 3, 20),
    	)
    	// 9 20
    }

## if 和 else ##

在 if 的简短语句中声明的变量同样**可以在任何对应的 else 块**中使用。  
（在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回其各自的结果。）

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func pow(x, n, lim float64) float64 {
        
    	if v := math.Pow(x, n); v < lim {
        
    		return v
    	} else {
        
    		fmt.Printf("%g >= %g\n", v, lim)
    	}
    	// 这里开始就不能使用 v 了
    	return lim
    }
    
    func main() {
        
    	fmt.Println(
    		pow(3, 2, 10),
    		pow(3, 3, 20),
    	)
    	// 27 >= 20
    	// 9 20
    	// 在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回其各自的结果。
    	// 所以先打印 27 >= 20
    	// 紧接着依次打印两个调用的返回值
    
    }

## switch ##

switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go **只运行选定的 case**，而非之后所有的 case。 实际上，**Go 自动提供了在这些语言中每个 case 后面所需的 break 语句**。 除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 **switch 的 case 无需为常量，且取值不必为整数。**

package main
    
    import (
    	"fmt"
    	"runtime"
    )
    
    func main() {
        
    	fmt.Print("Go runs on ")
    	//  runtime.GOOS:目标操作系统
    	switch os := runtime.GOOS; os {
        
    	case "darwin":
    		fmt.Println("OS X.")
    	case "linux":
    		fmt.Println("Linux.")
    	default:
    		// freebsd, openbsd,
    		// plan9, windows...
    		fmt.Printf("%s.\n", os)
    	}
    }

## switch 的求值顺序 ##

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

（例如，

switch i {
    case 0:
    case f():
    }

在 i==0 时 f 不会被调用。）

package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func main() {
        
    	fmt.Println("When's Saturday?")
    	today := time.Now().Weekday()
    	fmt.Println("Today is:",today)
    	switch time.Wednesday {
        
    	case today + 0:
    		fmt.Println("Today.")
    	case today + 1:
    		fmt.Println("Tomorrow.")
    	case today + 2:
    		fmt.Println("In two days.")
    	default:
    		fmt.Println("Too far away.")
    	}
    	// When's Saturday?
    	// Today is: Tuesday
    	// Tomorrow.
    }

## 没有条件的 switch ##

没有条件的 switch 同 switch true 一样。

这种形式能将一长串 if-then-else 写得更加清晰。

package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func main() {
        
    	t := time.Now()
    	fmt.Println(t.Hour())
    	switch {
        
    	case t.Hour() < 12:
    		fmt.Println("Good morning!")
    	case t.Hour() < 17:
    		fmt.Println("Good afternoon.")
    	default:
    		fmt.Println("Good evening.")
    	}
    	// 23
    	// Good evening.
    
    }

## defer ##

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数**会立即求值**，但直到**外层函数返回前该函数都不会被调用**。

package main
    
    import "fmt"
    
    func main() {
        
    	defer fmt.Println("world")
    
    	fmt.Println("hello")
    
    	// hello
    	// world
    }

## defer 栈 ##

推迟的函数调用**会被压入一个栈中**。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

package main
    
    import "fmt"
    
    func main() {
        
    	fmt.Println("counting")
    
    	for i := 0; i < 10; i++ {
        
    		defer fmt.Println(i)
    	}
    
    	fmt.Println("done")
    	
    	// counting
    	// done
    	// 9
    	// 8
    	// 7
    	// 6
    	// 5
    	// 4
    	// 3
    	// 2
    	// 1
    	// 0
    }

# 更多类型：struct、slice 和映射 #

学习如何基于现有类型定义新的类型：本节课涵盖了结构体、数组、切片和映射。

## 指针 ##

Go 拥有指针。指针保存了值的内存地址。

类型 \*T 是指向 T 类型值的指针。其零值为 nil。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
    p = &i

*  操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
    *p = 21         // 通过指针 p 设置 i

这也就是通常所说的“间接引用”或“重定向”。

与 C 不同，Go 没有指针运算。

package main
    
    import "fmt"
    
    func main() {
        
    	i, j := 42, 2701
    
    	p := &i         // 指向 i
    	fmt.Println(*p) // 通过指针读取 i 的值 // 42
    	*p = 21         // 通过指针设置 i 的值 
    	fmt.Println(i)  // 查看 i 的值        // 21
    
    	p = &j         // 指向 j
    	*p = *p / 37   // 通过指针对 j 进行除法运算
    	fmt.Println(j) // 查看 i 的值        // 73
    }

## 结构体 ##

一个结构体（struct）就是一个**字段的集合**。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	X int
    	Y int
    }
    
    func main() {
        
    	fmt.Println(Vertex{
        1, 2}) // {1 2}
    }

### 结构体字段 ###

结构体字段使用**点号**来访问。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	X int
    	Y int
    }
    
    func main() {
        
    	v := Vertex{
        1, 2}
    	v.X = 4
    	fmt.Println(v.X)
    }

### 结构体指针 ###

结构体字段可以通过**结构体指针**来访问。

如果我们有一个指向结构体的指针 p，那么可以通过 (\*p).X 来访问其字段 X。不过这么写太啰嗦了，所以语言也允许我们使用**隐式间接引用**，直接写 **p.X** 就可以。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	X int
    	Y int
    }
    
    func main() {
        
    	v := Vertex{
        1, 2}
    	p := &v
    	p.X = 10
    	fmt.Println(v)
    }

### 结构体文法 ###

结构体文法通过直接列出字段的值来新分配一个结构体。

使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

特殊的**前缀 &** 返回一个**指向结构体的指针**。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	X, Y int
    }
    
    var (
    	v1 = Vertex{
        1, 2}  // 创建一个 Vertex 类型的结构体
    	v2 = Vertex{
        X: 1}  // Y:0 被隐式地赋予
    	v3 = Vertex{
        }      // X:0 Y:0
    	p  = &Vertex{
        1, 2} // 创建一个 *Vertex 类型的结构体（指针）
    )
    
    func main() {
        
    	fmt.Println(v1, *p, v2, v3) // {1 2} {1 2} {1 0} {0 0}
    	fmt.Println(v1, p, v2, v3) // {1 2} &{1 2} {1 0} {0 0}
    }

## 数组 ##

类型 **\[n\]T** 表示拥有 n 个 T 类型的值的数组。

表达式

var a [10]int

会将变量 a 声明为拥有 10 个整数的数组。

**数组的长度是其类型的一部分**，因此数组**不能改变大小**。这看起来是个限制，不过没关系，Go 提供了更加便利的方式来使用数组。

package main
    
    import "fmt"
    
    func main() {
        
    	var a [2]string
    	a[0] = "Hello"
    	a[1] = "World"
    	fmt.Println(a[0], a[1]) // Hello World
    	fmt.Println(a) // [Hello World]
    
    	primes := [6]int{
        2, 3, 5, 7, 11, 13} // [2 3 5 7 11 13]
    	fmt.Println(primes)
    }

## 切片 ##

每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中，**切片比数组更常用。**

类型 **\[\]T** 表示一个元素类型为 T 的切片。

切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：

a[low : high]

它会选择一个**半开区间**，包括第一个元素，但排除最后一个元素。

以下表达式创建了一个切片，它包含 a 中下标从 1 到 3 的元素：

a[1:4]

package main
    
    import "fmt"
    
    func main() {
        
    	primes := [6]int{
        2, 3, 5, 7, 11, 13}
    
    	var s []int = primes[1:4]
    	fmt.Println(s) // [3 5 7]
    }

### 切片就像数组的引用 ###

切片并不存储任何数据，它只是描述了底层数组中的一段。

**更改切片的元素会修改其底层数组中对应的元素。**

**与它共享底层数组的切片**都会观测到这些修改。

package main
    
    import "fmt"
    
    func main() {
        
    	names := [4]string{
        
    		"John",
    		"Paul",
    		"George",
    		"Ringo",
    	}
    	fmt.Println(names) // [John Paul George Ringo]
    
    	a := names[0:2]
    	b := names[1:3]
    	fmt.Println(a, b) // [John Paul] [Paul George]
    
    	b[0] = "XXX"
    	fmt.Println(a, b) // [John XXX] [XXX George]
    	fmt.Println(names) // [John XXX George Ringo]
    }

### 切片文法 ###

切片文法类似于**没有长度**的数组文法。

这是一个数组文法：

[3]bool{true, true, false}

下面这样则会创建一个和上面相同的数组，然后构建一个引用了它的切片：

[]bool{true, true, false}

package main
    
    import "fmt"
    
    func main() {
        
    	q := []int{
        2, 3, 5, 7, 11, 13}
    	fmt.Println(q) // [2, 3, 5, 7, 11, 13]
    
    	r := []bool{
        true, false, true, true, false, true}
    	fmt.Println(r) // [true, false, true, true, false, true]
    
    	s := []struct {
        
    		i int
    		b bool
    	}{
        
    		{
        2, true},
    		{
        3, false},
    		{
        5, true},
    		{
        7, true},
    		{
        11, false},
    		{
        13, true},
    	}
    	fmt.Println(s) // [{2 true} {3 false} {5 true} {7 true} {11 false} {13 true}]
    }

### 切片的默认行为 ###

在进行切片时，你可以利用它的默认行为来忽略上下界。

切片下界的默认值为 0，上界则是该切片的长度。

对于数组

var a [10]int

来说，以下切片是等价的：

a[0:10]
    a[:10]
    a[0:]
    a[:]

package main
    
    import "fmt"
    
    func main() {
        
    	s := []int{
        2, 3, 5, 7, 11, 13}
    
    	s = s[1:4]
    	fmt.Println(s) // [3 5 7]
    
    	s = s[:2]
    	fmt.Println(s) // [3 5] //注意：s已经改变了
    
    	s = s[1:]
    	fmt.Println(s) // [5] //注意：s已经改变了
    }

### 切片的长度与容量 ###

切片拥有 **长度** 和 **容量**。

切片的长度就是它所**包含的元素个数**。

切片的容量是从它的**第一个元素开始数，到其底层数组元素末尾的个数。**

切片 s 的长度和容量可通过表达式 **len(s)** 和 **cap(s)** 来获取。

你可以通过**重新切片**来扩展一个切片，给它提供足够的容量。

package main
    
    import "fmt"
    
    func main() {
        
    	s := []int{
        2, 3, 5, 7, 11, 13}
    	printSlice(s) // len=6 cap=6 [2 3 5 7 11 13]
    
    	// 截取切片使其长度为 0
    	s = s[:0]
    	printSlice(s) // len=0 cap=6 []
    
    	// 拓展其长度
    	s = s[:4]
    	printSlice(s) // len=4 cap=6 [2 3 5 7]
    
    	// 舍弃前两个值
    	s = s[2:]
    	printSlice(s) // len=2 cap=4 [5 7]
    }
    
    func printSlice(s []int) {
        
    	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
    }

### nil 切片 ###

切片的**零值**是 nil。

nil 切片的**长度和容量为 0** 且**没有底层数组**。

package main
    
    import "fmt"
    
    func main() {
        
    	var s []int
    	fmt.Println(s, len(s), cap(s))
    	if s == nil {
        
    		fmt.Println("nil!")
    	}
    }

### 用 make 创建切片 ###

切片可以用内建函数 make 来创建，这也是你创建**动态数组**的方式。

make 函数会分配一个**元素为零值**的数组并返回一个引用了它的切片：

a := make([]int, 5)  // len(a)=5

要指定它的容量，需向 make 传入第三个参数：

b := make([]int, 0, 5) // len(b)=0, cap(b)=5
    
    b = b[:cap(b)] // len(b)=5, cap(b)=5
    b = b[1:]      // len(b)=4, cap(b)=4

package main
    
    import "fmt"
    
    func main() {
        
    	a := make([]int, 5)
    	printSlice("a", a) // a len=5 cap=5 [0 0 0 0 0]
    
    	b := make([]int, 0, 5)
    	printSlice("b", b) // b len=0 cap=5 []
    
    	c := b[:2]
    	printSlice("c", c) // c len=2 cap=5 [0 0]
    
    	d := c[2:5]
    	printSlice("d", d) // d len=3 cap=3 [0 0 0]
    }
    
    func printSlice(s string, x []int) {
        
    	fmt.Printf("%s len=%d cap=%d %v\n",
    		s, len(x), cap(x), x)
    }

### 切片的切片 ###

切片可包含任何类型，甚至包括其它的切片。

package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
        
    	// 创建一个井字板（经典游戏）
    	board := [][]string{
        
    		[]string{
        "_", "_", "_"},
    		[]string{
        "_", "_", "_"},
    		[]string{
        "_", "_", "_"},
    	}
    
    	// 两个玩家轮流打上 X 和 O
    	board[0][0] = "X"
    	board[2][2] = "O"
    	board[1][2] = "X"
    	board[1][0] = "O"
    	board[0][2] = "X"
    
    	for i := 0; i < len(board); i++ {
        
    		fmt.Printf("%s\n", strings.Join(board[i], " "))
    	}
    	// X _ X
    	// O _ X
    	// _ _ O
    }

### 向切片追加元素 ###

为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数。

func append(s []T, vs ...T) []T

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。

append 的结果是一个包含原切片所有元素加上新添加元素的切片。

当 s 的底层数组太小，不足以容纳所有给定的值时，它就会**分配一个更大的数组**。返回的切片会**指向这个新分配的数组**。

package main
    
    import "fmt"
    
    func main() {
        
    	var s []int
    	printSlice(s) // len=0 cap=0 []
    
    	if s == nil {
        
    		fmt.Println("nil!") // nil
    	}
    	
    	s = append(s, 0) 
    	printSlice(s) // len=1 cap=2 [0]
    
    	// 这个切片会按需增长
    	s = append(s, 1)
    	printSlice(s) // len=2 cap=2 [0 1]
    
    	// 可以一次性添加多个元素
    	s = append(s, 2, 3, 4)
    	printSlice(s) // len=5 cap=8 [0 1 2 3 4]
    }
    
    func printSlice(s []int) {
        
    	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
    }

### Range ###

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为**当前元素的下标**，第二个值为**该下标所对应元素的一份副本**。

package main
    
    import "fmt"
    
    var pow = []int{
        1, 2, 4, 8, 16, 32, 64, 128}
    
    func main() {
        
    	for i, v := range pow {
        
    		fmt.Printf("2**%d = %d\n", i, v)
    	}
    	// 2**0 = 1
    	// 2**1 = 2
    	// 2**2 = 4
    	// 2**3 = 8
    	// 2**4 = 16
    	// 2**5 = 32
    	// 2**6 = 64
    	// 2**7 = 128
    }

可以将**下标或值赋予 \_** 来忽略它。

若你只需要索引，去掉 `, value`的部分即可。

package main
    
    import "fmt"
    
    func main() {
        
    	pow := make([]int, 10)
    	for i := range pow {
        
    		pow[i] = 1 << uint(i) // == 2**i
    	}
    	for _, value := range pow {
        
    		fmt.Printf("%d\n", value)
    	}
    	// 1
    	// 2
    	// 4
    	// 8
    	// 16
    	// 32
    	// 64
    	// 128
    	// 256
    	// 512
    }

### 练习：切片 ###

实现 Pic。它应当返回一个长度为 dy 的切片，其中每个元素是一个长度为 dx，元素类型为 uint8 的切片。当你运行此程序时，它会将每个整数解释为灰度值（好吧，其实是蓝度值）并显示它所对应的图像。

图像的选择由你来定。几个有趣的函数包括 (x+y)/2, x*y, x^y, x*log(y) 和 x%(y+1)。

（提示：需要使用循环来分配 \[\]\[\]uint8 中的每个 \[\]uint8；请使用 uint8(intValue) 在类型之间转换；你可能会用到 math 包中的函数。）

package main
    
    import "golang.org/x/tour/pic"
    
    func Pic(dx, dy int) [][]uint8 {
        
    	a := make([][]uint8, dy) // 外层切片
    	for x := range a{
        
    		b := make([]uint8, dx) // 内层切片
    		for y := range b{
        
    			// 给内层切片里的每一个元素赋值。其中x*y可以替换成别的函数
    			b[y] = uint8(x*y - 1)
    		}
    		a[x] = b   // 给外层切片里的每一个元素赋值
    	}
    	return a	
    }
    
    func main() {
        
    	pic.Show(Pic)
    }

## 映射 ##

映射将键映射到值。

映射的零值为 nil 。nil 映射既没有键，也不能添加键。

make 函数会返回给定类型的映射，并将其初始化备用。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	Lat, Long float64
    }
    
    var m map[string]Vertex
    
    func main() {
        
    	m = make(map[string]Vertex)
    	m["Bell Labs"] = Vertex{
        
    		40.68433, -74.39967,
    	}
    	fmt.Println(m["Bell Labs"]) // {40.68433 -74.39967}
    }

在写上述程序时，用Printf报错，后来发现要用Println，查了一下两者的用法：

Println :可以打印出字符串，和变量  
Printf : 只可以打印出**格式化**的字符串,可以输出字符串类型的变量，不可以输出整形变量和整形

也就是说，当需要格式化输出信息时一般选择 Printf，**其他时候用 Println 就可以了**，比如：

a := 10
    fmt.Println(a)　　//right
    fmt.Println("abc")　　//right
    fmt.Printf("%d",a)　　//right
    fmt.Printf(a)　　//error

### 映射的文法 ###

映射的文法与结构体相似，不过**必须有键名**。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	Lat, Long float64
    }
    
    var m = map[string]Vertex{
        
    	"Bell Labs": Vertex{
        
    		40.68433, -74.39967,
    	},
    	"Google": Vertex{
        
    		37.42202, -122.08408,
    	},
    }
    
    func main() {
        
    	fmt.Println(m) // map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]
    }

若顶级类型只是一个类型名，你可以在文法的元素中省略它。

package main
    
    import "fmt"
    
    type Vertex struct {
        
    	Lat, Long float64
    }
    
    var m = map[string]Vertex{
        
    	"Bell Labs": {
        40.68433, -74.39967},
    	"Google":    {
        37.42202, -122.08408},
    }
    
    func main() {
        
    	fmt.Println(m) // map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]
    }

###  ###

修改映射  
在映射 m 中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

通过双赋值检测某个键是否存在：

elem, ok = m[key]

若 key 在 m 中，ok 为 true ；否则，ok 为 false。

若 key 不在映射中，那么 elem 是该映射元素类型的**零值**。

同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

注 ：若 elem 或 ok 还未声明，你可以使用短变量声明：

elem, ok := m[key]

package main
    
    import "fmt"
    
    func main() {
        
    	m := make(map[string]int)
    
    	m["Answer"] = 42
    	fmt.Println("The value:", m["Answer"]) // The value: 42
    
    	m["Answer"] = 48
    	fmt.Println("The value:", m["Answer"]) // The value: 48
    
    	delete(m, "Answer")
    	fmt.Println("The value:", m["Answer"]) // The value: 0
    
    	v, ok := m["Answer"]
    	fmt.Println("The value:", v, "Present?", ok) // The value: 0 Present? false
    }

### 练习：映射 ###

实现 WordCount。它应当返回一个映射，其中包含字符串 s 中每个“单词”的个数。函数 wc.Test 会对此函数执行一系列测试用例，并输出成功还是失败。

package main
    
    import (
    	"golang.org/x/tour/wc"
    	"strings"
    )
    
    func WordCount(s string) map[string]int {
        
    	splitS :=strings.Fields(s)
    	var m = make(map[string]int)
    	for _, value := range splitS{
        
    		_, ok := m[value]
    		if ok == true{
        
    			m[value] += 1
    		} else{
        
    			m[value] = 1
    		}
    	}
    	return m
    }
    
    func main() {
        
    	wc.Test(WordCount)
    
    	/*输出：
    	PASS
    	 f("I am learning Go!") = 
    	  map[string]int{"learning":1, "Go!":1, "I":1, "am":1}
    	PASS
    	 f("The quick brown fox jumped over the lazy dog.") = 
    	  map[string]int{"jumped":1, "over":1, "dog.":1, "The":1, "brown":1, "fox":1, "the":1, "lazy":1, "quick":1}
    	PASS
    	 f("I ate a donut. Then I ate another donut.") = 
    	  map[string]int{"Then":1, "another":1, "I":2, "ate":2, "a":1, "donut.":2}
    	PASS
    	 f("A man a plan a canal panama.") = 
    	  map[string]int{"A":1, "man":1, "a":2, "plan":1, "canal":1, "panama.":1}
    	*/	
    }

其中 **func Fields(s string) \[\]string** 分割string。

## 函数值 ##

**函数也是值**。它们可以像其它值一样传递。

函数值可以用作**函数的参数**或**返回值**。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    // 函数compute接收函数fn作为参数
    func compute(fn func(float64, float64) float64) float64 {
        
    	return fn(3, 4)
    }
    
    func main() {
        
    	hypot := func(x, y float64) float64 {
        
    		return math.Sqrt(x*x + y*y)
    	}
    	fmt.Println(hypot(5, 12)) // 13
    
    	fmt.Println(compute(hypot)) // 5 // 将函数hypot作为参数传递给compute函数
    	fmt.Println(compute(math.Pow)) // 81 // 将函数math.Pow作为参数传递给compute函数
    }

### 函数的闭包 ###

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被“绑定”在了这些变量上。

例如，函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。

package main
    
    import "fmt"
    
    func adder() func(int) int {
        
    	sum := 0
    	return func(x int) int {
        
    		sum += x
    		return sum
    	}
    }
    
    func main() {
        
    	pos, neg := adder(), adder()
    	for i := 0; i < 10; i++ {
        
    		fmt.Println(
    			pos(i),
    			neg(-2*i),
    		)
    	}
    	/*输出：
    		0 0
    		1 -2
    		3 -6
    		6 -12
    		10 -20
    		15 -30
    		21 -42
    		28 -56
    		36 -72
    		45 -90
    	*/
    }

### 练习：斐波纳契闭包 ###

让我们用函数做些好玩的事情。

实现一个 fibonacci 函数，它返回一个函数（闭包），该闭包返回一个斐波纳契数列 `(0, 1, 1, 2, 3, 5, ...)`。

package main
    
    import "fmt"
    
    // 返回一个“返回int的函数”
    func fibonacci() func() int {
        
    	// 初始值
    	num1, num2 := 0, 1
    	return func() int{
        
    		// 返回值
    		temp := num1
    		// 更新规则
    		num1, num2 = num2, (num1 + num2)
    		return temp
    	}
    }
    
    func main() {
        
    	f := fibonacci()
    	for i := 0; i < 10; i++ {
        
    		fmt.Println(f())
    	}
    }

[https_studygolang.com_articles_2644]: https://studygolang.com/articles/2644