uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

byte        alias for uint8
rune        alias for int32

uint     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

15  // 10进制形式(一定不能以"0"开头)
017 //  8进制形式(必须以"0"开头)
0xF // 16进制形式(必须以"0x" 或 "0X"开头)

type IntAlias = int
type IntDefinition int

var i int = 100
var ia IntAlias = 100
var id IntDefinition = 100

println("i == ia?", i == ia) //true, i 和 ia是相同类型，相当于2个相同类型的变量在进行值的比较。
//println("i == id?", i == id) //invalid operation: i == id (mismatched types int and IntDefinition), 编译出错，i和id是不同的类型。
println("i == id?", i == (int)(id)) //i的类型为int。id的类型演变方式为IntDefinition--int，id从IntDefinition类型到int类型直接转换即可(int)(id)

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8
// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

type t1 struct {
	S string
}
type T2 = t1

type A []string //[]string是切片，属于复合数据类型，所以[]string是“非定义的类型(Non-Defined Types)”。 但是A是通过“类型定义”创建出来的类型，属于“定义的类型(Defined Types)”，符合“定义的类型(Defined Types)”的第2点。
type B = A //B是通过“类型定义”创建出来的类型A的别名，所以B也是“定义的类型(Defined Types)”,符合“定义的类型(Defined Types)”的第3点。
type C = []string //[]string是切片，属于复合数据类型，所以[]string是**非定义的类型(Non-Defined Types)**。C不符合“定义的类型(Defined Types)”的3点定义，C是“非定义的类型(Non-Defined Types)”。

var a int = 100
println("Value of a:", a)
println("Address of a:", &a)

var p *int //p 为*int类型的指针，*int的基础类型是int
println("p: ", p, p == nil)
p = new(int) //new(int)分配一块存储int型数值的内存，并返回这块内存的地址给p
println("p: ", p, p == nil)

var a int = 100
println("Value of a:", a)
println("Address of a:", &a)

var pa *int
println()
println("Value of pa:", pa)

pa = &a //将变量a的地址赋给pa，pa存储的是变量a的地址，即pa指向变量a。
println("Value of pa:", pa)
println("Value pointed by pa:", *pa) //*pa表示取出pa存储地址上的数据，即a的值。

*pa = 200 //*pa = 200指的是将200赋到pa所指向的地址上，pa存储的是变量a的地址，从而变量a的值从100变为了200
println()
println("Value of pa:", pa)
println("Value pointed by pa:", *pa)

pa = nil //将pa的值赋为nil，则pa不再指向变量a，pa的值变了，但变量a的地址和值均未变
println()
println("Value of pa:", pa)
println("Value of a:", a)
println("Address of a:", &a)

type DINT int
type PINT *int
type PDINT *DINT

var i int = 200
println("i:", i)

var p *int = new(int)
p = &i
println("p:", p)

var di DINT
//di = i //cannot use i (type int) as type DINT in assignment
di = (DINT)(i) //显示转换;非指针类型的定义类型(DINT)和基础类型(int)的变量不可以互相直接赋值，编译器无法使用隐式转换，代码里需要显示转换。
println(" i to  di:", di)

var pi PINT
pi = p         //隐式转换;pi的类型演变是PINT--*int; p的类型是*int。*int到PINT之间没有其他类型，*int类型的变量p可以直接(隐式转换)赋给PINT类型的变量pi。
pi = (PINT)(p) //显示转换;pi的类型演变是PINT--*int; p的类型是*int。*int到PINT之间没有其他类型，*int类型的变量p也可以显示转换赋给PINT类型的变量pi。
println(" p to  pi:", pi)

var pdi PDINT
//pdi = p //cannot use p (type *int) as type PDINT in assignment
pdi = (*DINT)(p)          //显式+隐式转换;pdi的类型演变是PDINT--*DINT--*int; p的类型是*int。*int到PDINT之间有一个*DINT类型，*int类型的变量p需要先显示转换成*DINT类型，*DINT到PINT之间没有其他类型，*DINT类型的变量p通过隐式转换成PINT，再赋给PINT类型的变量pi。
pdi = (PDINT)((*DINT)(p)) //显示转换     ;pdi的类型演变是PDINT--*DINT--*int; p的类型是*int。*int到PDINT之间有一个*DINT类型，*int类型的变量p需要先显示转换成*DINT类型，*DINT到PINT之间没有其他类型，*DINT类型的变量p也可以显示转换成PINT，再赋给PINT类型的变量pi。
println(" p to pdi:", pdi)

//pdi = pi //cannot use pi (type PINT) as type PDINT in assignment;pi不能直接赋给pdi，因为pi和pdi是不同的类型
pdi = (*DINT)((*int)(pi))          //显式+隐式转换;pdi的类型演变是PDINT--*DINT--*int; pi的类型演变是PINT--*int。PINT类型的变量pi需要先显示转换回*int类型，然后再显示转换成*DINT类型，*DINT到PINT之间没有其他类型，*DINT类型的变量pi通过隐式转换成PDINT，再赋给PDINT类型的变量pdi。
pdi = (PDINT)((*DINT)((*int)(pi))) //显示转换     ;pdi的类型演变是PDINT--*DINT--*int; pi的类型演变是PINT--*int。PINT类型的变量pi需要先显示转换回*int类型，然后再显示转换成*DINT类型，*DINT到PINT之间没有其他类型，*DINT类型的变量pi也可以显示转换成PDINT，再赋给PDINT类型的变量pdi。
println("pi to pdi:", pdi)

var p *int = new(int)
println("p addr:", p, "p value:", *p)
*p = 100
println("p addr:", p, "p value:", *p)
*p++
println("p addr:", p, "p value:", *p)
*p--
println("p addr:", p, "p value:", *p)

package main

func pointerTest() *int {
       	var ptr *int = new(int)
       	*ptr = 123456789
       	println("ptr:", ptr, *ptr)
       	return ptr
}

func main() {
       	ret := pointerTest()
       	println("ret:", ret, *ret)
}

var r rune

r = 'a' //字面量'a'
println(r)

r = '\141' //3位8 进制的字面量表示为\141
println(r)

r = '\x61' //2位16进制的字面量表示为\x61
println(r)

r = '\u0061' //4位16进制的字面量表示为\u0061
println(r)

r = '\U00000061' //8位16进制的字面量表示为\U00000061
println(r)

1.23
01.23 // == 1.23
.23
1.
// A "e" or "E" starts the exponent part.
1.23e2  // == 123.0
123E2   // == 12300.0
123.E+2 // == 12300.0
1e-1    // == 0.1
.1e0    // == 0.1
0e+5    // == 0.0

var array [5]int
array[0] = 10
array[1] = 20
array[2] = 30
array[3] = 40
array[4] = 50
fmt.Println("len:", len(array), "array:", array)

array := [5]int{10, 20, 30, 40, 50}
fmt.Println("len:", len(array), "array:", array)

array := [...]int{10, 20, 30, 40, 50, 60, 70, 80}
fmt.Println("len:", len(array), "array:", array)

array := [...]int{0: 50, 10: 50}
fmt.Println("len:", len(array), "array:", array)

var array [5]*int
fmt.Println("declared array:", array)
array[0] = new(int)
array[1] = new(int)
array[2] = new(int)
array[3] = new(int)
array[4] = new(int)
fmt.Println("assigned array:", array)

array := [5]*int{new(int), new(int), new(int), new(int), new(int)}
fmt.Println("initial array:", array)

*array[0] = 10
fmt.Println("&array[0] =", &array[0], "array[0] =", array[0], "*array[0] =", *array[0])

*array[1] = 20
fmt.Println("&array[1] =", &array[1], "array[1] =", array[1], "*array[1] =", *array[1])

*array[2] = 30
fmt.Println("&array[2] =", &array[2], "array[2] =", array[2], "*array[2] =", *array[2])

*array[3] = 40
fmt.Println("&array[3] =", &array[3], "array[3] =", array[3], "*array[3] =", *array[3])

*array[4] = 50
fmt.Println("&array[4] =", &array[4], "array[4] =", array[4], "*array[4] =", *array[4])

var array1 [5]int
fmt.Println("declared array1:", array1)

array2 := [5]int{10, 20, 30, 40, 50}
array1 = array2
fmt.Println("assigned array1:", array1)

var array1 [5]string
var array2 = [5]string{"desk", "pencil", "ruler", "ink", "book"}

array1 = array2
fmt.Println("len(array1):", len(array1), " array1   :", array1)
fmt.Println("len(array2):", len(array2), " array2   :", array2)

var array1 [5]*int
fmt.Println("declared array1:", array1)

array2 := [5]*int{new(int), new(int), new(int), new(int), new(int)}
array1 = array2
fmt.Println("assigned array1:", array1)

