Go 其二 数组与切片
艺多不压身，学习一下最近蛮火的Go语言，整理一下笔记。相关Code和笔记也放到了Git上，传送门。
数组的声明
var a [3] int //声明并初始化为默认零值
a[0] = 1
b := [3]int{1,2,3} //声明同时初始化
c := [2][2]int{{1,2},{3,4}} //多维数组初始化
Go语言中定义的变量一定要使用，否则会报错，但如果只是想使用foreach的写法，可以使用 _ 来占位.
//foreach的写法, idx即为数组的索引的值
for idx, e:= range arr2 {
t.Log(idx, e)
}
//Go语言中定义的变量一定要使用，所以下面的写法会报错 idx declared but not used
// for idx, e:= range arr2 {
// t.Log(e)
// }
//如果只是想使用foreach的写法，可以使用 _ 来占位
for _, e:= range arr2 {
t.Log(e)
}
数组截取
a[开始索引(包含)， 结束索引(不包含)]
a := [...] int {1,2,3,4,5}
a[1:2] // 2
a[1:3] // 2,3
a[1:len(1)] // 2, 3, 4, 5
a[1:] //2, 3, 4, 5 //从索引1开始一直到末尾
a[:3] //1,2,3 //从索引0开始，一直到索引为3的位置，不包含索引为3的值
---------------------------------------------------------------
切片
切片在别的语言中不一定有，比如c#
使用起来像是可变长数组
切片内部结构
实际上是一个结构体，包含三个元素
1.指针，指向一片连续的存储空间（一个数组）ptr
2.切片内的元素个数 len
3.指针指向的这个数组的长度，容量 cap
//与声明数组很类似，区别是没有指定长度！例如
var s0 []int
利用len()方法来获得切片内元素个数
利用cap()方法来获得切片空间大小
利用append(s0, 1)来填充切片
使用make方法来声明长度和容量不同的切片 例如
//这里s2长度为3，但容量为5
s2 := make([]int, 3, 5)
其中len个元素会被初始化为默认值0，未初始化元素不可访问
切片本质上是共享的存储结构,注意这里的共享指的是由同一个切片“派生”出的其他切片或数组，例如
year := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}
q2 := year[3:6]
summer := year[5:8]
year,q2,summer是共享存储空间的
而反之，如
a := []int{1,2,3,4}
b := []int{1,2,3,4}
虽然初始的值相同，但其实是不共享存储空间的
---------------------------------------------------------------
数组 VS 切片
1. 容量是否可以伸缩，数组不可以，切片可以
2. 是否可以进行比较，数组可以与数组比较，切片与切片之间不可以比较
附录：
数组相关Code:
package array_test
import "testing"
func TestArrayInit(t *testing.T){
var arr [3]int
t.Log(arr[1],arr[2])
arr1 := [4]int{1,2,3,4}
//不指定长度且初始化时可以用[...]
arr2 := [...]int{1,2,3,4,5}
arr1[1] = 9
t.Log(arr1[1], arr1[3])
t.Log(arr2[2])
}
func TestArrayTraval(t *testing.T){
arr2 := [...]int{1,2,3,4,5}
for i:= 0; i < len(arr2); i++{
t.Log(arr2[i])
}
//foreach的写法, idx即为数组的索引的值
for idx, e:= range arr2 {
t.Log(idx, e)
}
//Go语言中定义的变量一定要使用，所以下面的写法会报错 idx declared but not used
// for idx, e:= range arr2 {
// t.Log(e)
// }
//如果只是想使用foreach的写法，可以使用 _ 来占位
for _, e:= range arr2 {
t.Log(e)
}
}
func TestArraySection(t *testing.T){
arr3 := [...] int{1,2,3,4,5}
arr3_sec := arr3[:3]
t.Log(arr3_sec)
arr3_sec2 := arr3[3:]
t.Log(arr3_sec2)
}
切片相关code:
package slice_test
import "testing"
func TestSliceInit(t *testing.T){
//与声明数组很类似，区别是没有指定长度！
var s0 []int
t.Log(len(s0), cap(s0))
s0 = append(s0, 1)
t.Log(len(s0), cap(s0))
//初始化
s1 := []int{1,2,3,4}
t.Log(len(s1), cap(s1))
//这里s2长度为3，但容量为5
s2 := make([]int, 3, 5)
t.Log(len(s2), cap(s2))
//这里会报错，因为后两个元素会越界
//t.Log(s2[0],s2[1],s2[2],s2[3],s2[4])
t.Log(s2[0],s2[1],s2[2])
s2 = append(s2, 1)
t.Log(s2[0],s2[1],s2[2],s2[3])
}
func TestSliceGrowing(t *testing.T){
s:=[]int{}
for i:=0; i<10; i++{
s = append(s, i)
t.Log(len(s), cap(s))
}
//输出结果
/*
TestSliceGrowing: slice_test.go:30: 1 1
TestSliceGrowing: slice_test.go:30: 2 2
TestSliceGrowing: slice_test.go:30: 3 4
TestSliceGrowing: slice_test.go:30: 4 4
TestSliceGrowing: slice_test.go:30: 5 8
TestSliceGrowing: slice_test.go:30: 6 8
TestSliceGrowing: slice_test.go:30: 7 8
TestSliceGrowing: slice_test.go:30: 8 8
TestSliceGrowing: slice_test.go:30: 9 16
TestSliceGrowing: slice_test.go:30: 10 16
*/
//每次不够放的适合，都会将上次的扩展为之前的两倍，因此要使用类似于s2 = append(s2, 1) 因为是新的空间给s2，并将原来的数据拷贝过去。
}
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))
//输出结果为
//TestSliceShareMemory: slice_test.go:53: [Apr May Jun] 3 9,容量是直接到末尾的，所以是9.
summer := year[5:8]
t.Log(summer, len(summer), cap(summer))
summer[0] = "Unkonw"
t.Log(summer, len(summer), cap(summer))
t.Log(q2, len(q2), cap(q2))
//输出结果为
/*
TestSliceShareMemory: slice_test.go:60: [Unkonw Jul Aug] 3 7
TestSliceShareMemory: slice_test.go:61: [Apr May Unkonw] 3 9
*/
//由于是共享的存储空间，因此summer的改动同时影响到了q2的值.
}
func TestSliceComparing(t *testing.T){
a := []int{1,2,3,4}
b := []int{1,2,3,4}
//会报错，nvalid operation: a == b (slice can only be compared to nil)
// if(a == b){
// t.Log("Can Compare")
// }
t.Log(a[2])
t.Log(b[2])
b[2] = 9
t.Log(a[2])
t.Log(b[2])
}
