本章主要分成三个部分：第一部分包括基本语法和数据结构;第二部分讨论方法和接口;第三部分介绍并发机制。
包、变量和函数
先看一个例子Packages.go：
```golang
package main
import (
"fmt"
"math/rand"
)
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println("My favorite number is", rand.Intn(10))
fmt.Println(add(42, 13))
}
```
包：每个 Go 程序都是由包(package)组成的，程序运行的入口是包 `main`。
导入：这个代码用圆括号组合了导入，这是“打包”导入语句。同样可以编写多个导入语句，例如：
import "fmt"
import "math"
这个程序使用并导入了包 "fmt" 和 `"math/rand"`。包名与导入路径的最后一个目录一致。例如，如果你导入了`"math/rand"`，那么你就可以在程序里面直接写rand.Intn(10),但如果你导入的是`"math"`，那么你就得写math.rand.Intn(10)。
函数：函数可以没有参数或接受多个参数。在这个例子中，`add` 接受两个 int 类型的参数，注意类型在变量名之后。有没有觉得很奇怪呢，下面就详细解释一下go这样做的原因。
看一个c的例子：
int (*fp)(int (*ff)(int x, int y), int b)
我相信学过c的同学为了看懂这个都下了不少功夫吧，有没有感觉到痛苦或者说痛苦之后的那一点点优越感。
什么？你还能看懂？那么再来一个：
int (*(*fp)(int (*)(int, int), int))(int, int);// 10s内看懂的同学给我回复下这个定义是啥，我请你吃饭。
用go语言的话这两个例子的定义如下：
f func(func(int,int) int, int) int
f func(func(int,int) int, int) func(int, int) int
是不是清晰多了，原来f返回的是一个函数啊。。。
函数参数：
当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略，比如func add(x int, y int) int可以写为func add(x, y int) int
函数返回值：
函数可以返回任意数量的返回值，比如func swap(x, y string) (string, string)。
并且，函数的返回值还可以被命名，并且像变量那样使用，比如
```golang
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
```
没有参数的 return 语句返回结果的当前值。
变量：
var 语句定义了一个变量的列表；跟函数的参数列表一样，类型在后面，可以定义在包或函数级别。比如：
```golang
package main
import "fmt"
var c, python, java bool
func main() {
var i int
fmt.Println(i, c, python, java)
}
```
变量的初始化: 变量定义可以包含初始值，每个变量对应一个。如果初始化是使用表达式，则可以省略类型；变量从初始值中获得类型。比如：var i, j int = 1, 2或者var c, python, java = true, false, "no!"
短声明变量：在函数中，`:=` 简洁赋值语句在明确类型的地方，可以用于替代 var 定义。
函数外的每个语句都必须以关键字开始（`var`、`func`、等等），`:=` 结构不能使用在函数外。比如：
```golang
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
零值：变量在定义时没有明确的初始化时会赋值为零值。数值类型为 `0`,布尔类型为 `false`,字符串为 `""`。
类型转换：Go 的在不同类型之间的项目赋值时需要显式转换。表达式 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)
类型推导：在定义一个变量但不指定其类型时（使用没有类型的 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 关键字，常量可以是字符、字符串、布尔或数字类型的值，常量不能使用 := 语法定义。
流程控制语句
for循环：Go 只有一种循环结构for循环。基本的 for 循环除了没有了 `( )` 之外（，看起来跟 C 或者 Java 中做的一样，而 `{ }` 是必须的。比如：
```golang
package main
import "fmt"
func main() {
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
fmt.Println(sum)
}
```
死循环：如果省略了循环条件，循环就不会结束，因此可以用更简洁地形式表达死循环。
```golang
package main
func main() {
for {
}
}
```
If语句：if 语句除了没有了 `( )` 之外，看起来跟 C 或者 Java 中的一样，而 `{ }` 是必须的。
```golang
func sqrt(x float64) string {
if x < 0 {
return sqrt(-x) + "i"
}
return fmt.Sprint(math.Sqrt(x))
}
```
可以在if条件之前执行一个简单的语句，由这个语句定义的变量的作用域仅在 if 范围之内,比如：
```golang
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
}
return lim
}
```
在 if 的便捷语句定义的变量同样可以在任何对应的 else 块中使用，比如：
```golang
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 的条件从上到下的执行，当匹配成功的时候停止，除非以 fallthrough 语句结束，否则分支会自动终止。比如：
switch i {
case 0:
case f():
}
当 i==0 时不会调用 `f`。没有条件的 switch 同 `switch true` 一样，这一构造使得可以用更清晰的形式来编写长的 if-then-else 链。
```golang
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 语句会延迟函数的执行直到上层函数返回，延迟调用的参数会立刻生成，但是在上层函数返回前函数都不会被调用。比如打印hello world：
```golang
func main() {
defer fmt.Println("world")
fmt.Println("hello")
}
```
延迟的函数调用被压入一个栈中。当函数返回时， 会按照后进先出的顺序调用被延迟的函数调用。
```golang
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
这个功能用来做清理工作非常清晰且强大，可以用结构化编程的思路处理面向对象编程中类似析构函数的功能。举一个实际点的例子：
```golang
func CopyFile(dstName, srcName string) (written int64, err error) {
src, err := os.Open(srcName)
if err != nil {
return
}
defer src.Close()
dst, err := os.Create(dstName)
if err != nil {
return
}
defer dst.Close()
return io.Copy(dst, src)
}
```
复杂类型
指针：Go 具有指针。 指针保存了变量的内存地址，类型 *T 是指向类型 T 的值的指针。其零值是 `nil`，& 符号会生成一个指向其作用对象的指针，* 符号表示指针指向的底层的值。
var p *int
i := 42
p = &i
fmt.Println(*p) // 通过指针 p 读取 i
*p = 21 // 通过指针 p 设置 i
与 C 不同，Go 没有指针运算。
结构体：一个结构体（`struct`）就是一个字段的集合，跟C类似，结构体字段使用点号来访问，结构体字段可以通过结构体指针来访问。
```golang
type Vertex struct {
X int
Y int
}
func main() {
fmt.Println(Vertex{1, 2})
v.X = 4
fmt.Println(v.X)
p := &v
p.X = 1e9
}
```
结构体文法：结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）特殊的前缀 & 返回一个指向结构体的指针。
```golang
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
)
```
数组：类型 [n]T 是一个有 n 个类型为 T 的值的数组，数组的长度是其类型的一部分，因此数组不能改变大小。
Slice：一个 slice 会指向一个序列的值，并且包含了长度信息，[]T 是一个元素类型为 T 的 slice。slice 可以重新切片，创建一个新的 slice 值指向相同的数组。s[lo:hi] 表示从 lo 到 hi-1 的 slice 元素，含两端，因此s[lo:lo] 是空的。下标从0开始。
```golang
package main
import "fmt"
func main() {
p := []int{2, 3, 5, 7, 11, 13}
fmt.Println("p ==", p)
fmt.Println("p[1:4] ==", p[1:4])
// 省略下标代表从 0 开始
fmt.Println("p[:3] ==", p[:3])
// 省略上标代表到 len(s) 结束
fmt.Println("p[4:] ==", p[4:])
}
```
构造slice：slice 由函数 make 创建。这会分配一个零长度的数组并且返回一个 slice 指向这个数组，比如：
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
slice 的零值是 `nil`，一个 nil 的 slice 的长度和容量是 0。
向slice添加元素：
func append(s []T, vs ...T) []T
append 的第一个参数 s 是一个类型为 T 的数组，append 的结果是一个包含原 slice 所有元素加上新添加的元素的 slice，如果 s 的底层数组太小，而不能容纳所有值时，会分配一个更大的数组，返回的 slice 会指向这个新分配的数组。
range：
for 循环的 range 格式可以对 slice 或者 map 进行迭代循环。
```golang
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)
}
}
```
可以通过赋值给 _ 来忽略序号和值,如果只需要索引值，去掉“, value”的部分即可。
```golang
func main() {
pow := make([]int, 10)
for i := range pow {
pow[i] = 1 << uint(i)
}
for _, value := range pow {
fmt.Printf("%d\n", value)
}
}
```
map：map 在使用之前必须用 make 而不是 new 来创建；值为 nil 的 map 是空的，并且不能赋值。
```golang
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"])
}
```
map 的文法跟结构体文法相似，不过必须有键名。
```golang
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
```
如果顶级的类型只有类型名的话，可以在文法的元素中省略键名。
var m = map[string]Vertex{
"Bell Labs": {40.68433, -74.39967},
"Google": {37.42202, -122.08408},
}
修改 map：
在 map m 中插入或修改一个元素：m[key] = elem
获得元素：elem = m[key]
删除元素：delete(m, key)
通过双赋值检测某个键存在：elem, ok = m[key]
如果 key 在 m 中，`ok` 为 true 。否则， ok 为 `false`，并且 elem 是 map 的元素类型的零值，同样的，当从 map 中读取某个不存在的键时，结果是 map 的元素类型的零值。
函数值：函数也是值。
```golang
package main
import (
"fmt"
"math"
)
func main() {
hypot := func(x, y float64) float64 {
return math.Sqrt(x*x + y*y)
}
fmt.Println(hypot(3, 4))
}
```
函数的闭包：这个意思简单点就是以函数作为返回值。
Go 函数可以是闭包的。闭包是一个函数值，它来自函数体的外部的变量引用。 函数可以对这个引用值进行访问和赋值；换句话说这个函数被“绑定”在这个变量上。
```golang
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),
)
}
}
```
有疑问加站长微信联系（非本文作者）