array := [2][5]int {{10, 11, 12, 13, 14},{20, 21, 22, 23, 24}}
fmt.Println("len(array):", len(array), "array:", array)
fmt.Println("len(array[0]):", len(array[0]), "array[0]:", array[0])
fmt.Println("len(array[1]):", len(array[1]), "array[1]:", array[1])

array := [2][5]int{1: {2: 22}}
fmt.Println("len(array):", len(array), "array:", array)
fmt.Println("len(array[0]):", len(array[0]), "array[0]:", array[0])
fmt.Println("len(array[1]):", len(array[1]), "array[1]:", array[1])

var array [2][5]int
array[0][0] = 10
array[0][1] = 11
array[0][2] = 12
array[0][3] = 13
array[0][4] = 14
array[1][0] = 20
array[1][1] = 21
array[1][2] = 22
array[1][3] = 23
array[1][4] = 24
fmt.Println("len(array):", len(array), "array:", array)
fmt.Println("len(array[0]):", len(array[0]), "array[0]:", array[0])
fmt.Println("len(array[1]):", len(array[1]), "array[1]:", array[1])

var array1 [2][5]int
var array2 [2][5]int

array2[0][0] = 10
array2[0][1] = 11
array2[0][2] = 12
array2[0][3] = 13
array2[0][4] = 14
array2[1][0] = 20
array2[1][1] = 21
array2[1][2] = 22
array2[1][3] = 23
array2[1][4] = 24

array1 = array2
fmt.Println("len(array1):", len(array1), "array1:", array1)
fmt.Println("len(array2):", len(array2), "array2:", array2)

func main() {

	array := [2][5]int{{10, 11, 12, 13, 14}, {20, 21, 22, 23, 24}}
	test1(array)
	test2(&array)
}

func test1(a [2][5]int) { //test1参数传递的是整个二维数组
	fmt.Println("test1 a :", a, "len(a):", len(a), "sizeof(a):", unsafe.Sizeof(a))
}

func test2(a *[2][5]int) { //test2参数传递的是二维数组的指针
	fmt.Println("test2 a:", a, "len(a):", len(a), "sizeof(a):", unsafe.Sizeof(a))
}

type _slice struct {
	elements unsafe.Pointer // referencing underlying elements
	len      int            // length
	cap      int            // capacity
}

var s []int //or var s []int = nil

fmt.Println("s is nil?", s== nil)
fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n", s, len(s), cap(s))

s := []int(nil)

fmt.Println("s is nil?", s== nil)
fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n", s, len(s), cap(s))

s := []int{}

fmt.Println("s is nil?", s== nil)
fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n", s, len(s), cap(s))

s := make([]int, 0)

fmt.Println("s is nil?", s== nil)
fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n", s, len(s), cap(s))

s := []string{"pen", "ink", "paper", "eraser", "bag"}

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n", s, len(s), cap(s))

s := []string{4: "bag"}

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n", s, len(s), cap(s))

var s []int //or var s []int = nil

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

s = make([]int, 5)

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

s[0] = 1
s[1] = 2
s[2] = 3
s[3] = 4
s[4] = 5

fmt.Printf("s %#v\n", s)

s:= []int(nil)

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

s = make([]int, 4, 5)

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

s[0] = 1
s[1] = 2
s[2] = 3
//s[3]不予赋值，因为切片s一共有4个数组元素可以访问，s[3]默认为0
//s[4]不能赋值，因为切片s一共有4个数组元素可以访问，给s[4]赋值，会导致编译错误

fmt.Printf("s %#v\n", s)

s := make([]int, 4, 5)

s[0] = 1
s[1] = 2
s[2] = 3

fmt.Printf("s %#v\n", s)

s := []int{} //or s := make([]int, 0)
s1 := []int{7,8,9}

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

s = append(s, 1, 2, 3)

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

s = append(s, s1...)

fmt.Printf("s %#v\n", s)
fmt.Printf("s header address: %p\n", &s)
fmt.Printf("s array header address(elements): %p len: %d cap: %d\n\n", s, len(s), cap(s))

slice := append([]byte("hello "), "world"...)

fmt.Printf("elements:%06p, capacity:%d, length:%d, slice: %s\n", slice, len(slice), cap(slice), slice)

s1 := make([]int, 5)
s2 := make([]int, 15)
s3 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s4 := make([]byte, 5)

n1 := copy(s1, s3[:])        //s1 len 小于 s3 len
n2 := copy(s2, s3[:])        //s2 len 大于 s3 len
n3 := copy(s3[0:], s3[5:9])  //s3 重叠拷贝
n4 := copy(s4, "blackwhite") //将字符串拷贝到byte切片

fmt.Println("n1:", n1, "s1:", s1)
fmt.Println("n2:", n2, "s2:", s2)
fmt.Println("n3:", n3, "s3:", s3)
fmt.Printf("n4: %d s4: %s\n", n4, s4)

s := []string{"zero", "one", "two", "three", "four", "five", "six", "seven", "eight"}

for i, v := range s {
	fmt.Println(i, v)
}

slice1 := []string{"pen", "ink", "paper", "eraser", "bag"}
slice2 := slice1[1:3]
slice3 := slice1[1:3:4]
fmt.Println(slice1, len(slice1), cap(slice1))
fmt.Println(slice2, len(slice2), cap(slice2))
fmt.Println(slice3, len(slice3), cap(slice3))

slice1 := []string{"pen", "ink", "paper", "eraser", "bag"}
slice2 := slice1[1:3]
slice2[1] = "elephant"
fmt.Println(slice1, len(slice1), cap(slice1))
fmt.Println(slice2, len(slice2), cap(slice2))

slice := [][]int{{1, 2, 3}, {10, 20, 30}}

fmt.Printf("slice variable address: %p\n\n", &slice) //0x40a0e0：slice变量的首地址

fmt.Printf("slice[0] header address: %p\n\n", slice) //0x43e260：二维切片里第0个切片成员slice[0]的首地址。

fmt.Printf("slice[0] header address: %p\n", &slice[0])           //0x43e260：二维切片里第0个切片成员slice[0]的首地址。
fmt.Printf("slice[0] array header address:  %p\n", slice[0])     //0x414020：slice[0]切片底层数组的首地址。
fmt.Printf("slice[0] array header address:  %p\n", &slice[0][0]) //0x414020：slice[0]切片底层数组的首地址。
fmt.Printf("slice[0] array's addresses:     %p %p %p\n\n", &slice[0][0], &slice[0][1], &slice[0][2])

fmt.Printf("slice[1] header address: %p\n", &slice[1])           //0x43e26c：二维切片里第1个切片成员slice[1]的首地址。
fmt.Printf("slice[1] array header address:  %p\n", slice[1])     //0x414030：slice[1]切片底层数组的首地址。
fmt.Printf("slice[1] array header address:  %p\n", &slice[1][0]) //0x414030：slice[1]切片底层数组的首地址。
fmt.Printf("slice[1] array's addresses:     %p %p %p\n\n", &slice[1][0], &slice[1][1], &slice[1][2])

func main() {

	slice := [][]int{{10, 11, 12, 13, 14}, {20, 21, 22, 23, 24}}
	test1(slice)
	test2(&slice)
}

func test1(a [][]int) { //test1参数传递的是整个二维切片
	//fmt.Println("test1 a :", a, "len(a):", len(a), "sizeof(a):", unsafe.Sizeof(a))
	fmt.Println("test2 a:", a, "sizeof(a):", unsafe.Sizeof(a))
}

func test2(a *[][]int) { //test2参数传递的是二维切片的指针
	//fmt.Println("test2 a:", a, "len(a):", len(a), "sizeof(a):", unsafe.Sizeof(a))
	fmt.Println("test2 a:", a, "sizeof(a):", unsafe.Sizeof(a))
}

var m map[string]int //声明一个类型为map[string]int的变量m
fmt.Printf("m header address: %06p, m hash header address %06p.\n", &m, m)

m = make(map[string]int) //使用make为m分配类型为map[string]int的哈希表
fmt.Printf("m header address: %06p, m hash header address %06p.\n", &m, m)

m["aaa"] = 111
m["bbb"] = 222
m["ccc"] = 333
fmt.Println("m: ", m)

m := make(map[string]int)

m["aaa"] = 111
m["bbb"] = 222
m["ccc"] = 333

fmt.Printf("m header address: %06p, m hash header address %06p.\n", &m, m)
fmt.Println("m: ", m)

m := map[string]int{}

m["aaa"] = 111
m["bbb"] = 222
m["ccc"] = 333

fmt.Printf("m header address: %06p, m hash header address %06p.\n", &m, m)
fmt.Println("m: ", m)

