const Home = os.GetEnv("HOME")

Go 语言预定义了这些常量： true 、 false 和 iota 。

const ( 
 Sunday = iota
 Monday 
 Tuesday 
 Wednesday 
 Thursday 
 Friday 
 Saturday 
 numberOfDays // 这个常量没有导出 
)

注意：

var v1 bool
v1 = true
v2 := (1 == 2) // v2也会被推导为bool类型

var b bool
b = 1 // 编译错误
b = bool(1) // 编译错误

var b bool
b = (1!=0) // 编译正确 
fmt.Println("Result:", b) // 打印结果为Result: true

var value2 int32
value1 := 64 // value1将会被自动推导为int类型
value2 = value1 // 编译错误

value2 = int32(value1) // 编译通过

var i int32
var j int64
i, j = 1, 2 
if i == j { // 编译错误
 fmt.Println("i and j are equal.") 
} 
if i == 1 || j == 2 { // 编译通过
 fmt.Println("i and j are equal.") 
}

var fvalue1 float32
fvalue1 = 12 
fvalue2 := 12.0 // 如果不加小数点，fvalue2会被推导为整型而不是浮点型

fvalue1 = fvalue2

而必须使用这样的强制类型转换：

fvalue1 = float32(fvalue2)

下面是一种推荐的替代方案：
import "math" 
// p为用户自定义的比较精度，比如0.00001 
func IsEqual(f1, f2, p float64) bool { 
 return math.Fdim(f1, f2) < p 
}

var value1 complex64 // 由2个float32构成的复数类型
value1 = 3.2 + 12i 
value2 := 3.2 + 12i // value2是complex128类型
value3 := complex(3.2, 12) // value3结果同 value2

var str string // 声明一个字符串变量
str = "Hello world" // 字符串赋值
ch := str[0] // 取字符串的第一个字符


fmt.Printf("The length of \"%s\" is %d \n", str, len(str))
fmt.Printf("The first character of \"%s\" is %c.\n", str, ch)


输出结果为：
The length of "Hello world" is 11 
The first character of "Hello world" is H.

str := "Hello world" // 字符串也支持声明时进行初始化的做法
str[0] = 'X' // 编译错误

编译器会报类似如下的错误：
cannot assign to str[0]

package main 
import "fmt" 
func modify(array [10]int) { 
 array[0] = 10 // 试图修改数组的第一个元素
 fmt.Println("In modify(), array values:", array) 
}

func main() { 
 array := [5]int{1,2,3,4,5} // 定义并初始化一个数组
 modify(array) // 传递给一个函数，并试图在函数体内修改这个数组内容
 fmt.Println("In main(), array values:", array) 
}

该程序的执行结果为：
In modify(), array values: [10 2 3 4 5] 
In main(), array values: [1 2 3 4 5]

package main 
import "fmt" 
func main() { 
 // 先定义一个数组
 var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
 // 基于数组创建一个数组切片
 var mySlice []int = myArray[:5] 
 fmt.Println("Elements of myArray: ") 
 for _, v := range myArray { 
 fmt.Print(v, " ") 
 } 
 fmt.Println("\nElements of mySlice: ") 
 for _, v := range mySlice { 
 fmt.Print(v, " ") 
 } 
 fmt.Println() 
}

运行结果为：
Elements of myArray: 
1 2 3 4 5 6 7 8 9 10 
Elements of mySlice: 
1 2 3 4 5

// 基于myArray的所有元素创建数组切片：
mySlice = myArray[:]

// 基于myArray的前5个元素创建数组切片：
mySlice = myArray[:5]

// 基于从第5个元素开始的所有元素创建数组切片：
mySlice = myArray[5:]

// 创建一个初始元素个数为5的数组切片，元素初始值为0：
mySlice1 := make([]int, 5)

// 创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：
mySlice2 := make([]int, 5, 10)

// 直接创建并初始化包含5个元素的数组切片：
mySlice3 := []int{1, 2, 3, 4, 5}

mySlice2 := []int{8, 9, 10}
// 给mySlice后面添加另一个数组切片
mySlice = append(mySlice, mySlice2...)

func SliceLenCap() {
	mySlice := make([]int, 5, 10)
	for i := range mySlice {
		mySlice[i] = i
	}
	fmt.Println("len(mySlice):", len(mySlice))
	fmt.Println("cap(mySlice):", cap(mySlice))

	fmt.Println("可以从尾端给mySlice加上3个元素:5,6,7")
	mySlice = append(mySlice, 5, 6, 7)
	for _, v := range mySlice {
		fmt.Print(v, " ")
	}
	fmt.Println()

	fmt.Println("给mySlice后面添加另一个数组切片")
	mySlice2 := []int{8, 9, 10}
	// 给mySlice后面添加另一个数组切片
	mySlice = append(mySlice, mySlice2...)
	for _, v := range mySlice {
		fmt.Print(v, " ")
	}
	fmt.Println()
}

func MapCase() {
	var personDB map[string]PersonInfo
	personDB = make(map[string]PersonInfo)

	// 往这个map里插入几条数据
	personDB["100001"] = PersonInfo{"100001", "张三", "Room 203"}
	personDB["100002"] = PersonInfo{"100002", "李四", "Room 204"}

	// 从这个map查找键为"100001"的信息
	person, ok := personDB["100001"]
	// ok 是一个返回的bool型，返回true表示找到了对应的数据
	if ok {
		fmt.Println("Found person", person.Name, "with ID 100001.")
	} else {
		fmt.Println("Cannot find person with ID 100001.")
	}
}

var myMap map[string] PersonInfo

其中，myMap是声明的map变量名，string是键的类型，PersonInfo则是其中所存放的值类型。

（2）创建

可以使用Go语言内置的函数make()来创建一个新map

myMap = make(map[string] PersonInfo)

也可以选择是否在创建时指定该map的初始存储能力，下面的例子创建了一个初始存储能力为100的map:

myMap = make(map[string] PersonInfo, 100)

创建并初始化map代码如下：

myMap = map[string] PersonInfo{ 
 "1234": PersonInfo{"1", "Jack", "Room 101,..."}, 
}

（3）元素赋值

// 是将键和值用下面的方式对应起来即可：
myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}

（4）元素删除

// Go语言提供了一个内置函数delete()，用于删除容器内的元素
delete(myMap, "1234")

（5）元素查找

value, ok := myMap["1234"] 
if ok { // 找到了
 // 处理找到的value 
}