本篇主要是讲述了数组和切片、Map的初始化方式与基本使用、重点阐述了如何使用Map实现Set、用Map实现工厂模式，以及字符串的使用，字符串常用API、Unicode与UTF8的关系！

数组和切片

go
func TestArray01(t *testing.T)  {
	//声明并初始化为默认值
	var a [3]int
	a[0] = 1

	b := [3] int {11, 22, 33}
	c := [2][2] int {{11, 22}, {33, 44}}

	for _,data := range b{
		t.Log(data)
	}
	for _,data := range c{
		t.Log(data)
	}
}

func TestArraySection(t *testing.T){
	arr := [...]int{11, 22, 33, 44}
	arr_sec := arr[:3] //取前三个元素
	t.Log(arr_sec)
	arr_sec = arr[3:] //取下标为3的后面的所有元素
	t.Log(arr_sec)
}

其实切片的内部结构和Buffer的结构是差不多的，切片的使用:

make函数相当于申请空间、并且可以控制多少空间初始化！

go
package slice_test

import "testing"

func TestSlice(t *testing.T)  {
	var s0 []int //切片的声明
	t.Log(len(s0), cap(s0)) //0 0
	s0 = append(s0, 1)
	t.Log(len(s0), cap(s0)) //1 1

	s1 := []int{1, 2, 3, 4}
	t.Log(len(s1), cap(s1)) //4 4

	s2 := make([]int, 3, 5) 
	t.Log(len(s2), cap(s2)) //4 4

	s2 = append(s2, 1)
	t.Log(len(s2), cap(s2)) //4 4
	t.Log(s2[0], s2[1], s2[2], s2[3])
}

切片如何扩容呢？

go
func TestSliceGrowing(t *testing.T)  {
	s := []int{}
	for i:=0; i<10; i++{
		s = append(s, i)
		t.Log(len(s), cap(s))
	}
}

可以看出来，每次增长二倍的关系，所以就解释了为什么每次append之后都要接收append的返回值，因为go的内部实现就是内存区域Copy的形式，所以随时可能返回新的内存地址，所以需要接收！

go
func TestSliceShareMemory(t *testing.T){
	year := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}

	Q2 := year[3:6]
	t.Log(Q2, len(Q2), cap(Q2)) //[Apr May Jun] 3 9
	summer := year[5:8]
	t.Log(summer, len(summer), cap(summer)) //[Jun Jul Aug] 3 7
	summer[0] = "UnKnow"
	t.Log(Q2, len(Q2), cap(Q2)) //[Apr May UnKnow] 3 9
}

数组和切片的比较：数组不可伸缩、切片可以伸缩；相同维数且相同长度的数组才是可以比较的，切片是不可以比较的，下面的代码会编译不通过：

go
func TestSliceCompare(t *testing.T){
	a := []int{1, 2 , 3, 4}
	b := []int{1, 2 , 3, 4}
	if a == b{ //error
		t.Log("equal")
	}
}

Map的基本使用

go
package map_test

import "testing"

func TestInitMap(t *testing.T)  {
	m1 := map[string]int{"one":1, "two":2, "three":3}
	t.Log(m1, len(m1)) //map[one:1 three:3 two:2] 3

	m2 := map[int]int{}
	m2[4] = 16
	t.Log(m2, len(m2)) //map[4:16] 1

	m3 := make(map[int]int, 10)
	t.Log(m3, len(m3)) //map[] 0
}

Map的遍历

go
func TestForEachMap(t *testing.T)  {
	m1 := map[string]int{"one":1, "two":2, "three":3}
	for k, v := range m1{
		t.Log(k, "=", v)
	}
}

Map与工厂模式

Map的Value可以是一个方法，因为在Golang中，方法也是一种类型，可以当做参数传递的，与Dock type接口方式一起，可以方便的实现单一方法对象的工厂模式