m := map[string]int{"aaa":111, "bbb":222, "ccc":333 }

fmt.Printf("m header address: %06p, m hash header address %06p.\n", &m, m)
fmt.Println("m: ", m)

m := map[string]int{"aaa": 111, "bbb": 222, "ccc": 333}

for k, v := range m {
	fmt.Println("key", k, "value", v)
}

kod := []string{}
m := map[string]int{"aaa": 111, "bbb": 222, "ccc": 333}

for k, _ := range m {
	kod = append(kod, k)
}

sort.Strings(kod)

for _, s := range kod {
	fmt.Println("Key", s, "Value", m[s])
}

var v int
var exist bool

m := map[string]int{"aaa": 1, "bbb": 2, "ccc": 3}

//bbb在map中，v为222，exist为true.
v, exist = m["bbb"]
fmt.Println("bbb value", v, exist)

//xyz不在map中，虽然v能打印出值0（实际上是int型变量的默认值），但exist为false，这种为不安全的取值。
v, exist = m["xyz"]
fmt.Println("xyz value", v, exist)

//所以需要先判断exist的布尔值，exist为true说明xyz存在于map中，这时候对应的Value是有效的，否则就是xyz不存在于map中。
if v, exist = m["xyz"]; exist {
	fmt.Println("xyz value", v, exist)

} else {
	fmt.Println("Key xyz doesn't exist in map")
}

m := map[string]int{"aaa": 111, "bbb": 222, "ccc": 333}
fmt.Println("m: ", m)

delete(m, "aaa")
fmt.Println("m: ", m)

delete(m, "opq")
fmt.Println("m: ", m)

func sig1(x int, y int) int {
	return x + y
}

func sig2(x, y int) int {
	return x + y
}

func sig3(x int, _ int) int {
	return x
}

func sig4(int, int) int {
	return 0
}

func main() {
	fmt.Printf("sig1: %T\n", sig1)
	fmt.Printf("sig2: %T\n", sig2)
	fmt.Printf("sig3: %T\n", sig3)
	fmt.Printf("sig4: %T\n", sig4)
}

package math

func Sin(x float64) float64 // implemented in assembly language.

func recursion(slice []int) []int {
	slice = append(slice, len(slice)+1)

	fmt.Println(slice)
	if len(slice) < 20 {
		recursion(slice)
	}

	return slice
}

func main() {
	mainslice := recursion(nil)
	fmt.Println("mainslice:", mainslice, "len:", len(mainslice), "cap:", cap(mainslice))
}

func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

func main() {
	var f func(int, int) int

	fmt.Println(f == nil)
	//fmt.Println(f == f) //invalid operation: f == f (func can only be compared to nil)

	f = add
	fmt.Println("5 + 3: ", f(5, 3))
	f = sub
	fmt.Println("5 - 3: ", f(5, 3))
}

func add1(r rune) rune { return r + 1 }
func main() {
	fmt.Println(strings.Map(add1, "HAL-9000")) // "IBM.:111"
	fmt.Println(strings.Map(add1, "VMS"))      // "WNT"
	fmt.Println(strings.Map(add1, "Admix"))    // "Benjy"
}

func main() {

	for i := 0; i < 10; i++ {
		fmt.Printf("%*s\n", i*2, "-")
	}

	for i := 10; i > 0; i-- {
		fmt.Printf("%*s\n", i*2, "-")
	}
}

-
 -
   -
     -
       -
         -
           -
             -
               -
                 -
                   -
                 -
               -
             -
           -
         -
       -
     -
   -
 -

func main() {
	fmt.Println(strings.Map(func(x rune) rune { return x + 1 }, "HAL-9000"))
	fmt.Println(strings.Map(func(x rune) rune { return x + 1 }, "VMS"))
	fmt.Println(strings.Map(func(x rune) rune { return x + 1 }, "Admix"))
}

func add() func() int {
	i := 1
	return func() int {
		i = i + 1
		return i
	}
}

func main() {
	s := add // s是一个指向add函数的指针
	fmt.Println("add addr:", s)
	var f func() int // f是一个func() int函数类型的变量

	/* square()的返回值是函数体内的匿名函数，将匿名函数
		func() int {
			i = i + 1
			return i
		}
	赋给f
	*/
	f = s() //将add()函数的执行结果返回给f，f现在是匿名函数，它能继续引用add函数体内的变量i

	//如下面对f函数的调用f(), 每调用一次i都加1。
	//对于add函数内的变量i来说，这种匿名函数对i的调用一定程度上类似于C语言内的static int i = 1。
	fmt.Println("  f addr:", f, "f():", f()) //匿名函数调用结果 2
	fmt.Println("  f addr:", f, "f():", f()) //匿名函数调用结果 3
	fmt.Println("  f addr:", f, "f():", f()) //匿名函数调用结果 4
	fmt.Println("  f addr:", f, "f():", f()) //匿名函数调用结果 5
}

func main() {

	var fs []func()
	slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	for _, s := range slice {
		fs = append(fs, func() { fmt.Println(&s, s) })
	}

	for _, f := range fs {
		f()
	}
}

func main() {

	var fs []func()
	slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	for _, s := range slice {
		s := s
		fs = append(fs, func() { fmt.Println(&s, s) })
	}

	for _, f := range fs {
		f()
	}
}

func add1(i ...int) {
	var sum int
	for _, s := range i {
		sum += s
	}
	fmt.Printf("add1: i type: %T, sum: %d\n", i, sum)
}

func add2(i []int) {
	var sum int
	for _, s := range i {
		sum += s
	}
	fmt.Printf("add2: i type: %T, sum: %d\n", i, sum)
}

func main() {
	fmt.Printf("add1 type:%T\n", add1)
	fmt.Printf("add2 type:%T\n", add2)
	fmt.Println()

	s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	add1(1, 2, 3, 4, 5, 6, 7, 8, 9) //1. main函数隐式的把add的参数放到一个切片里，然后再传给add函数。
	add1(s...)                      //2. main函数向add1变参函数真的传递一个切片的时候，需要在切片变量后面加入...，以告知add1这回真是个切片。
	add2(s)                         //3. main函数向add2(参数为切片)传参的时候，直接写s即可。
}

func anytype(i ...interface{}) {
	fmt.Println(i)
}

func main() {
	anytype(1, 2, 3, 4)
	anytype("abc", "def", "ghi", "jkl")
	anytype(1, "def", true, 3.14)
}

func ReadFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    return ReadAll(f)
}

func bigSlowOperation() {
	defer trace("bigSlowOperation")() // don't forget the extra parentheses
	// ...lots of work...
	time.Sleep(10 * time.Second) // simulate slow operation by sleeping
}
func trace(msg string) func() {
	start := time.Now()
	log.Printf("enter %s", msg)
	return func() {
		log.Printf("exit %s (%s)", msg, time.Since(start))
	}
}

func main() {
	bigSlowOperation()
}

func add(i ...int) int {
	var sum int

	defer func() { fmt.Println("sum: ", sum) }()

	for _, s := range i {
		sum += s
	}

	return sum
}

func main() {

	add(1, 2, 3, 4, 5)
	add(5, 5, 5, 5, 5)
}

func main() {

	for _, filename := range filenames {
		f, err := os.Open(filename)
		if err != nil {
			return err
		}
		defer f.Close() // NOTE: risky; could run out of file descriptors
		// ...process f...
	}
}

func processfile(file string) error {
	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer f.Close() // NOTE: risky; could run out of file descriptors
	// ...process f...

}

func main() {

	for _, filename := range filenames {
		if err := processfile(filename); err != nil {
			return err
		}
	}
}

fmt.Println(err)
//or
fmt.Printf("%v", err)

return errors.New("Failed to get data")
//or
return fmt.Errorf("Failed to get data, status: %s", status)

fmt.Fprintf(os.Stderr, "Site is down: %v\n", err)
os.Exit(1)
//or
 log.Fatalf("Site is down: %v\n", err)

log.SetPrefix("wait: ")
log.SetFlags(0)

fmt.Fprintf(os.Stderr, "Site is down: %v\n", err)
os.Exit(1)
//or
 log.Fatalf("Site is down: %v\n", err)

func main() {

	f(3)

	fmt.Println("main is end")
}

func f(x int) {
	fmt.Printf("f(%d)\n", x+0/x) // panics if x == 0
	f(x - 1)
}

func main() {
	defer printStack()
	f(3)
}

func printStack() {
	var buf [4096]byte
	n := runtime.Stack(buf[:], false)
	os.Stdout.Write(buf[:n])
}

func f(x int) {
	fmt.Printf("f(%d)\n", x+0/x) // panics if x == 0
	f(x - 1)
}

func main() {
	f(3)
}

