包、变量和函数

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

程序从 main 包开始运行。

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

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

rand 语句开始。

package main
import (
"fmt"
"math/rand"
)
func main(){
fmt.Println("hello,world,rand number is",rand.Intn(10))
}

导入

上述代码中使用了()导入，这是 分组导入 的形式，也可以编写多个导入语句

import "fmt"
import "math"

导出名

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如， Pizza 就是个已导出名，

Pi 也同样，它导出自 math 包。

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

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

函数

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

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

注意类型在变量名 之后。

当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略，见 sub 函数
 package main
import "fmt"
func add(x int, y int) int { // 注意返回类型的位置
return x + y
}
func sub(x, y int) int {
return x - y
}
func main(){
fmt.Println(add(42,13))
fmt.Println(sub(42,13))
}

多值返回

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

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

package main
import "fmt"
func swap(x string, y string) (string, string){
return y,x
}
func main(){
a, b := swap("hello","world")
fmt.Println(a,b)
}

命名返回值

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

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

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

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

package main
import "fmt"
func split(sum int)(x, y int){
x = sum * 4 / 9
y = sum - x
return
}
func main(){
fmt.Println(split(17))
}

变量

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, 2
func main(){
var c, python, java = true, false, "no"
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)
fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
fmt.Printf("Type: %T Value: %v\n", z, z)
}

零值

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

零值是：

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

类型转换

表达式 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 在不同类型的项之间赋值时需要显式转换。

类型推导

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型

由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：
 var i int
j := i // j 也是一个 int

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

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

常量

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

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

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

package main
import "fmt"
const PI = 3.14
func main(){
const World = "世界"
fmt.Println("hello", World)
fmt.Println("happy", PI, "day")
const i = 3
fmt.Println("your age?",i)
const Truth = true
fmt.Println("Go rules?", Truth)
}

数值常量

数值常量是高精度的 值。

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

流程控制语句
for

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

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

初始化语句：在第一次迭代前执行（可省略）
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行（可省略）

初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

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

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号， 大

括号 { } 则是必须的。
 package main
import "fmt"
func main(){
sum1 := 0
for i:=0 ; i < 10 ; i++ {
sum1 += i
}
fmt.Println(sum1)
sum2 := 1
for ; sum2 < 1000 ; {
sum2 += sum2
}
fmt.Println(sum2)
}

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
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),
)
}

if和else

在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。

上面例子中的pow函数可以改成

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
}

switch

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

Go 的 switch 语句类似于 C、C++、Java 中的Go

Go自动提供了在这些语言中每个 case 后面所需的 break 语句
除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的
case 无需为常量，且取值不必为整数。

package main
import (
 "fmt"
"runtime"
)
func main() {
fmt.Print("Go runs on")
switch os := runtime.GOOS; os{
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s.\n", os)
}
}

switch的求值顺序

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

没有条件的switch

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

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

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

defer

defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
defer通常用于简化执行各种清理操作的函数
详见 https://blog.go-zh.org/defer-panic-and-recover

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

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

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

更多类型
指针

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 // p指向i
fmt.Println(*p) // 通过指针读取 i 的值
*p = 21 // 通过指针设置 i 的值
fmt.Println(i) // 查看 i 的值

p = &j // p指向 j
*p = *p / 37 // 通过指针对 j 进行除法运算
fmt.Println(j) // 查看 j 的值
}
结构体

一个结构体（ struct ）就是一组字段（field）。

结构体字段

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

结构体指针

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

如果我们有一个指向结构体的指针 p ，那么可以通过 (*p).X 来访问其字段 X 。

不过这么写太啰嗦了，所以语言也允许我们使用隐式间接引用，直接写 p.X 就可以。

package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main(){file
v := Vertex{1,2}
// 使用.访问结构体字段
v.X = 4
fmt.Println(v)
// 使用结构体指针访问结构体字段
p := &v
p.X = 1e9
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)
}
数组

类型 [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])
fmt.Println(a)

primes := [6] int {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)
}
切片就像数组的引用

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

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

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

package main
import "fmt"

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

切片文法

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

这是一个数组文法：

[3]bool{true, true, false}

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

[]bool{true, true, false}

切片的默认行为

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

切片下界的默认值为 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)
s = s[:2]
fmt.Println(s)
s = s[1:]
fmt.Println(s)
}

切片的长度和容量

切片拥有 长度 和 容量。

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

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

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

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

package main
import "fmt"
func main(){
s := []int {2,3,5,7,11,13}
printSlice(s)
// 截取切片使其长度为 0
s = s[:0]
printSlice(s)
// 拓展其长度
s = s[:4]
printSlice(s)
// 舍弃前两个值
s = s[2:]
printSlice(s)
}
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() {
// 创建一个井字板
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], " "))
}
}
向切片追加元素

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

有详细的介绍。

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

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

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

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

（要了解关于切片的更多内容，请阅读文章 Go 切片：用法和本质。）

package main
import "fmt"
func main(){
var s []int
printSlice(s)
s = append(s, 0)
printSlice(s)
// 这个切片会按需增长
s = append(s, 1)
printSlice(s)
// 可以一次性添加多个元素
s = append(s, 2, 3, 4)
printSlice(s)
}
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)
}
}

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

for i, _ := range pow

for _, value := range pow

若你只需要索引，忽略第二个变量即可。
 for i := range pow

映射

映射将键映射到值。

映射的零值为 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"])
}

映射的文法

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

package main
import "fmt"
type Vertex struct{
Lat, Long float64
}
var m = map[string]Vertex{
"Bell" : Vertex{
40.6833,-948.384
},
"Google" : Vertex{
37.839, -122.348
},
}

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

var m = map[string]Vertex{
"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"
"math"
)
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))
fmt.Println(compute(hypot))
fmt.Println(compute(math.Pow))
}
函数的闭包

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

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

关于闭包的深度理解，可以参考这篇文章 https://zhuanlan.zhihu.com/p/92634505

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))
}
}