1.数组的声明：

package main

import (
	"fmt"
)

func main() {
	//声明一个包含 5 个元素的整型数组，默认初始化
	var array [5]int
	fmt.Println(array[1])
	array[1] = 1

	//用具体值初始化每个元素
	array2 := [5]int{10, 20, 30, 40, 50}
	fmt.Println(array[1])
	array2[1] = 1

	// 容量由初始化值的数量决定
	array3 := [...]int{10, 20, 30, 40, 50}
	fmt.Println(array[1])
	array3[0] = 1
	//声明包含 5 个元素的指向整数的数组
	array4 := [5]*int{0: new(int), 1: new(int)}
	//用整型指针初始化索引为 0 和 1 的数组元素
	*array4[0] = 10

	//---------------------------
	// 声明第一个包含 5 个元素的字符串数组
	var array5 [5]string
	array5[1] = "123"
	// 声明第二个包含 5 个元素的字符串数组
	// 用颜色初始化数组
	array6 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}
	array6[0] = "test"
	// 把 array2 的值复制到 array1
	array5 = array6
	


}

2.编译器会阻止类型不同的数组互相赋值

// 声明第一个包含 4 个元素的字符串数组
var array1 [4]string
// 声明第二个包含 5 个元素的字符串数组
// 使用颜色初始化数组
array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}
// 将 array2 复制给 array1
array1 = array2

3.数组的传递

根据内存和性能来看，在函数间传递数组是一个开销很大的操作。在函数之间传递变量时，
总是以值的方式传递的。如果这个变量是一个数组，意味着整个数组，不管有多长，都会完整复
制，并传递给函数。
为了考察这个操作，我们来创建一个包含 100 万个 int 类型元素的数组。在 64 位架构上，
这将需要 800 万字节，即 8 MB 的内存。如果声明了这种大小的数组，并将其传递给函数，会发
生什么呢？如代码清单 4-14 所示。
代码清单 4-14 使用值传递，在函数间传递大数组

// 声明一个需要 8 MB 的数组
var array [1e6]int
// 将数组传递给函数 foo
foo(array)
// 函数 foo 接受一个 100 万个整型值的数组
func foo(array [1e6]int) {
...
}

// 分配一个需要 8 MB 的数组
var array [1e6]int
// 将数组的地址传递给函数 foo
foo(&array)
// 函数 foo 接受一个指向 100 万个整型值的数组的指针
func foo(array *[1e6]int) {
...
}