func f(x int) {
	if x == 1 {
		panic(fmt.Sprintf("stop recursion when x is %d", x))
	}

	f(x - 1)
}

func main() {

	f(3)

	fmt.Println("main is end")
}

func f(x int) {
	defer func() {
		if p := recover(); p != nil {
			fmt.Printf("internal error(x = %d). %v\n", x, p)
		}
	}()

	fmt.Printf("f(%d)\n", x+0/x) // panics if x == 0
	f(x - 1)
}

package geometry

import "math"

type Point struct{ X, Y float64 }

// traditional function
func Distance(p, q Point) float64 {
	return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// same thing, but as a method of the Point type
func (p Point) Distance(q Point) float64 {
	return math.Hypot(q.X-p.X, q.Y-p.Y)
}

package main

import "fmt"
import "geometry"

func main() {
	p1 := geometry.Point{3, 5}
	p2 := geometry.Point{3, 100}

	fmt.Println(p1.Distance(p2))           //方法调用
	fmt.Println(geometry.Distance(p1, p2)) //函数调用
}

package geometry

import "math"

type Point struct{ X, Y float64 }

// traditional function
func Distance(p, q Point) float64 {
	return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// same thing, but as a method of the Point type
func (p Point) Distance(q Point) float64 {
	return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// A Path is a journey connecting the points with straight lines.
type Path []Point

// Distance returns the distance traveled along the path.
func (path Path) Distance() float64 {
	sum := 0.0
	for i := range path {
		if i > 0 {
			sum += path[i-1].Distance(path[i])
		}
	}
	return sum
}

package main

import (
	"fmt"
	"geometry"
)

func main() {
	p := geometry.Path{{2, 10}, {3, 20}, {4, 30}, {5, 40}}
	fmt.Println(p.Distance())
}

package main

import (
	"fmt"
)

type rbt struct {
	distance, step int
}

func (r rbt) m(num int) {
	r.distance = num * r.step
}

func (r *rbt) move(num int) {
	r.distance = num * r.step
}

func main() {
	r1 := rbt{0, 5} // r1是rbt类型的普通变量（这里rbt类型的普通变量用于区分*rbt类型的指针变量，如后面的指针变量r2这里叫做指针变量）

	fmt.Printf("\nr1.m type: %T r1.move type: %T\n", r1.m, r1.move) //r1.m type: func(int) r1.move type: func(int)
	fmt.Printf("r1 type: %T    &r1 type: %T\n", r1, &r1)            //r1 type: main.rbt    &r1 type: *main.rbt

	r1.m(7)                  //r1是rbt类型的普通变量，方法m的接收者是rbt类型的普通变量，则r1可以直接调用方法m
	fmt.Println(r1.distance) //0 普通变量r1在调用方法m时，会产生一个r1的副本，这和C语言函数的形参是普通变量，函数调用者给函数传实参后，
	// 函数得到的是实参的副本，函数对实参副本的更改并不改变函数调用者的实参值，因此这里普通变量r1的m函数操作的是r1的副本，
	// 并不影响真正的实参r1的成员distance的值，所以打印r1.distance时值为0

	(&r1).move(7)            //r1是rbt类型的普通变量，方法move的接收者是*rbt类型的指针变量，取地址符号&可以将r1变成*rbt类型的指针变量：&r1，因此(&r1)可以调用接收者是*rbt类型的方法move
	fmt.Println(r1.distance) //35 方法的接收者是指针变量，同C语言将实参传递给指针类型的形参一样，调用者和被调函数共享同一个指针变量，所以被调函数改变形参后，实参也跟着改变，r1.distance为35

	r1.move(7)               //r1是rbt类型的普通变量，方法move的接收者是*rbt类型的指针变量，r1也可以直接调用方法move，编译器隐式的使用&r1来调用move
	fmt.Println(r1.distance) //35 方法接收者是指针变量，方法里对变量的更改会影响指针变量的值，方法里将r1.distance改成了35，再打印r1.distance时也是35

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	r2 := &rbt{0, 5} // r2是*rbt类型的指针变量（这里*rbt类型的指针变量用于区分rbt类型的普通变量，如上面的普通变量r1）

	fmt.Printf("\nr2.m type: %T  r2.move type: %T\n", r2.m, r2.move) //r2.m type: func(int)  r2.move type: func(int)
	fmt.Printf("r2 type: %T    *r2 type: %T\n", r2, *r2)             //r2 type: *main.rbt    *r2 type: main.rbt

	r2.m(7)                  //r2是rbt类型的指针变量，方法m的接收者是rbt类型的普通变量，r2也可以直接调用方法m，编译器隐式的使用*r2来调用m
	fmt.Println(r2.distance) //0 方法接收者是普通变量，方法里更改的是实参的副本，函数对副本的更改并不影响实参的值，r2.distance值仍为0

	(*r2).m(7)               //r2是rbt类型的指针变量，方法m的接收者是rbt类型的普通变量，取数据符号*可以将r2变成rbt类型的普通变量:*r2，因此用(*r2)可以调用接收者是rbt类型的方法m
	fmt.Println(r2.distance) //0 方法接收者是普通变量，方法里更改的是实参的副本，函数对副本的更改并不影响实参的值，r2.distance值仍为0

	r2.move(7)               //r2是rbt类型的指针变量，方法move的接收者是*rbt类型的指针变量，则r2可以直接调用方法move
	fmt.Println(r2.distance) //35 方法接收者是指针变量，方法里对变量的更改会影响指针变量的值，方法里将r1.distance改成了35，再打印r1.distance时也是35
}

package main

import "fmt"

type S []int
type M map[int]string

func func_slice(s S) {
	s[3] = 555

	fmt.Println("\nfunc_slice")
	fmt.Printf("&s: %p s: %p %#v\n", &s, s, s)
	s = nil //TODO: 不确定这里给s赋nil值之后，s切片指向底层数组的指针已为nil，但func_slice返回后，仍能打印出s的内容。难道GC机制会判断后面还会用s所以这里s=nil的赋值没生效？
	fmt.Printf("&s: %p s: %p %#v\n", &s, s, s)
}

func func_slice_ptr(s *S) {
	(*s)[3] = 666

	fmt.Println("\nfunc_slice_ptr")
	fmt.Printf("s: %p *s: %p %#v\n", s, *s, s)
	s = nil //TODO: 不确定这里给s赋nil值之后，s切片指向底层数组的指针已为nil，但func_slice_ptr返回后，仍能打印出s的内容。难道GC机制会判断后面还会用s所以这里s=nil的赋值没生效？
	fmt.Printf("s: %p %#v\n", s, s)
}

//[]int是“非定义的类型”，如果method_slice的方法接收者由(s S)改为(s []int)后会导致
//"invalid receiver type []int ([]int is not a defined type)"的错误.
//type S []int用type定义的S是[]int的定义类型。
func (s S) method_slice() {
	s[3] = 888

	fmt.Println("\nmethod_slice")
	fmt.Printf("&s: %p s: %p %#v\n", &s, s, s)
	s = nil //TODO: 不确定这里给s赋nil值之后，s切片指向底层数组的指针已为nil，但method_slice返回后，仍能打印出s的内容。难道GC机制会判断后面还会用s所以这里s=nil的赋值没生效？
	fmt.Printf("&s: %p s: %p %#v\n", &s, s, s)
}

func (s *S) method_slice_ptr() {
	(*s)[3] = 999

	fmt.Println("\nmethod_slice_ptr")
	fmt.Printf("s: %p *s: %p %#v\n", s, *s, s)
	s = nil //TODO: 不确定这里给s赋nil值之后，s切片指向底层数组的指针已为nil，但method_slice_ptr返回后，仍能打印出s的内容。难道GC机制会判断后面还会用s所以这里s=nil的赋值没生效？
	fmt.Printf("s: %p %#v\n", s, s)
}

//##############################################################################################################################

func func_map(m M) {
	m[3] = "ooo"

	fmt.Println("\nfunc_map")
	fmt.Printf("&m: %p m: %p %#v\n", &m, m, m)
	m = nil //TODO: 不确定这里给m赋nil值之后，m切片指向底层数组的指针已为nil，但func_map返回后，仍能打印出m的内容。难道GC机制会判断后面还会用m所以这里m=nil的赋值没生效？
	fmt.Printf("&m: %p m: %p %#v\n", &m, m, m)
}

func func_map_ptr(m *M) {
	(*m)[3] = "ppp"

	fmt.Println("\nfunc_map_ptr")
	fmt.Printf("m: %p *m: %p %#v\n", m, *m, m)
	m = nil //TODO: 不确定这里给m赋nil值之后，m切片指向底层数组的指针已为nil，但func_map_ptr返回后，仍能打印出m的内容。难道GC机制会判断后面还会用m所以这里m=nil的赋值没生效？
	fmt.Printf("m: %p %#v\n", m, m)
}

//map[int]string是“非定义的类型”，如果method_map的方法接收者由(m M)改为(m map[int]string)后会导致
//"invalid receiver type map[int]string (map[int]string is not a defined type)"的错误.
//type M map[int]string用type定义的S是[]int的定义类型。
func (m M) method_map() {
	m[3] = "xxx"

	fmt.Println("\nfunc_map")
	fmt.Printf("&m: %p m: %p %#v\n", &m, m, m)
	m = nil //TODO: 不确定这里给m赋nil值之后，m切片指向底层数组的指针已为nil，但method_map返回后，仍能打印出m的内容。难道GC机制会判断后面还会用m所以这里m=nil的赋值没生效？
	fmt.Printf("&m: %p m: %p %#v\n", &m, m, m)
}

func (m *M) method_map_ptr() {
	(*m)[3] = "yyy"

	fmt.Println("\nfunc_map_ptr")
	fmt.Printf("m: %p *m: %p %#v\n", m, *m, m)
	m = nil //TODO: 不确定这里给m赋nil值之后，m切片指向底层数组的指针已为nil，但method_map_ptr返回后，仍能打印出m的内容。难道GC机制会判断后面还会用m所以这里m=nil的赋值没生效？
	fmt.Printf("m: %p %#v\n", m, m)
}

func main() {

	s := S{0, 1, 2, 3, 4, 5}
	m := M{0: "a", 1: "b", 2: "c", 3: "d", 4: "e", 5: "f"}

	fmt.Println("s:", s)
	fmt.Printf("&s: %p s: %p\n", &s, s)

	func_slice(s)
	fmt.Println("func_slice s:", s)

	func_slice_ptr(&s)
	fmt.Println("func_slice_ptr s:", s)

	s.method_slice()
	fmt.Println("method_slice s:", s)

	(&s).method_slice_ptr()
	fmt.Println("method_slice_ptr s:", s)

	fmt.Println("\n\nm:", m)
	fmt.Printf("&m: %p m: %p\n", &m, m)

	func_map(m)
	fmt.Println("func_map m:", m)

	func_map_ptr(&m)
	fmt.Println("func_map_ptr m:", m)

	m.method_map()
	fmt.Println("method_map m:", m)

	(&m).method_map_ptr()
	fmt.Println("method_map_ptr m:", m)
}

package main

import "fmt"

type M map[int]int

func (m M) get(idx int) int {
	return m[idx]
}

func (m M) set(idx, v int) {
	m[idx] = v
}

func main() {
	m := M{0: 9, 1: 99, 2: 999, 3: 9999}

	m.get(1)
	fmt.Println(m) //map[0:9 1:99 2:999 3:9999]

	m.set(1, 100)
	fmt.Println(m) //map[1:100 2:999 3:9999 0:9]

	m = nil

	ret := m.get(2)
	fmt.Println("ret: ", ret)
	fmt.Println(m) //map[]

	//m.set(2, 200) //panic: assignment to entry in nil map
	//fmt.Println(m)
}

package main

import "fmt"

type Arm struct {
	lefthand, righthand int
}

type Leg struct {
	leftleg, rightleg int
}

type Wing struct {
	leftwing, rightwing int
}

func (a *Arm) move(angle int) {
	a.lefthand += angle
	a.righthand += angle
}

func (l *Leg) walk(step int) {
	l.leftleg += step
	l.rightleg += step
}

func (w *Wing) fly(step int) {
	w.leftwing += step
	w.rightwing += step
}

type Body struct {
	Arm
	Leg
	*Wing
	height int
}

func main() {

	b := Body{Arm{1, 1}, Leg{2, 2}, &Wing{50, 50}, 180}
	fmt.Println(b.Arm, b.Leg, *b.Wing, b.height)

	b.move(2)
	b.walk(5)
	fmt.Println(b.Arm, b.Leg, *b.Wing, b.height)

	(&b).fly(100)
	fmt.Println(b.Arm, b.Leg, *b.Wing, b.height)
	fmt.Printf("b.leftwing = %d, b.rightwing = %d\n", b.leftwing, b.rightwing)
}

package main

import "fmt"

type Arm struct {
	lefthand, righthand int
}

type Leg struct {
	leftleg, rightleg int
}

type Wing struct {
	leftwing, rightwing int
}

func (a *Arm) move(angle int) {
	a.lefthand += angle
	a.righthand += angle
}

func (l *Leg) walk(step int) {
	l.leftleg += step
	l.rightleg += step
}

func (w *Wing) fly(step int) {
	w.leftwing += step
	w.rightwing += step
}

type Body struct {
	Arm
	Leg
	*Wing
	height int
}

func main() {
	a := Arm{1, 1}
	l := Leg{2, 2}
	w := Wing{50, 50}

	b := Body{a, l, &w, 180}
	fmt.Println("Ori", b.Arm, b.Leg, *b.Wing, b.height)

	//b.move(2)

	bmv := b.move //将变量b的方法move(实际上是arm的方法，只是被b引用而已)的地址赋给bmv，bmv其实是b.move的方法指针。
	bmv(2)        //向bmv传入参数2，实际上等同于b.move(2)的表示方式。
	fmt.Println("Arm", b.Arm, b.Leg, *b.Wing, b.height)

	//b.walk(5)

	wk1 := (*Leg).walk //将*Leg类型的方法walk赋给wk1， wk1是(*Leg).walk的*Leg类型walk方法的指针
	wk1(&(b.Leg), 5)   //(*Leg) 类型的方法walk实际上只有一个参数，但这里却给wk1传递了2个参数，因为wk1的第一个参数需要是wk1这个指针指向的方法的接收者类型的变量，即walk方法的接收者*Leg类型的变量&(b.Leg)，后面的5才是传给walk的参数step.
	fmt.Printf("\nwk1 type %T\n", wk1)
	fmt.Println("Leg", b.Arm, b.Leg, *b.Wing, b.height)

	wk2 := (*Body).walk //wk2和wk1都指向walk方法，只不过wk1的walk方法接收者变量是*Leg，wk2的接收者变量类型是*Body
	wk2(&b, 8)          //wk2的第一个参数是*Body类型的变量&b，第二个参数8是传给walk的参数step.
	fmt.Printf("\nwk2 type %T\n", wk2)
	fmt.Println("Leg", b.Arm, b.Leg, *b.Wing, b.height)

	(&b).fly(100)
	fmt.Println("\nWing", b.Arm, b.Leg, *b.Wing, b.height)

	fmt.Printf("b.leftwing = %d, b.rightwing = %d\n", b.leftwing, b.rightwing)
}

interface {
   eat() error
}

type eater interface {
   eat() error
}

type eatalias = interface {
 	eat() error
}

type _interface struct {
   dynamicTypeInfo *struct {
       dynamicType *_type       // the dynamic type
       methods     []*_function // method table
   }
   dynamicValue unsafe.Pointer // the dynamic value
}

package main

import "fmt"

//eater是定义的接口类型，这个接口类型定义了一个方法eat()
type eater interface {
	eat(sth string)
}

//kid是定义的结构体类型，这个结构体类型定义了一个string类型的变量name
type kid struct {
	name string
}

//kid类型实现了eat方法
func (k kid) eat(sth string) {
	fmt.Println(k.name, "is eating", sth)
}

//feed函数有2个参数:
//第1个参数是eater接口类型的变量sbd。因为kid类型实现了eater接口要求的eat()方法，
//所以kid类型满足eater接口类型的要求, eater接口类型的变量sbd能指向kid类型的变量。
//第2个参数是string类型的变量sth，代表要吃的东西。
func feed(sbd eater, sth string) {
	sbd.eat(sth)
	//fmt.Printf("sbd type: %T  value: %s\n", sbd, sbd) //sbd type: main.kid  value: {Louis}
}

func main() {
	k := kid{"Louis"}

	feed(k, "bread")
	feed(k, "apple")
}

type _interface struct {
	dynamicType  *_type         // the dynamic type
	dynamicValue unsafe.Pointer // the dynamic value
}

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var i interface{}//空接口类型变量i

	i = 1	//i的dynamicType指向int类型，dynamicValue指向int类型值1
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)

	i = 1.0 //i的dynamicType指向float类型，dynamicValue指向float类型值1.0
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)

	i = "abcdef" //i的dynamicType指向string类型，dynamicValue指向string类型值"abcdef"
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)

	i = map[int]string{0: "monday"} //i的dynamicType指向map[int]string类型，dynamicValue指向map[int]string类型值0: "monday"
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)

	i = []int{1, 2, 3, 4, 5} //i的dynamicType指向[]int类型，dynamicValue指向[]int类型值1, 2, 3, 4, 5
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)

	i = new(bytes.Buffer) //i的dynamicType指向bytes.Buffer类型的指针，dynamicValue指向bytes.Buffer类型变量的default值
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)

	i = nil //interface和interface{}类型的0值是nil
	fmt.Printf("i type: %-14T ", i)
	fmt.Println(" value:", i)
}