go
func TestMapWithFunValue(t *testing.T)  {
	//Key是整型、Value是方法类型
	m := map[int] func(op int) int {}

	m[1] = func(op int) int {
		return op
	}

	m[2] = func(op int) int {
		return op * op
	}

	m[3] = func(op int) int {
		return op * op * op
	}

	t.Log(m[1](2 ), m[2](2), m[3](2)) //2 4 8
}

Map实现Set

Go内置集合没有Set实现，可以map[type]bool

1、元素的唯一性

2、基本操作

• 添加元素
• 判断元素是否存在
• 删除元素
• 元素个数

go
func TestMapForSet(t *testing.T)  {
	mySet := map[int]bool{}
	//1、添加元素
	mySet[1] = true

	//n := 3 //3 is not existing
	n := 1  //1 is existing

	//2、判断一个元素是否存在
	if mySet[n]{
		t.Logf("%d is existing", n) //1 is existing
	}else{
		t.Logf("%d is not existing", n)
	}

	//3、获取Set的长度
	mySet[2] = true
	mySet[3] = true
	t.Log("len =", len(mySet)) //len = 3

	//4、从Set删除元素
	delete(mySet, 1)
	n = 1
	if mySet[n]{
		t.Logf("%d is existing", n)
	}else{
		t.Logf("%d is not existing", n) //1 is not existing
	}
}

字符串

与其他主要编程语言的差异：

string 是数据类型，不是引用或指针类型

string 是只读的byte slice, len 函数可以它所包含的byte数

string 的byte数组可以存放任何数据

string实际上就是一个不可变的切片

go
func TestString(t *testing.T)  {
	var s string
	t.Log(s) //初始化默认值""
	s = "hello"
	t.Log(len(s))

	//s[3] = 'c' error string不可变
	s = "\xE4\xB8\xA5" //可以存储任意二进制数据
	t.Log(s, len(s)) //严
	s = "中国"
	t.Log(len(s)) //len求的是字节数
}

Unicode与UTF8

1、Unicode是一种字符集（code point）

2、UTF8是Unicode的存储实现（转为字节序列的规则）

Unicode为世界上所有字符都分配了一个唯一的数字编号，这个编号范围从 0x000000 到 0x10FFFF(十六进制)，有110多万，每个字符都有一个唯一的Unicode编号，这个编号一般写成16进制， Unicode就相当于一张表，建立了字符与编号之间的联系，而UTF8是具体实现， 在UTF8中编号小的使用的字节就少，编号大的使用的字节就多。使用的字节个数从1到4个不等。

rune函数

在Go当中 string底层是用byte数组存的，并且是不可以改变的。fmt.Println(len("Go编程")) 输出结果应该是8因为中文字符是用3个字节存的， len(string(rune('编')))的结果是3 ，如果想要获得我们想要的情况的话，需要先转换为rune切片再使用内置的len函数： fmt.Println(len([]rune(s))) 结果就是4了。 所以用string存储unicode的话，如果有中文，按下标是访问不到的，因为你只能得到一个byte。 要想访问中文的话，还是要用rune切片，这样就能按下标访问。

go
func TestString(t *testing.T)  {
    s := "中"
	t.Log(len(s)) //3

	c := []rune(s)

	t.Logf("中 unicode %x", c[0]) //中 unicode 4e2d
	t.Logf("中 UTF8 %x", s) //中 UTF8 e4b8ad
}

常用的字符串处理函数： strings包： https://golang.org/pkg/strings

strconv包 https://golang.org/pkg/strconv

go
func TestStringFunc(t *testing.T)  {
	//切割字符串
	s := "A,B,C"
	split := strings.Split(s, ",")
	for _, ch := range split{
		t.Log(ch)
	}

	//连接字符串数组的元素
	t.Log(strings.Join(split, "-"))

	//字符串与数字的转换
	s = strconv.Itoa(250)
	t.Logf("s = %s", s)

	num := "100"
	//返回两个值，err代表是否发生错误
	if i, err := strconv.Atoi(num); err == nil{
		t.Log(100 + i)
	}
}