命名
标识符
Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的：heapSort和Heapsort是两个不同的名字。
所有你自己写的代码，定义的变量，函数等必须遵守标识符的原则。
有很少的一些go语言的关键字你不能当做变量的名字
以下这些，初次接触，不要被吓到，不要可以去记住，可以大概浏览一下，有个印象，后面我会一个一个讲到。
Go语言中类似if和switch的关键字有25个；关键字不能用于自定义名字，只能在特定语法结构中使用。
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
此外，还有大约30多个预定义的名字，比如int和true等，主要对应内建的常量、类型和函数。
内建常量: true false iota nil
内建类型: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
内建函数: make len cap new append copy close delete
complex real imag
panic recover
作用域
如果一个名字是在函数内部定义，那么它就只在函数内部有效。如果是在函数外部定义，那么将在当前包的所有文件中都可以访问。
公开与私有
这点go语言比较有自己的个性。名字的开头字母的大小写决定了名字在包外的可见性。如果一个变量或函数名字是大写字母开头的，那么它将是导出的，也就是说可以被外部的包访问，例如fmt包的Printf函数就是导出的，可以在fmt包外部访问。包本身的名字一般总是用小写字母。
名字的长度没有逻辑限制，但是Go语言的风格是尽量使用短小的名字，对于局部变量尤其是这样；你会经常看到i之类的短名字，而不是冗长的theLoopIndex命名。通常来说，如果一个名字的作用域比较大，生命周期也比较长，那么用长的名字将会更有意义。
在习惯上，Go语言程序员推荐使用 驼峰式 命名，当名字由几个单词组成时优先使用大小写分隔，而不是优先用下划线分隔。因此，在标准库有QuoteRuneToASCII和parseRequestLine这样的函数命名，但是一般不会用quote_rune_to_ASCII和parse_request_line这样的python风格或js风格的命名。
声明
通常可以声明包，声明变量，声明常量，声明函数，声明类型等等。让我们逐个了解一下。下面展示了一个基本的使用的代码例子。
代码位于 lesson_1/main.go
package main
import "fmt"
const version = "0.0.1"
var name = "唐国强"
func main() {
fmt.Println("当前程序版本是:" + version)
fmt.Println("我是演员：" + name)
name = "诸葛亮"
fmt.Println("我在扮演:" + name)
}
声明包
这里第一行package main 是声明包名称。go语言一个文件夹算作一个包，一个文件夹下面所有的go文件声明的package必须是一样的。
其次main包是特殊的包，只能存在于一个文件当中。main包的main函数是特殊的函数，是程序执行的入口。
声明完package之后其他的地方就可以引用了。就像这里import "fmt"就是引用的标准库里的fmt包。然后调用了fmt包里面的公有方法Println.
声明常量，变量
我们还声明了一个常量version，它是不可变的。声明了一个变量name，它的值在函数里面发生了改变。
这里面version和name都是小写，像这样的声明方式，在其他包里面是无法引用到的。
声明函数
一个函数的声明由一个函数名字、参数列表（由函数的调用者提供参数变量的具体值）、一个可选的返回值列表和包含函数定义的函数体组成。如果函数没有返回值，那么返回值列表是省略的。执行函数从函数的第一个语句开始，依次顺序执行直到遇到return返回语句，如果没有返回语句则是执行到函数末尾，然后返回到函数调用者。
我们把程序稍微改一下，让她使用函数。cosplay是函数的名字，name string是参数列表，返回值没有，大括号里面就是函数体。
而getCosplaySaying 获取扮演的话，里面添加了返回值也是字符串类型。main函数里面调用函数之后使用fmt.Println进行打印返回的字符串。这里fmt.Sprintf跟fmt.Printf异曲同工，加了S表示返回的是字符串，不加S表示打印到标准输出。
package main
import "fmt"
const version = "0.0.1"
var name = "唐国强"
func main() {
fmt.Println("当前程序版本是:" + version)
fmt.Println("我是演员：" + name)
name = "诸葛亮"
cosplay(name)
name = "雍正"
cosplay(name)
name = "朱元璋"
fmt.Println(getCosplaySaying(name))
name = "毛泽东"
fmt.Println(getCosplaySaying(name))
}
func cosplay(name string) {
fmt.Println("我在扮演：" + name)
}
func getCosplaySaying(name string) string {
return fmt.Sprintf("我在扮演：%s", name)
}
程序输出如下：
变量
变量的声明语法是
var 变量名字 类型 = 表达式
其中“类型”或“= 表达式”两个部分可以省略其中的一个。如果省略的是类型信息，那么将根据初始化表达式来推导变量的类型信息。如果初始化表达式被省略，那么将用零值初始化该变量。 数值类型变量对应的零值是0，布尔类型变量对应的零值是false，字符串类型对应的零值是空字符串（这里需要额外注意一下，跟其他语言不太一样，字符串的零值是”“而不是nil），接口或引用类型（包括slice、指针、map、chan和函数）变量对应的零值是nil。数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值。
零值初始化机制可以确保每个声明的变量总是有一个良好定义的值，因此在Go语言中不存在未初始化的变量。这个特性可以简化很多代码，而且可以在没有增加额外工作的前提下确保边界条件下的合理行为。例如：
var s string
fmt.Println(s) // ""
这段代码将打印一个空字符串，而不是导致错误或产生不可预知的行为。Go语言程序员应该让一些聚合类型的零值也具有意义，这样可以保证不管任何类型的变量总是有一个合理有效的零值状态。
也可以在一个声明语句中同时声明一组变量，或用一组初始化表达式声明并初始化一组变量。如果省略每个变量的类型，将可以声明多个类型不同的变量（类型由初始化表达式推导）：
var i, j, k int // int, int, int
var b, f, s = true, 2.3, "four" // bool, float64, string
初始化表达式可以是字面量或任意的表达式。在包级别声明的变量会在main入口函数执行前完成初始化（§2.6.2），局部变量将在声明语句被执行到的时候完成初始化。
一组变量也可以通过调用一个函数，由函数返回的多个返回值初始化：
var f, err = os.Open(name) // os.Open returns a file and an error
在函数内部，有一种称为简短变量声明语句的形式可用于声明和初始化局部变量。它以“名字 := 表达式”形式声明变量，变量的类型根据表达式来自动推导
因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。var形式的声明语句往往是用于需要显式指定变量类型的地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。
i := 100 // an int
var boiling float64 = 100 // a float64
var names []string
var err error
var p Point
和var形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：
i, j := 0, 1
这样的语法设计导致了，go语言可以像python一样可以很方便的交换变量
i, j = j, i // 交换 i 和 j 的值
和普通var形式的变量声明语句一样，简短变量声明语句也可以用函数的返回值来声明和初始化变量，像下面的os.Open函数调用将返回两个值：
f, err := os.Open(name)
if err != nil {
return err
}
// ...use f...
f.Close()
这里有一个比较微妙的地方：简短变量声明左边的变量可能并不是全部都是刚刚声明的。如果有一些已经在相同的词法域声明过了，那么简短变量声明语句对这些已经声明过的变量就只有赋值行为了。
在下面的代码中，第一个语句声明了in和err两个变量。在第二个语句只声明了out一个变量，然后对已经声明的err进行了赋值操作。
in, err := os.Open(infile)
// ...
out, err := os.Create(outfile)
简短变量声明语句中必须至少要声明一个新的变量，下面的代码将不能编译通过：
f, err := os.Open(infile)
// ...
f, err := os.Create(outfile) // compile error: no new variables
解决的方法是第二个简短变量声明语句改用普通的多重赋值语句。
这种设计其实主要是为了解决err重复使用的问题，提供的语法糖。
指针
一个指针的值是另一个变量的地址。一个指针对应变量在内存中的存储位置。并不是每一个值都会有一个内存地址，但是对于每一个变量必然有对应的内存地址。通过指针，我们可以直接读或更新对应变量的值，而不需要知道该变量的名字（如果变量有名字的话）。
如果用“var x int”声明语句声明一个x变量，那么&x表达式（取x变量的内存地址）将产生一个指向该整数变量的指针，指针对应的数据类型是*int，指针被称之为“指向int类型的指针”。如果指针名字为p，那么可以说“p指针指向变量x”，或者说“p指针保存了x变量的内存地址”。同时*p表达式对应p指针指向的变量的值。一般*p表达式读取指针指向的变量的值，这里为int类型的值，同时因为*p对应一个变量，所以该表达式也可以出现在赋值语句的左边，表示更新指针所指向的变量的值。
x := 1
p := &x // p类型是*int，也就是int变量的指针，指向了x变量
fmt.Println(*p) // "1" 这里*p表示取p指针指向的变量的值
*p = 2 // 相当于 x = 2
fmt.Println(x) // "2"
对于聚合类型每个成员——比如结构体（后面会讲到）的每个字段、或者是数组的每个元素——也都是对应一个变量，因此可以被取地址。
变量有时候被称为可寻址的值。即使变量由表达式临时生成，那么表达式也必须能接受&取地址操作。于此对应常量是不可寻址的值，因为常量不能修改，取地址没有意义，go就规定常量不能寻址了，也就不能进行&取指针。
任何类型的指针的零值都是nil。如果p指向某个有效变量，那么p != nil测试为真。指针之间也是可以进行相等测试的，只有当它们指向同一个变量或全部是nil时才相等。
var x, y int
fmt.Println(&x == &x, &x == &y, &x == nil) // "true false false"
在Go语言中，返回函数中局部变量的地址也是安全的。例如下面的代码，调用f函数时创建局部变量v，在局部变量地址被返回之后依然有效，因为指针p依然引用这个变量。
var p = f()
func f() *int {
v := 1
return &v
}
每次调用f函数都将返回不同的结果：
fmt.Println(f() == f()) // "false"
因为指针包含了一个变量的地址，因此如果将指针作为参数调用函数，那将可以在函数中通过该指针来更新变量的值。
我想要在函数里面改变传入的变量，但是传入的变量不是引用类型的，而是基本类型的，如int。这种情况我们可以通过传入指针来改变.举例如下
package main
import "fmt"
func main() {
var i int
incr(&i)
incr(&i)
fmt.Println(i)
}
func incr(p *int) {
*p++
}
由于incr函数被调用两次，每次函数里面都通过指针改变了指针变量p所引用的值，也就是i，所以最好会输出2.
举个使用指针的例子。我们go有一个编写命令行程序的时候用作命令行参数解析的库叫做flag，是标准库里面包含的不需要额外安装。
package main
import (
"flag"
"fmt"
"strings"
)
func main() {
sep := flag.String("s", " ", "分隔符")
n := flag.Bool("n", false, "是否结尾换行")
flag.Parse()
pathList := flag.Args()
fmt.Print(strings.Join(pathList, *sep))
if *n {
fmt.Println()
}
}
输出如下：
代码见上面。我们定义了两个变量sep和n，他们都是指针类型，sep是字符串指针，n是bool类型的指针。flag.Parse会让flag库解析用户传递的参数。要注意使用flag定义的变量之前一定要指向flag.Parse()，否则这些变量都是未被解析赋值的，如果是字符串，则是”“,如果是boo类型，则永远是false，Parse函数把-s的值传递给sep变量，把-n的值传递给n变量。我们使用*sep取字符串的值，使用*n取布尔值。strings.Join是字符串拼接函数。因为pathList变量是字符串切片，取的是命令函参数非-x这种的所有字符串。使用*sep的值做一个拼接。我们这个程序可以用于windows和linux路径拼接。
new函数
另一个创建变量的方法是调用内建的new函数。表达式new(T)将创建一个T类型的匿名变量，初始化为T类型的零值，然后返回变量地址，返回的指针类型为*T。
p := new(int) // p, *int 类型, 指向匿名的 int 变量
fmt.Println(*p) // "0"
*p = 2 // 设置 int 匿名变量的值为 2
fmt.Println(*p) // "2"
用new创建变量和普通变量声明语句方式创建变量没有什么区别，除了不需要声明一个临时变量的名字外，我们还可以在表达式中使用new(T)。换言之，new函数类似是一种语法糖，而不是一个新的基础概念。
下面的两个newInt函数有着相同的行为：
func newInt() *int {
return new(int)
}
func newInt() *int {
var dummy int
return &dummy
}
每次调用new函数都是返回一个新的变量的地址，因此下面两个地址是不同的：
p := new(int)
q := new(int)
fmt.Println(p == q) // "false"
当然也可能有特殊情况：如果两个类型都是空的，也就是说类型的大小是0，例如struct{}和[0]int，有可能有相同的地址（依赖具体的语言实现）（译注：请谨慎使用大小为0的类型，因为如果类型的大小为0的话，可能导致Go语言的自动垃圾回收器有不同的行为，具体请查看runtime.SetFinalizer函数相关文档）。
new函数使用通常相对比较少，因为对于结构体来说，直接用字面量语法创建新变量的方法会更灵活。
由于new只是一个预定义的函数，它并不是一个关键字，因此我们可以将new名字重新定义为别的类型。例如下面的例子：
func delta(old, new int) int { return new - old }
由于new被定义为int类型的变量名，因此在delta函数内部是无法使用内置的new函数的。
作用域
通常情况下，函数内部定义的变量，只在函数体内部有用。但是如果定义了指针变量，返回指针的引用这种。用go的术语来说是变量逃逸了。用通常术语来说函数内部定义的变量不再在栈上进行分配了，而是在堆上进行分配。
var global *int
func f() {
var x int
x = 1
global = &x
}
func g() {
y := new(int)
*y = 1
}
在上面的例子中，f函数里的x变量必须在堆上分配，因为它在函数退出后依然可以通过包一级的global变量找到，虽然它是在函数内部定义的；用Go语言的术语说，这个x局部变量从函数f中逃逸了。相反，当g函数返回时，变量*y将是不可达的，也就是说可以马上被回收的。因此，*y并没有从函数g中逃逸，编译器可以选择在栈上分配*y的存储空间（译注：也可以选择在堆上分配，然后由Go语言的GC回收这个变量的内存空间），虽然这里用的是new方式。其实在任何时候，你并不需为了编写正确的代码而要考虑变量的逃逸行为，要记住的是，逃逸的变量需要额外分配内存，同时对性能的优化可能会产生细微的影响。
赋值
使用赋值语句可以更新一个变量的值，最简单的赋值语句是将要被赋值的变量放在=的左边，新值的表达式放在=的右边。
x = 1 // 命名变量的赋值
*p = true // 通过指针间接赋值
person.name = "bob" // 结构体字段赋值
count[x] = count[x] * scale // 数组、slice或map的元素赋值
特定的二元算术运算符和赋值语句的复合操作有一个简洁形式，例如上面最后的语句可以重写为：
count[x] *= scale
这样可以省去对变量表达式的重复计算。
数值变量也可以支持++递增和--递减语句（译注：自增和自减是语句，而不是表达式，因此x = i++之类的表达式是错误的）：
v := 1
v++ // 等价方式 v = v + 1；v 变成 2
v-- // 等价方式 v = v - 1；v 变成 1
元祖赋值
元组赋值是另一种形式的赋值语句，它允许同时更新多个变量的值。在赋值之前，赋值语句右边的所有表达式将会先进行求值，然后再统一更新左边对应变量的值。这对于处理有些同时出现在元组赋值语句左右两边的变量很有帮助，例如我们可以这样交换两个变量的值：
x, y = y, x
a[i], a[j] = a[j], a[i]
计算斐波纳契数列（Fibonacci）的第N个数：
func fib(n int) int {
x, y := 0, 1
for i := 0; i < n; i++ {
x, y = y, x+y
}
return x
}
元组赋值也可以使一系列琐碎赋值更加紧凑（译注: 特别是在for循环的初始化部分），
i, j, k = 2, 3, 5
但如果表达式太复杂的话，应该尽量避免过度使用元组赋值；因为每个变量单独赋值语句的写法可读性会更好。
有些表达式会产生多个值，比如调用一个有多个返回值的函数。当这样一个函数调用出现在元组赋值右边的表达式中时（译注：右边不能再有其它表达式），左边变量的数目必须和右边一致。
f, err = os.Open("foo.txt") // function call returns two values
通常，这类函数会用额外的返回值来表达某种错误类型，例如os.Open是用额外的返回值返回一个error类型的错误，还有一些是用来返回布尔值，通常被称为ok。在稍后我们将看到的三个操作都是类似的用法。如果map查找、类型断言 或 通道接收 出现在赋值语句的右边，它们都可能会产生两个结果，有一个额外的布尔结果表示操作是否成功：
v, ok = m[key] // map lookup
v, ok = x.(T) // type assertion
v, ok = <-ch // channel receive
译注：map查找、类型断言 或通道接收 出现在赋值语句的右边时，并不一定是产生两个结果，也可能只产生一个结果。对于只产生一个结果的情形，map查找失败时会返回零值，类型断言失败时会发生运行时panic异常，通道接收失败时会返回零值（阻塞不算是失败）。例如下面的例子：
v = m[key] // map查找，失败时返回零值
v = x.(T) // type断言，失败时panic异常
v = <-ch // 管道接收，失败时返回零值（阻塞不算是失败）
_, ok = m[key] // map返回2个值
_, ok = mm[""], false // map返回1个值
_ = mm[""] // map返回1个值
和变量声明一样，我们可以用下划线空白标识符_来丢弃不需要的值。
_, err = io.Copy(dst, src) // 丢弃字节数
_, ok = x.(T) // 只检测类型，忽略具体值
可赋值性
赋值语句是显式的赋值形式，但是程序中还有很多地方会发生隐式的赋值行为：函数调用会隐式地将调用参数的值赋值给函数的参数变量，一个返回语句会隐式地将返回操作的值赋值给结果变量，一个复合类型的字面量也会产生赋值行为。例如下面的语句：
medals := []string{"gold", "silver", "bronze"}
隐式地对slice的每个元素进行赋值操作，类似这样写的行为：
medals[0] = "gold"
medals[1] = "silver"
medals[2] = "bronze"
map和chan的元素，虽然不是普通的变量，但是也有类似的隐式赋值行为。
不管是隐式还是显式地赋值，在赋值语句左边的变量和右边最终的求到的值必须有相同的数据类型。更直白地说，只有右边的值对于左边的变量是可赋值的，赋值语句才是允许的。