package main

import "fmt"

type human interface {
	swim() error
	walk() error
	talk() error
}

type superhuman interface {
	fly() error
	swim() error
	walk() error
	talk() error
}

type man struct{}

func (man) swim() error {
	fmt.Println("Man can swim")
	return nil
}

func (man) walk() error {
	fmt.Println("Man can walk")
	return nil
}

func (man) talk() error {
	fmt.Println("Man can talk")
	return nil
}

type superman struct{}

func (superman) fly() error {
	fmt.Println("superman can fly")
	return nil
}

func (superman) swim() error {
	fmt.Println("superman can swim")
	return nil
}

func (superman) walk() error {
	fmt.Println("superman can walk")
	return nil
}

func (superman) talk() error {
	fmt.Println("superman can talk")
	return nil
}

func main() {

	var h human      //h代表人类
	var s superhuman //s代表超人类

	h = s //s超人类具有人类h所拥有的所有技能: swim，walk，talk，所以可以把s赋给h。
	//s = h //人类h会的方法没有超人类s多，人类自身没有fly的技能，所以不能把h赋给s。此行编译会出现如下错误：
	//cannot use h (type human) as type superhuman in assignment: human does not implement superhuman (missing fly method)

	var m man //m代表一个人
	h = m     //m这个人实现了h人类的所有技能: swim，walk，talk，所以可以把m赋给h。 h这个接口类型的变量指向了一个实现其3个方法的变量m。

	var sm superman //sm代表一个超人
	s = sm          //sm这个超人实现了s超人类的所有技能: fly，swim，walk，talk，所以可以把sm赋给s。 s这个接口类型的变量指向一个实现了s 4个方法的变量sm.

	//试试h人类指向的这个人m所具有的技能：
	h.swim()
	h.walk()
	h.talk()

	fmt.Println() //打印一个空行

	//试试s超人类指向的这个超人sm所具有的技能：
	s.fly()
	s.swim()
	s.walk()
	s.talk()

	fmt.Println() //打印一个空行

	h = s //s超人类具有人类h所拥有的所有技能: swim，walk，talk，所以可以把s赋给h。这时候h指向的是超人sm。
	h.swim()
	h.walk()
	h.talk()
}

