复合数据类型（构造类型）
map
golang map 是Hash表的引用，差不多就是PHP 关联数组或者 Python 字典，当然 C++ STL 也有map，但 golang map 应该是 unordered_map。map 所有键必须同类型，值也必须同类型，这一点并不像 PHP 关联数组那样随心所欲，另外，键必须是支持 == 进行比较的，所以通常它是一个原始基本类型。由于浮点比较的不精确性，所以用浮点数为键不是好主意（golang NaN可以是浮点）。
初始化一个map，类似如下：
ages := map[string]int {
"Alice": 31,
"Charlie": 34,
}创建一个空的map，有两种方式
ages := map[string]int {}
// or
ages := make(map[string]int)移除map的某个元素（键值对），可以使用内置函数 delete，如
delete(ages, "Alice")可以安全地删除不存在的元素（键不存在），甚至可以安全地访问不存在的键（此时返回该类型的零值）或者修改它（此时先自动创建元素再修改），例如
ages["Bob"] = ages["Bob"] + 1
// or
ages["Bob"] += 1
// or
ages["Bob"]++上面的代码，都会先主动创建键为Bob，值为0的元素，然后将值加1，这一点似乎比STL map要更夸张一点。
golang map的键是无序的，这和 STL map 用红黑树内部有序不同，如果确实需要按键排序，只能遍历map把键取出作为一个数组，对该数组排序再来索引map。
map 的元素访问，遍历都是自然的，只是不存在的键也可以访问（返回零值）。那么如何区分返回的恰好是0，还是因为键不存在返回了0？答案是访问键不仅返回值，还可以同时返回检索是否成功：
age, ok := ages["bob"]
if !ok { /* not key! */ }
// or
if age, ok := ages["bob"]; !ok { /* not key! */ }和 slice 一样，除了用 == 或 != 和 nil 作比较，map 是不可比较的。确实要比较2个map，只能手动自己写函数，只是 map 允许访问不存在的键，给比较函数带来一个小坑
package main
import (
"fmt"
)
func main() {
map1 := map[string]int{"A": 0}
map2 := map[string]int{"B": 42}
fmt.Println(equal(map1, map2)) // false
}
func equal(x, y map[string]int) bool {
if len(x) != len(y) {
return false
}
for k, xv := range x {
if yv, ok := y[k]; !ok || yv != xv { // y 中键 k 不存在也是不等的
return false
}
}
return true
}
golang 没有集合类型，但可以直接用 map[T]bool 来代替集合。当我们希望键是某种不可比较的类型（例如 slice）时怎么办？和前面的排序问题一样，变通实现，即引入辅助函数k()，确保当且仅当 x 和 y 相等时， k(x) == k(y)，而且 k() 返回类型是可以比较的（通常是字符串类型），然后创建 map[k(T)]T‘形式的map
map 的值类型可以是复合类型，如 slice 或者又一个map，make(map[string]map[string]bool) 将创建键为string，值为map类型，值的map类型中的键为string，值为bool
结构体
golang结构体和C结构体比较相似，不过golang结构体成员可以是空的，另外，声明的时候是用定义新类型（类型别名）的方式进行的：
type Employee struct {
ID int
Name string
Address string
DoB time.Time
Position string
Salary int
ManagerID int
}用该类型声明变量 var john Empoyee
访问成员 john.Salary -= 5000
指针访问 position := &john.Position; *position = "Senior " + *position
指向结构体的指针也用点号.访问！
var e *Empoyee = &john ; e.Position += " (proactive team player)"
结构体成员的名字和顺序很重要，在不改变顺序情况下，相同类型的成员可以简化写成一行。
golang 结构体有一个被王垠大神吐槽的访问控制机制，即成员变量名称首字母大写意味着该变量是可导出的，而小写的是私有的。这个和包全局变量的情况一致。
结构体初始化可以使用两种方式（短结构多用方式一，复杂结构多用方式二），但不能混用
package main
import (
"fmt"
)
func main() {
p1 := Point{1, 2} // 方式一
p2 := Point{Y: 2, X: 1} // 方式二，可不按顺序
p3 := Point{X: 1} // 方式二，部分成员给定值，其余默认0值
fmt.Println(p1) // {1 2}
fmt.Println(p2) // {1 2}
fmt.Println(p3) // {1 0}
}
type Point struct {
X, Y int
}
结构体类型作为函数参数，也是拷贝的（值传递），所以，对于大的结构体作为函数参数，一般使用指针方式。创建、初始化结构体变量并获取它的地址可以一步完成：
pp := &Point{1, 2}
// 等价于
pp := new(Point)
*pp = Point{1, 2}&Point{1, 2} 一步完成（返回了指针），所以可以作为函数实参。
结构体是否可以用 == 或 != 比较，是由其所有成员决定的，即所有成员可以比较，结构体才可以比较。当结构体可以用 == 比较时，它可以作为map的键。
golang支持嵌套匿名结构体，并为访问匿名结构体的成员提供快捷语法：
package main
import (
"fmt"
)
func main() {
var w Wheel
w.X = 8 // 等价于 w.Circle.Point.X = 8
w.Y = 8 // 等价于 w.Circle.Point.Y = 8
w.Radius = 5 // 等价于 w.Circle.Radius = 5
w.Spokes = 20
fmt.Println(w) // {{{8 8} 5} 20}
w1 := Wheel{Circle{Point{8, 8}, 5}, 20}
w2 := Wheel{
Circle: Circle{
Point: Point{X: 8, Y: 8},
Radius: 5, // 这个逗号是必需的！
},
Spokes: 20, // 这个逗号是必需的！
}
fmt.Printf("%#v\n", w1)
fmt.Printf("%#v\n", w2)
}
type Point struct {
X, Y int
}
type Circle struct {
Point // 匿名结构体，自动嵌入成员 X, Y
Radius int
}
type Wheel struct {
Circle // 匿名结构体，自动嵌入 X, Y, Radius
Spokes int
}
代码中，结构体用字面量初始化时，仍然只能用标准方式（注意代码中含嵌套的结构体初始化时最后一个成员尾部的逗号，可以理解为”有儿子的结构体初始化最后一个成员后加逗号“）。上述代码输出
{{{8 8} 5} 20}
main.Wheel{Circle:main.Circle{Point:main.Point{X:8, Y:8}, Radius:5}, Spokes:20}
main.Wheel{Circle:main.Circle{Point:main.Point{X:8, Y:8}, Radius:5}, Spokes:20}对于嵌套结构体的成员的访问控制，例如 point 不可导出，但有可导出的成员 X 和 Y，当将它通过 circle（不可导出）嵌入 Wheel 时， w.X 在引入Wheel的包仍然可用，但 w.circle.point.X 就不行。简单理解，嵌入的成员它的访问控制并不由原来的结构体说了算，好像它已经成了包含嵌体的结构体的成员。
嵌入的匿名成员，并不限于结构体类型，任何命名的类型或指向命名类型的指针都可以。用快捷方式访问匿名成员的方式，不仅适用于匿名成员内部变量，也适用于它的方法。这种机制，帮助 golang 实现了 聚合方式的 OOP。
----