@@ -19,6 +19,13 @@ var variableName type = value
 */
 var vname1, vname2, vname3 type= v1, v2, v3
 
+// 定义多个变量
+var (
+	home   = os.Getenv("HOME")
+	user   = os.Getenv("USER")
+	gopath = os.Getenv("GOPATH")
+)
+
 /*
  定义三个变量，它们分别初始化为相应的值 vname1 为 v1，vname2 为 v2，vname3 为 v3 编译器会根据初始化的值自动推导出相应的类型
 */
@@ -43,7 +50,9 @@ func main() {
 
 # 常量
 
-所谓常量，也就是在程序编译阶段就确定下来的值，而程序在运行时无法改变该值。在 Go 程序中，常量可定义为数值、布尔值或字符串等类型。它的语法如下：
+所谓常量，也就是在程序编译阶段就确定下来的值，而程序在运行时无法改变该值，Go 中的常量就是不变量。它们在编译时创建，即便它们可能是函数中定义的局部变量。常量只能是数字、字符（符文）、字符串或布尔值。由于编译时的限制， 定义它们的表达式必须也是可被编译器求值的常量表达式。例如 `1<<3` 就是一个常量表达式，而 `math.Sin(math.Pi/4)` 则不是，因为对 `math.Sin` 的函数调用在运行时才会发生。
+
+它的语法如下：
 
 ```go
 const constantName = value
@@ -61,3 +70,45 @@ const prefix = "astaxie_"
 ```
 
 Go 常量和一般程序语言不同的是，可以指定相当多的小数位数(例如 200 位)，若指定給 float32 自动缩短为 32bit，指定给 float64 自动缩短为 64bit，详情参考[链接](http://golang.org/ref/spec#Constants)
+
+## iota
+
+在 Go 中，枚举常量使用枚举器 iota 创建。由于 iota 可为表达式的一部分，而表达式可以被隐式地重复，这样也就更容易构建复杂的值的集合了。每次 const 出现时，都会让 iota 初始化为 0。
+
+```go
+const a = iota // a=0
+const (
+  b = iota     //b=0
+  c            //c=1
+)
+```
+
+自增长常量经常包含一个自定义枚举类型，允许你依靠编译器完成自增设置。
+
+```go
+type Stereotype int
+
+const (
+    TypicalNoob Stereotype = iota // 0
+    TypicalHipster                // 1
+    TypicalUnixWizard             // 2
+    TypicalStartupFounder         // 3
+)
+```
+
+```go
+type ByteSize float64
+
+const (
+    // 通过赋予空白标识符来忽略第一个值
+    _           = iota // ignore first value by assigning to blank identifier
+    KB ByteSize = 1 << (10 * iota)
+    MB
+    GB
+    TB
+    PB
+    EB
+    ZB
+    YB
+)
+```
@@ -1,3 +1,3 @@
 # 并发编程
 
-关于并发编程的通用基础内容，参阅
+关于并发编程的通用基础内容，参阅[并发编程导论 https://url.wx-coder.cn/Yagu8 ](https://url.wx-coder.cn/Yagu8)。
@@ -1,22 +1,18 @@
 # 基本类型
 
-## 数值类型
+# 数值类型
 
 整数类型有无符号和带符号两种。Go 同时支持`int`和`uint`，这两种类型的长度相同，但具体长度取决于不同编译器的实现。Go 里面也有直接定义好位数的类型：`rune`, `int8`, `int16`, `int32`, `int64`和`byte`, `uint8`, `uint16`, `uint32`, `uint64`。其中`rune`是`int32`的别称，`byte`是`uint8`的别称。
 
-> 需要注意的一点是，这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错。
->
-> 如下的代码会产生错误：invalid operation: a + b (mismatched types int8 and int32)
->
-> > var a int8
-> >
-> > var b int32
-> >
-> > c:=a + b
->
-> 另外，尽管 int 的长度是 32 bit, 但 int 与 int32 并不可以互用。
+需要注意的一点是，这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错。如下的代码会产生错误：`invalid operation: a + b (mismatched types int8 and int32)`
 
-浮点数的类型有`float32`和`float64`两种(没有`float`类型)，默认是`float64`。
+```go
+var a int8
+var b int32
+c:=a + b
+```
+
+另外，尽管 int 的长度是 32 bit, 但 int 与 int32 并不可以互用。浮点数的类型有`float32`和`float64`两种(没有`float`类型)，默认是`float64`。
 
 这就是全部吗？No！Go 还支持复数。它的默认类型是`complex128`(64 位实数+64 位虚数)。如果需要小一些的，也有`complex64`(32 位实数+32 位虚数)。复数的形式为`RE + IMi`，其中`RE`是实数部分，`IM`是虚数部分，而最后的`i`是虚数单位。下面是一个使用复数的例子：
 
@@ -26,7 +22,7 @@ var c complex64 = 5+5i
 fmt.Printf("Value is: %v", c)
 ```
 
-## 布尔类型
+# 布尔类型
 
 在 Go 中，布尔值的类型为`bool`，值是`true`或`false`，默认为`false`。
 
@@ -40,66 +36,3 @@ func test() {
     available = true    // 赋值操作
 }
 ```
-
-# String
-
-我们在上一节中讲过，Go 中的字符串都是采用`UTF-8`字符集编码。字符串是用一对双引号(`""`)或反引号(`` ` `` `)括起来定义，它的类型是`string`。
-
-```
-//示例代码
-var frenchHello string  // 声明变量为字符串的一般方法
-var emptyString string = ""  // 声明了一个字符串变量，初始化为空字符串
-func test() {
-    no, yes, maybe := "no", "yes", "maybe"  // 简短声明，同时声明多个变量
-    japaneseHello := "Konichiwa"  // 同上
-    frenchHello = "Bonjour"  // 常规赋值
-}
-```
-
-在 Go 中字符串是不可变的，例如下面的代码编译时会报错：cannot assign to s[0]
-
-```
-var s string = "hello"
-s[0] = 'c'
-```
-
-但如果真的想要修改怎么办呢？下面的代码可以实现：
-
-```
-s := "hello"
-c := []byte(s)  // 将字符串 s 转换为 []byte 类型
-c[0] = 'c'
-s2 := string(c)  // 再转换回 string 类型
-fmt.Printf("%s\n", s2)
-```
-
-Go 中可以使用`+`操作符来连接两个字符串：
-
-```
-s := "hello,"
-m := " world"
-a := s + m
-fmt.Printf("%s\n", a)
-```
-
-修改字符串也可写为：
-
-```go
-s := "hello"
-s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
-fmt.Printf("%s\n", s)
-```
-
-如果要声明一个多行的字符串怎么办？可以通过`` `来声明：
-
-```
-m := `hello
-    world`
-```
-
-`` ` 括起的字符串为 Raw 字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。例如本例中会输出：
-
-```
-hello
-    world
-```
@@ -0,0 +1,62 @@
+# 字符串
+
+我们在上一节中讲过，Go 中的字符串都是采用`UTF-8`字符集编码。字符串是用一对双引号(`""`)或反引号(`` ` `` `)括起来定义，它的类型是`string`。
+
+```go
+//示例代码
+var frenchHello string  // 声明变量为字符串的一般方法
+var emptyString string = ""  // 声明了一个字符串变量，初始化为空字符串
+func test() {
+    no, yes, maybe := "no", "yes", "maybe"  // 简短声明，同时声明多个变量
+    japaneseHello := "Konichiwa"  // 同上
+    frenchHello = "Bonjour"  // 常规赋值
+}
+```
+
+在 Go 中字符串是不可变的，例如下面的代码编译时会报错：cannot assign to s[0]
+
+```
+var s string = "hello"
+s[0] = 'c'
+```
+
+但如果真的想要修改怎么办呢？下面的代码可以实现：
+
+```
+s := "hello"
+c := []byte(s)  // 将字符串 s 转换为 []byte 类型
+c[0] = 'c'
+s2 := string(c)  // 再转换回 string 类型
+fmt.Printf("%s\n", s2)
+```
+
+Go 中可以使用`+`操作符来连接两个字符串：
+
+```go
+s := "hello,"
+m := " world"
+a := s + m
+fmt.Printf("%s\n", a)
+```
+
+修改字符串也可写为：
+
+```go
+s := "hello"
+s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
+fmt.Printf("%s\n", s)
+```
+
+如果要声明一个多行的字符串怎么办？可以通过`` `来声明：
+
+```go
+m := `hello
+    world`
+```
+
+`` ` 括起的字符串为 Raw 字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。例如本例中会输出：
+
+```
+hello
+    world
+```
@@ -0,0 +1,33 @@
+# 映射
+
+映射是方便而强大的内建数据结构，它可以关联不同类型的值。其键可以是任何相等性操作符支持的类型，如整数、浮点数、复数、字符串、指针、接口（只要其动态类型支持相等性判断）、结构以及数组。
+
+切片不能用作映射键，因为它们的相等性还未定义。与切片一样，映射也是引用类型。若将映射传入函数中，并更改了该映射的内容，则此修改对调用者同样可见。
+
+map 的零值为 nil。对于 map 的零值得读取，不会出错，但是写入则会引发 panic，例如：
+
+```go
+func main() {
+	var m map[string]string
+	fmt.Println(m["hello"])
+	m["hello"] = "world"
+}
+
+// error
+panic: assignment to entry in nil map
+
+goroutine 1 [running]:
+main.main()
+	/tmp/main.go:10 +0xee
+exit status 2
+```
+
+# 取值与遍历
+
+对 map 取值，返回两个参数，第二个参数为 bool 值，标志 key 是否存在于 map 中：
+
+```go
+s := m["hello"] // 如果key不存在，s为对应类型的零值
+s, ok := m["hello"] // 如果key不存在, ok为false，反之为true
+_, exists := m["hello"] // 用来确定key是否存在
+```
@@ -1 +1,49 @@
 # Package | 包
+
+# init 函数
+
+每个源文件都可以通过定义自己的无参数 init 函数来设置一些必要的状态；每个文件都可以拥有多个 init 函数。只有该包中的所有变量声明都通过它们的初始化器求值后 init 才会被调用， 而那些 init 只有在所有已导入的包都被初始化后才会被求值。除了那些不能被表示成声明的初始化外，init 函数还常被用在程序真正开始执行前，检验或校正程序的状态。
+
+尽管 init 方法能够在同一个源文件中多次定义，并且顺序执行，应该尽量避免。同一个包下的多个源文件中的 init 执行顺序，依赖编译器 resolve 源代码文件的顺序，亦可以是手动指定文件的顺序，所以他们的执行顺序是不可靠的。所以一个包尽量一个 init 函数。
+
+```go
+// main.go
+package main
+
+import (
+	"fmt"
+)
+
+func init() {
+	fmt.Println("main")
+}
+
+func main() {
+}
+
+```
+
+```go
+// b.go
+package main
+
+import (
+	"fmt"
+)
+
+func init() {
+	fmt.Println("b")
+}
+
+```
+
+```go
+$ go build -o main main.go b.go
+$ ./main
+main
+b
+$ go build -o main b.go main.go
+./main
+b
+main
+```
@@ -0,0 +1,27 @@
+# 内嵌
+
+Go 语言中并没有子类继承这样的概念，而是通过嵌入(Embedding)的方式来实现类或者接口的组合。
+
+```go
+// ReadWriter 的实现需要同时满足 Reader 与 Writer
+type ReadWriter interface {
+    Reader
+    Writer
+}
+
+// Server 暴露了所有 Logger 结构体的方法
+type Server struct {
+    Host string
+    Port int
+    *log.Logger
+}
+
+// 初始化方式并未受影响
+server := &Server{"localhost", 80, log.New(...)}
+
+// 却可以直接调用内嵌结构体的方法，等价于 server.Logger.Log(...)
+server.Log(...)
+
+// 内嵌结构体的名词即是类型名
+var logger *log.Logger = server.Logger
+```
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`# 并发编程`
`2`	`2`
`3`		`-关于并发编程的通用基础内容，参阅`
	`3`	`+关于并发编程的通用基础内容，参阅[并发编程导论 https://url.wx-coder.cn/Yagu8 ](https://url.wx-coder.cn/Yagu8)。`