package main

import "fmt"

type human interface {
	swim() error
	walk() error
	talk() error
}

type superhuman interface {
	fly() error
	swim() error
	walk() error
	talk() error
}

type man struct{}

func (man) swim() error {
	fmt.Println("Man can swim")
	return nil
}

func (man) walk() error {
	fmt.Println("Man can walk")
	return nil
}

func (man) talk() error {
	fmt.Println("Man can talk")
	return nil
}

type superman struct{}

func (superman) fly() error {
	fmt.Println("superman can fly")
	return nil
}

func (superman) swim() error {
	fmt.Println("superman can swim")
	return nil
}

func (superman) walk() error {
	fmt.Println("superman can walk")
	return nil
}

func (superman) talk() error {
	fmt.Println("superman can talk")
	return nil
}

func main() {

	var h human      //h代表人类
	var s superhuman //s代表超人类

	var m man //m代表一个人
	h = m     //m这个人实现了h人类的所有技能: swim，walk，talk，所以可以把m赋给h。 h这个接口类型的变量指向了一个实现其3个方法的变量m, m的方法和m的类型man。

	var sm superman //sm代表一个超人
	s = sm          //sm这个超人实现了s超人类的所有技能: fly，swim，walk，talk，所以可以把sm赋给s。 s这个接口类型的变量指向一个实现了s 4个方法的变量sm，sm的方法和sm的类型superman。

	fmt.Println() //打印一个空行

	fmt.Println("i.(T) type asertion (type conversion check) test")

	fmt.Println("\nT is a non-interface type:") //T是非接口类型的情况, i指向的动态类型一定要和T非接口的类型相同，则断言成功。因为h的动态类型是man，所以h.(superman)是断言失败的。s的动态类型是superman，所以s.(man)也是断言失败的。
	fmt.Printf("h.(man)          type asertion (type conversion check) is %T\n", h.(man))
	//fmt.Printf("h.(superman)   type asertion (type conversion check) is %T\n", h.(superman)) //panic: interface conversion: main.human is main.man, not main.superman

	fmt.Printf("s.(superman)     type assertion (type conversion check) is %T\n", s.(superman))
	//fmt.Printf("s.(man)        type assertion (type conversion check) is %T\n", s.(man)) //impossible type assertion: man does not implement superhuman (missing fly method)

	fmt.Println("\nT is a interface type:") //T是接口类型的情况， i指向的动态类型实现了T接口类型所拥有的方法，则断言成功。h没有实现superhuman类型所定义的fly()方法，所以h.(superhuman)是断言失败的。
	fmt.Printf("h.(human)        type asertion (type conversion check) is %T\n", h.(human))
	//fmt.Printf("h.(superhuman) type asertion (type conversion check) is %T\n", h.(superhuman)) //panic: interface conversion: main.man is not main.superhuman: missing method fly

	fmt.Printf("s.(superhuman)   type assertion (type conversion check) is %T\n", s.(superhuman))
	fmt.Printf("s.(human)        type assertion (type conversion check) is %T\n", s.(human))
}

package main

import "fmt"

func main() {
	var i interface{} = 100
	fmt.Println("i is", i)

	x := i.(int)               //interface{}类型的i指向100时，会把100的默认类型转换为int整型。
	fmt.Println("i.(int):", x) //100

	x, ok := i.(int)               //在上一步的基础上加入可选变量ok，用于判断类型断言是否成功。
	fmt.Println("i.(int):", x, ok) //100 true

	//y := i.([]int)              //i的默认类型是int，这里用[]int作为断言类型肯定会断言失败，同时这里只用了1个返回结果y，程序会直接进入panic。
	//fmt.Println("i.([]int)", y) //panic: interface conversion: interface {} is int, not []int

	y, ok := i.([]int)               //在上一步的基础上加入可选变量ok，用于判断类型断言是否成功。如果类型断言失败，则程序可以继续执行，不panic。
	fmt.Println("i.([]int):", y, ok) //[] false

	z, ok := i.(interface{})               //i的断言类型是interface{}时，因为interface{}没有任何方法, 可以理解为interface{}类型不用实现，或者i实现了interface{}类型。
	fmt.Println("i.(interface{}):", z, ok) //100 true

	fmt.Println()

	var j interface{} //j为interface{}类型的变量，j的默认值为nil
	fmt.Println("j is", j)

	m, ok := j.(int)               //测试j能否成功转换成int类型
	fmt.Println("j.(int):", m, ok) //0 false 转换失败

	n, ok := j.(interface{})               //测试j能否成功转换成interface{}类型
	fmt.Println("j.(interface{}):", n, ok) //<nil> false 转换失败
}

switch SimpleStmt; v := i.(type) {
case TypeA:
	...
case TypeB, TypeC:
	...
case nil:
	...
default:
	...
}

package main

import "fmt"

func main() {
	values := []interface{}{
		456, "abc", true, 0.33, int32(789),
		[]int{1, 2, 3}, map[int]bool{}, nil,
	}
	for _, x := range values {
		// Here, v is declared once, but it denotes
		// different variables in different branches.
		switch v := x.(type) {

		//case interface{}:
		//fmt.Println("\ninterface{} val: ", v)
		//fmt.Printf("interface{} type: %T\n", v)

		case []int: // a type literal
			fmt.Println("\nint slice:", v)
		case string: // one type name
			fmt.Println("\nstring:", v)
		case int, float64, int32: // multiple type names
			fmt.Println("\nnumber:", v)

		case bool:
			fmt.Println("\nbool:", v)

		case nil:
			fmt.Println("\nnil val: ", v)
			fmt.Printf("nil type: %T\n", v)

		default:
			fmt.Println("\nOthers val: ", v)
			fmt.Printf("Others type: %T\n", v)
		}
	}
}

package main

import "fmt"

type human interface {
	swim() error
	walk() error
	talk() error
}

type superhuman interface {
	fly() error
	swim() error
	walk() error
	talk() error
}

type man struct{}

func (man) swim() error {
	fmt.Println("Man can swim")
	return nil
}

func (man) walk() error {
	fmt.Println("Man can walk")
	return nil
}

func (man) talk() error {
	fmt.Println("Man can talk")
	return nil
}

type superman struct{}

func (superman) fly() error {
	fmt.Println("superman can fly")
	return nil
}

func (superman) swim() error {
	fmt.Println("superman can swim")
	return nil
}

func (superman) walk() error {
	fmt.Println("superman can walk")
	return nil
}

func (superman) talk() error {
	fmt.Println("superman can talk")
	return nil
}

//接口类型可以包裹其他接口类型，比如asian接口类型可以包含human接口类型，asian含有human拥有的所有方法。
//如果给asian再加上一个fly()的方法，那asian就成为超级亚洲人了。
type asian interface {
	human
	//superhuman //接口类型不能嵌套多个具有相同方法名的接口类型
	//asian //接口类型不能自己嵌套自己
	fly() error
}

//flyman实现了fly()方法。
type flyman struct{}

func (flyman) swim() error {
	fmt.Println("flyman can swim")
	return nil
}

func (flyman) walk() error {
	fmt.Println("flyman can walk")
	return nil
}

func (flyman) talk() error {
	fmt.Println("flyman can talk")
	return nil
}

func (flyman) fly() error {
	fmt.Println("Believe me I can fly, I am singing in the sky")
	return nil
}

func main() {

	var a asian      //a是超级亚洲人接口类型变量
	var s superhuman //s代表超人类接口类型变量
	var f flyman     //f是一个flyman类型的变量，flyman类型实现了asian接口类型的所有方法，flyman类型的变量f也具有flyman类型的所有方法。

	a = f
	s = f
	_, ok := a.(human) //human是接口类型，a实现了human接口类型的所有方法，所以a.(human)断言成功
	fmt.Println("a.(human): ", ok)

	_, ok = s.(human)  //同上
	fmt.Println("s.(human): ", ok)

	_, ok = a.(superhuman) //superhuman是接口类型，a实现了superhuman接口类型的所有方法(flyman会fly了)，所以a.(superhuman)断言成功
	fmt.Println("a.(superhuman): ", ok)

	_, ok = s.(superhuman)  //同上
	fmt.Println("s.(superhuman): ", ok)

	//_, ok = a.(man) //man是一个非接口类型，a的方法要和man的方法实现完全一致才能断言成功，man没有实现fly接口，所以a.(man)断言失败。 impossible type assertion: man does not implement asian (missing fly method)
	//fmt.Println("a.(man): ", ok)

	//_, ok = s.(man) //同上impossible type assertion:man does not implement superhuman (missing fly method)
	//fmt.Println("s.(man): ", ok)

	_, ok = a.(superman) //superman是一个非接口类型，a的动态类型是flyman，不是superman，所以a.(superman)断言失败
	fmt.Println("a.(superman): ", ok)

	_, ok = s.(superman) //同上
	fmt.Println("s.(superman): ", ok)

	_, ok = a.(flyman) //flyman是一个非接口类型，a的动态类型是flyman，所以a.(flyman)断言成功
	fmt.Println("a.(flyman): ", ok)

	_, ok = s.(flyman) //同上
	fmt.Println("s.(flyman): ", ok)
}

func main() {

	var a asian      //a是超级亚洲人接口类型变量
	var s superhuman //s代表超人类接口类型变量
	var f flyman     //f是一个flyman类型的变量，flyman类型实现了asian接口类型的所有方法，flyman类型的变量f也具有flyman类型的所有方法。
	var sm superman

	fmt.Println("a:", s, "s:", s, " a == s", a == s) //a: <nil> s: <nil>  a == s true. a 和 s的值均为nil, 符合条件1

	a = f
	s = f
	fmt.Println("a:", s, "s:", s, " a == s", a == s) //a: {} s: {}  a == s true. a 和 s均指向同一个变量f，符合条件2

	a = f
	s = sm
	fmt.Println("a:", s, "s:", s, " a == s", a == s) //a: {} s: {}  a == s false. f和sm虽然均有相同的方法实现，但是它们对于a和s来说属于不同的动态类型和动态值，所以比较结果不同， 不符合条件2。
}

package main

import "fmt"

func main() {

	//声明一个数据类型为int的双向通道变量bidirCh
	var bidirCh chan int // or bidirCh := chan int(nil)

	//声明一个数据类型为int的send only的单向通道变量sendOnlyCh
	var sendOnlyCh chan<- int

	//声明一个数据类型为int的receive only的单向通道变量receiveOnlyCh
	var receiveOnlyCh <-chan int

	fmt.Printf("bidirCh is nil? %t\n", bidirCh == nil)
	fmt.Printf("bidirCh type is: %#v\n\n", bidirCh)

	fmt.Printf("sendOnlyCh is nil? %t\n", sendOnlyCh == nil)
	fmt.Printf("sendOnlyCh type is: %#v\n\n", sendOnlyCh)

	fmt.Printf("receiveOnlyCh is nil? %t\n", receiveOnlyCh == nil)
	fmt.Printf("receiveOnlyCh type is: %#v\n", receiveOnlyCh)

	//chan int 型的双向通道的变量可以隐式的转换为chan<- int或<-chan int型的单向通道的变量
	sendOnlyCh = bidirCh    //也可显式地转换:  sendOnlyCh := (chan<- int)(bidirCh)
	receiveOnlyCh = bidirCh //也可显式地转换:  receiveOnlyCh := (<-chan int)(bidirCh)
}

package main

import "fmt"

func main() {

	//声明一个数据类型为int的双向通道变量bidirCh
	var bidirCh chan int // or bidirCh := chan int(nil)

	//声明一个数据类型为int的send only的单向通道变量sendOnlyCh
	var sendOnlyCh chan<- int

	//声明一个数据类型为int的receive only的单向通道变量receiveOnlyCh
	var receiveOnlyCh <-chan int

	//将bidircCh分配成一个无缓冲的双向通道
	bidirCh = make(chan int, 0) //或者bidirCh = make(chan int)

	//将sendOnlyCh分配成一个有20个整数缓冲的send only的通道
	sendOnlyCh = make(chan<- int, 20)

	//将receiveOnlyCh分配成一个有30个整数缓冲的receive only的通道
	receiveOnlyCh = make(<-chan int, 30)

	fmt.Printf("bidirCh is nil? %t\n", bidirCh == nil)
	fmt.Printf("sendOnlyCh is nil? %t\n", sendOnlyCh == nil)
	fmt.Printf("receiveOnlyCh is nil? %t\n\n", receiveOnlyCh == nil)

	fmt.Printf("bidirCh len %d cap:%d\n", len(bidirCh), cap(bidirCh))
	fmt.Printf("sendOnlyCh len %d cap:%d\n", len(sendOnlyCh), cap(sendOnlyCh))
	fmt.Printf("receiveOnlyCh len %d cap:%d\n\n", len(receiveOnlyCh), cap(receiveOnlyCh))

	//chan int 型的双向通道的变量可以隐式的转换为chan<- int或<-chan int型的单向通道的变量
	sendOnlyCh = bidirCh    //也可显式地转换:  sendOnlyCh := (chan<- int)(bidirCh)
	receiveOnlyCh = bidirCh //也可显式地转换:  receiveOnlyCh := (chan<- int)(bidirCh)

	//注意: 这时的sendOnlyCh和receiveOnlyCh均是由bidirCh转换而来，它们的容量cap已变成bidirCh的容量。
	fmt.Printf("sendOnlyCh len %d cap:%d\n", len(sendOnlyCh), cap(sendOnlyCh))
	fmt.Printf("receiveOnlyCh len %d cap:%d\n", len(receiveOnlyCh), cap(receiveOnlyCh))
}

package main

import (
	"fmt"
	"time"
)

func sender(ch chan<- int, s []int) {
	for _, v := range s {
		//fmt.Println("\nsend block")
		ch <- v
		fmt.Printf("send %d\n", v)
	}
}

func receiver(ch <-chan int) {
	for {
		//fmt.Println("\nrecv block")
		v := <-ch
		fmt.Printf("recv %d\n", v)
	}
}

func main() {

	//声明一个数据类型为int的双向通道变量bidirCh
	var bidirCh chan int // or bidirCh := chan int(nil)

	//为bidircCh分配一个无缓冲的双向通道
	bidirCh = make(chan int, 0) //或者bidirCh = make(chan int)

	s := []int{5, 4, 3, 2, 1, 0}

	//启动sender的goroutine
	go sender(bidirCh, s)

	//启动receiver的goroutine
	go receiver(bidirCh)

	//让main goroutine 延迟5秒退出，以便等待sender和receiver的goroutine完成。
	time.Sleep(time.Second * 5)
}

package main

import (
	"fmt"
	"time"
)

func sender(ch chan<- int, s []int) {

	for _, v := range s {
		//fmt.Println("\nsend block")
		ch <- v
		fmt.Printf("send %d\n", v)
	}
	close(ch)
	//close(ch) //item2 ❌ panic: close of closed channel
	//ch <- 99  //item3 ❌ panic: send on closed channel
}

func receiver(ch <-chan int) {
	for {
		//fmt.Println("\nrecv block")
		//close(ch) //item4 ❌ invalid operation: close(ch) (cannot close receive-only channel)
		v := <-ch
		fmt.Printf("recv %d\n", v)
	}
}

func main() {

	//声明一个通道数据类型为int的双向通道bidirCh
	var bidirCh chan int // or bidirCh := chan int(nil)

	//close(bidirCh) //item1 ❌ panic: close of nil channel
	//将bidircCh分配成一个无缓冲的双向通道
	bidirCh = make(chan int, 0) //或者bidirCh = make(chan int)

	s := []int{5, 4, 3, 2, 1, 0}

	//启动sender的goroutine
	go sender(bidirCh, s)

	//启动receiver的goroutine
	go receiver(bidirCh)

	//让main goroutine 延迟5秒退出，以便等待sender和receiver的goroutine完成。
	time.Sleep(time.Second * 5)
}

package main

import (
	"fmt"
	"time"
)

func sender(ch chan<- int, s []int) {

	for _, v := range s {
		//fmt.Println("\nsend block")
		ch <- v
		fmt.Printf("send %d\n", v)
	}
	close(ch)
	//close(ch) //item2 ❌ panic: close of closed channel
	//ch <- 99  //item3 ❌ panic: send on closed channel
}

func receiver(ch <-chan int) {
	for {
		//fmt.Println("\nrecv block")
		//close(ch) //item4 ❌ invalid operation: close(ch) (cannot close receive-only channel)
		v, ok := <-ch
		if ok == true {
			fmt.Printf("recv %d %t\n", v, ok)
		} else {
			break
		}
	}
}

func main() {

	//声明一个通道数据类型为int的双向通道bidirCh
	var bidirCh chan int // or bidirCh := chan int(nil)

	//close(bidirCh) //item1 ❌ panic: close of nil channel
	//将bidircCh分配成一个无缓冲的双向通道
	bidirCh = make(chan int, 0) //或者bidirCh = make(chan int)

	s := []int{5, 4, 3, 2, 1, 0}

	//启动sender的goroutine
	go sender(bidirCh, s)

	//启动receiver的goroutine
	go receiver(bidirCh)

	//让main goroutine 延迟5秒退出，以便等待sender和receiver的goroutine完成。
	time.Sleep(time.Second * 5)
}

package main

import (
	"fmt"
)

func sender(ch chan<- int, s []int) {

	for _, v := range s {
		ch <- v
		fmt.Printf("send %d\n", v)
	}
	close(ch)
}

func receiver(ch <-chan int, done chan<- string) {
	for {
		v, ok := <-ch
		if ok == true {
			fmt.Printf("recv %d %t\n", v, ok)
		} else {
			break
		}
	}
	done <- "**********************************"
}

func main() {

	var bidirCh chan int
	done := make(chan string, 0)

	bidirCh = make(chan int, 0)

	s := []int{5, 4, 3, 2, 1, 0}

	go sender(bidirCh, s)

	go receiver(bidirCh, done)

	//time.Sleep(time.Second * 5)
	//Replace time.Sleep() statement with <-done and
	//print the receiving string from done channel.
	fmt.Println(<-done)
}

package main

import "fmt"

func main() {

	s := make([]int, 10)

	//1. 创建： 创建一个缓冲为5的通道ch
	ch := make(chan int, 5)

	fmt.Printf("len(ch):%2d  cap(ch):%2d\n", len(ch), cap(ch))//len(ch): 0  cap(ch): 5

	//2. 写入： 往通道ch里发送数据
	ch <- 1
	ch <- 2
	ch <- 3
	ch <- 4
	ch <- 5

	//3.
	// 长度
	// 容量
	fmt.Printf("len(ch):%2d  cap(ch):%2d\n", len(ch), cap(ch))//len(ch): 0  cap(ch): 5

	//❌ ch <- 6 //通道已满(len(ch) == len(cap))，再像通道写入数据会产生错误：fatal error: all goroutines are asleep - deadlock!

	//4. 读取
	s[0] = <-ch
	s[1] = <-ch
	s[2] = <-ch
	s[3] = <-ch
	s[4] = <-ch

	fmt.Printf("len(ch):%2d  cap(ch):%2d\n", len(ch), cap(ch))//len(ch): 0  cap(ch): 5

	//❌ s[5] = <-ch //通道已空(len(ch) == 0)，再从通道读取数据会产生错误：fatal error: all goroutines are asleep - deadlock!

	fmt.Println(s)

	//8. 关闭
	close(ch)
}

M0
|
|
|
P0 <----等-待-队-列----G1--G2--G3--G4--G5---<----
|						|
运						|
|						|
行						|
|						|
G0 ->----回-到-等-待-队-列-------->--------->----

M0
|
|
|
G0(阻塞状态)
1. G0处于阻塞状态被绑定到M0上，M0、G0均与P0分离


M1
|
|
|
P0 <----等-待-队-列----G2--G3--G4--G5-------<----
|						|
运						|
|						|
行						|
|						|
G1 ->----回-到-等-待-队-列-------->--------->----
2. 调度器为G1重新分配了一个系统线程M1， P0执行等待队列中的其他goroutine


M1
|
|
|
P0 <----等-待-队-列----G3--G4--G5--G1--G0---<----
|						|
运						|
|						|
行						|
|						|
G2 ->----回-到-等-待-队-列-------->--------->----
3. G0阻塞完毕，重新回到P0的等待队列中


M0
|
|
|
4. M0被系统保存，以便后续使用。

package main

import (
	"log"
	"time"
)

func routineTest(s string, times int) {
	for i := 0; i < times; i++ {
		log.Println(s)
		time.Sleep(1 * time.Second)
	}
}

func main() {
	log.SetFlags(0)
	go routineTest("watching TV", 5)
	go routineTest("coding", 5)
	time.Sleep(5 * time.Second)
}

package main

import (
	"log"
	"sync"
	"time"
)

var wg sync.WaitGroup

func routineTest(s string, times int) {
	for i := 0; i < times; i++ {
		log.Println(s)
		time.Sleep(1 * time.Second)
	}
	wg.Done()
}

func main() {
	log.SetFlags(0)
	wg.Add(2)
	go routineTest("watching TV", 5)
	go routineTest("coding", 5)
	wg.Wait()
}

package main

import "fmt"

type myint int

func myfunc(mi *myint) {
	*mi = 3
}

func (mi *myint) mymethod() {
	*mi = 4
}

func main() {
	ch := make(chan int, 10)

	if true {
		fmt.Println("SimpleStmt1 空语句")
	}

	if ch <- 5; true {
		fmt.Println("SimpleStmt2 通道发送 ch <- 5")
	}

	if _, ok := <-ch; ok {
		fmt.Println("SimpleStmt2 通道接收 _, ok = <-ch", ok)
	}

	var ptr *int = new(int)
	*ptr = 5
	if *ptr++; true {
		fmt.Println("SimpleStmt3 加加减减 *ptr++", *ptr)
	}

	if *ptr--; true {
		fmt.Println("SimpleStmt3 加加减减 *ptr--", *ptr)
	}

	var i int
	if i = 1; true {
		fmt.Println("SimpleStmt4 赋值语句 i =", i)
	}

	if x := 1; true {
		fmt.Println("SimpleStmt5 短变量声明 x := ", x)
	}

	var mi myint
	if myfunc(&mi); mi > 0 {
		fmt.Println("SimpleStmt6 函数调用 myfunc(&mi), mi", mi)
	}

	if (&mi).mymethod(); mi > 0 {
		fmt.Println("SimpleStmt6 方法调用 (&mi).mymethod(), mi", mi)
	}
}

package main

import "fmt"

func main() {
	var i int = 0

	for i < 5 {
		fmt.Println(i)
		i++
	}
}

package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ {
		fmt.Println(i)
	}
}

package main

import "fmt"

func main() {
	var i int = 0
	fmt.Println("Remove InitStmt")
	for ; i < 5; i++ {
		fmt.Println(i)
	}
}

package main

import "fmt"

func main() {
	fmt.Println("Remove PostStmt")
	for i := 0; i < 5; {
		fmt.Println(i)
		i++
	}
}

package main

import "fmt"

func main() {
	var i int = 0
	fmt.Println("Remove InitStmt and PostStmt, reserve smeicolons")
	for ; i < 5;  {
		fmt.Println(i)
		i++
	}
}