数据（array）与切片（slice）
数组声明：
= "[" ArrayLength "]" ElementType .
var a [32] int
var b [3][5] int
在Go和C中，数组的工作方式有几个重要的差别。在Go中，
（1）数组是值类型。将一个数组赋值给另一个，会拷贝所有的元素。
（2） 如果你给函数传递一个数组，其将收到一个数组的拷贝，而不是它的指针。
（3）数组的大小是其类型的一部分，类型[10]int和[20]int是不同的。数组长度在声明后，就不可更改。
切片声明：
SliceType = "[" "]" ElementType .
var a []int
没有初始化的slice为nil。
切片（slice）对数组进行封装，实际上，切片可以看成大小可以动态变化的数组，这一点类似C++中std::vector。就像std::vector在实际C++编程中大量使用一样，Go中大多数的数组编程都是通过切片完成，而不是简单数组。
一般来说，有两种方式来初始化切片：
（1）通过数组
var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
var mySlice []int = myArray[:5]
（2）通过make
make([]T, length, capacity)
创建一个初始长度为5，容量为10为切片，切片的每个元素都为0：
slice1 := make([]int, 5, 10)
创建一个长度为5的切片，并初始化切片的每个元素：
slice2 := []int{1, 2, 3, 4, 5}
对于切片，最重要的特点就是长度是可变的：
slice2 := []int{1, 2, 3, 4, 5}
fmt.Println("slice:", slice2)
slice2 = append(slice2, 6)
fmt.Println("slice:", slice2)
slice: [1 2 3 4 5]
slice: [1 2 3 4 5 6]
函数append是GO专门为切片增加元素而提供的一个内建函数。
切片持有对底层数组的引用，如果你将一个切片赋值给另一个，二者都将引用同一个数组。如果函数接受一个切片作为参数，那么其对切片的元素所做的改动，对于调用者是可见的，好比是传递了一个底层数组的指针。
func (f *File) Read(b []byte) (n int, err error)
这个os.File的Read方法，它接受一个切片参数，切片中的长度已经设定了要读取的数据的上限。对于C/C++，需要同时提供一个缓冲区的指针，和缓冲区的大小：
int read(File* f, char* buf, int len)
从这里可以看到，GO的写法要简单一些。
切片（数组）的遍历
在go语言中，遍历切片或者数组，有两种方式：
传统方式：
for i := 0; i &len(mySlice); i++ {
fmt.Println("mySlice[", i, "] =", mySlice[i])
使用range表达式
range表达式有两个返回值，第一个是索引，第二个是元素的值：
for i, v := range mySlice {
fmt.Println("mySlice[", i, "] =", v)
使用range让代码更加简洁，所以在go编程中也更加常用。
阅读(...) 评论()一、数组　
与其他大多数语言类似，Go语言的数组也是一个元素类型相同的定长的序列。
（1）数组的创建。
数组有3种创建方式：[length]Type　、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN}　如下：
复制代码&代码如下:
func test5() {&&& var iarray1 [5]int32&&& var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5}&&& iarray3 := [5]int32{1, 2, 3, 4, 5}&&& iarray4 := [5]int32{6, 7, 8, 9, 10}&&& iarray5 := [...]int32{11, 12, 13, 14, 15}&&& iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}&&& fmt.Println(iarray1)&&& fmt.Println(iarray2)&&& fmt.Println(iarray3)&&& fmt.Println(iarray4)&&& fmt.Println(iarray5)&&& fmt.Println(iarray6)}
[0 0 0 0 0][1 2 3 4 5][1 2 3 4 5][6 7 8 9 10][11 12 13 14 15][[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]
我们看数组 iarray1，只声明，并未赋值，Go语言帮我们自动赋值为0。再看 iarray2 和 iarray3 ，我们可以看到，Go语言的声明，可以表明类型，也可以不表明类型，var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全没问题的。
（2）数组的容量和长度是一样的。cap() 函数和 len() 函数均输出数组的容量（即长度）。如：
复制代码&代码如下:
func test6() {&&& iarray4 := [5]int32{6, 7, 8, 9, 10}&&& fmt.Println(len(iarray4))&&& fmt.Println(cap(iarray4))}
输出都是5。
（3）使用：
复制代码&代码如下:
func test7() {&&& iarray7 := [5]string{"aaa", `bb`, "可以啦", "叫我说什么好", "()"}&&& fmt.Println(iarray7)&&& for i := range iarray7 {&&&&&&& fmt.Println(iarray7[i])&&& }}
Go语言中，切片是长度可变、容量固定的相同的元素序列。Go语言的切片本质是一个数组。容量固定是因为数组的长度是固定的，切片的容量即隐藏数组的长度。长度可变指的是在数组长度的范围内可变。
（1）切片的创建。
切片的创建有4种方式：
1）make ( []Type ,length, capacity )
2)& make ( []Type, length)
3) []Type{}
4) []Type{value1 , value2 , ... , valueN }
从3)、4)可见，创建切片跟创建数组唯一的区别在于 Type 前的“ [] ”中是否有数字，为空，则代表切片，否则则代表数组。因为切片是长度可变的。如下是创建切片的示例：
复制代码&代码如下:
func test8() {&&& slice1 := make([]int32, 5, 8)&&& slice2 := make([]int32, 9)&&& slice3 := []int32{}&&& slice4 := []int32{1, 2, 3, 4, 5}&&& fmt.Println(slice1)&&& fmt.Println(slice2)&&& fmt.Println(slice3)&&& fmt.Println(slice4)}
[0 0 0 0 0][0 0 0 0 0 0 0 0 0][][1 2 3 4 5]
如上，创造了4个切片，3个空切片，一个有值的切片。
（2）切片与隐藏数组：
一个切片是一个隐藏数组的引用，并且对于该切片的切片也引用同一个数组。如下示例，创建了一个切片 slice0，并根据这个切片创建了2个切片 slice1 和 slice2：
复制代码&代码如下:
func test9() {&&& slice0 := []string{"a", "b", "c", "d", "e"}&&& slice1 := slice0[2 : len(slice0)-1]&&& slice2 := slice0[:3]&&& fmt.Println(slice0, slice1, slice2)&&& slice2[2] = "8"&&& fmt.Println(slice0, slice1, slice2)}
[a b c d e] [c d] [a b c][a b 8 d e] [8 d] [a b 8]可见，切片slice0 、 slice1 和 slice2是同一个底层数组的引用，所以slice2改变了，其他两个都会变。
（3）遍历、修改切片：
复制代码&代码如下:
func test10() {&&& slice0 := []string{"a", "b", "c", "d", "e"}&&& fmt.Println("\n~~~~~~元素遍历~~~~~~")&&& for _, ele := range slice0 {&&&&&&& fmt.Print(ele, " ")&&&&&&& ele = "7"&&& }&&& fmt.Println("\n~~~~~~索引遍历~~~~~~")&&& for index := range slice0 {&&&&&&& fmt.Print(slice0[index], " ")&&& }&&& fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")&&& for index, ele := range slice0 {&&&&&&& fmt.Print(ele, slice0[index], " ")&&& }&&& fmt.Println("\n~~~~~~修改~~~~~~")&&& for index := range slice0 {&&&&&&& slice0[index] = "9"&&& }&&& fmt.Println(slice0)}
如上，前三种循环使用了不同的for range循环，当for后面，range前面有2个元素时，第一个元素代表索引，第二个元素代表元素值，使用 “_” 则表示忽略，因为go语言中，未使用的值会导致编译错误。
只有一个元素时，该元素代表索引。
只有用索引才能修改元素。如在第一个遍历中，赋值ele为7，结果没有作用。因为在元素遍历中，ele是值传递，ele是该切片元素的副本，修改它不会影响原本值，而在第四个遍历——索引遍历中，修改的是该切片元素引用的值，所以可以修改。
~~~~~~元素遍历~~~~~~a b c d e&~~~~~~索引遍历~~~~~~a b c d e&~~~~~~元素索引共同使用~~~~~~aa bb cc dd ee&~~~~~~修改~~~~~~[9 9 9 9 9]
（4）、追加、复制切片：
复制代码&代码如下:
func test11() {&&& slice := []int32{}&&& fmt.Printf("slice的长度为：%d,slice为：%v\n", len(slice), slice)&&& slice = append(slice, 12, 11, 10, 9)&&& fmt.Printf("追加后，slice的长度为：%d,slice为：%v\n", len(slice), slice)&&& slicecp := make([]int32, (len(slice)))&&& fmt.Printf("slicecp的长度为：%d,slicecp为：%v\n", len(slicecp), slicecp)&&& copy(slicecp, slice)&&& fmt.Printf("复制赋值后，slicecp的长度为：%d,slicecp为：%v\n", len(slicecp), slicecp)}
追加、复制切片，用的是内置函数append和copy，copy函数返回的是最后所复制的元素的数量。
（5）、内置函数append
内置函数append可以向一个切片后追加一个或多个同类型的其他值。如果追加的元素数量超过了原切片容量，那么最后返回的是一个全新数组中的全新切片。如果没有超过，那么最后返回的是原数组中的全新切片。无论如何，append对原切片无任何影响。如下示例：
复制代码&代码如下:
func test12() {&&& slice := []int32{1, 2, 3, 4, 5, 6}&&& slice2 := slice[:2]&&& _ = append(slice2, 50, 60, 70, 80, 90)&&& fmt.Printf("slice为：%v\n", slice)&&& fmt.Printf("操作的切片：%v\n", slice2)&&& _ = append(slice2, 50, 60)&&& fmt.Printf("slice为：%v\n", slice)&&& fmt.Printf("操作的切片：%v\n", slice2)}
如上，append方法用了2次，结果返回的结果完全不同，原因是第二次append方法追加的元素数量没有超过 slice 的容量。而无论怎样，原切片slice2都无影响。结果：
slice为：[1 2 3 4 5 6]操作的切片：[1 2]slice为：[1 2 50 60 5 6]操作的切片：[1 2]
阅读(...) 评论()Go语言切片的用法和本质
Go的切片类型为处理同类型数据序列提供一个方便而高效的方式。 切片有些类似于其他语言中的数组，但是有一些不同寻常的特性。 本文将深入切片的本质，并讲解它的用法。
Go的切片是在数组之上的抽象数据类型，因此在了解切片之前必须要先理解数组。
数组类型定义了长度和元素类型。例如，[4]int类型表示一个四个整数的数组。 数组的长度是固定的，长度是数组类型的一部分（[4]int和[5]int是完全不同的类型）。 数组可以以常规的索引方式访问，表达式s[n]访问数组的第 n 个元素。
var a [4]int
数组不需要显式的初始化；数组的零值是可以直接使用的，数组元素会自动初始化为其对应类型的零值：
// a[2] == 0, int 类型的零值
类型[4]int对应内存中四个连续的整数：
Go的数组是值语义。一个数组变量表示整个数组，它不是指向第一个元素的指针（不像 C 语言的数组）。 当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。 （为了避免复制数组，你可以传递一个指向数组的指针，但是数组指针并不是数组。） 可以将数组看作一个特殊的struct，结构的字段名对应数组的索引，同时成员的数目固定。
数组的字面值像这样：
b := [2]string{&Penn&, &Teller&}
当然，也可以让编译器统计数组字面值中元素的数目：
b := [...]string{&Penn&, &Teller&}
这两种写法，b都是对应[2]string类型。
数组虽然有适用它们的地方，但是数组不够灵活，因此在Go代码中数组使用的并不多。 但是，切片则使用得相当广泛。切片基于数组构建，但是提供更强的功能和便利。
切片类型的写法是[]T，T是切片元素的类型。和数组不同的是，切片类型并没有给定固定的长度。
切片的字面值和数组字面值很像，不过切片没有指定元素个数：
letters := []string{&a&, &b&, &c&, &d&}
切片可以使用内置函数make创建，函数签名为：
func make([]T, len, cap) []T
其中T代表被创建的切片元素的类型。函数make接受一个类型、一个长度和一个可选的容量参数。 调用make时，内部会分配一个数组，然后返回数组对应的切片。
var s []byte
s = make([]byte, 5, 5)
// s == []byte{0, 0, 0, 0, 0}
当容量参数被忽略时，它默认为指定的长度。下面是简洁的写法：
s := make([]byte, 5)
可以使用内置函数len和cap获取切片的长度和容量信息。
len(s) == 5
cap(s) == 5
接下来的两个小节将讨论长度和容量之间的关系。
切片的零值为nil。对于切片的零值，len和cap都将返回0。
切片也可以基于现有的切片或数组生成。切分的范围由两个由冒号分割的索引对应的半开区间指定。 例如，表达式b[1:4]创建的切片引用数组b的第1到3个元素空间（对应切片的索引为0到2）。
b := []byte{'g', 'o', 'l', 'a', 'n', 'g'}
// b[1:4] == []byte{'o', 'l', 'a'}, sharing the same storage as b
切片的开始和结束的索引都是可选的；它们分别默认为零和数组的长度。
// b[:2] == []byte{'g', 'o'}
// b[2:] == []byte{'l', 'a', 'n', 'g'}
// b[:] == b
下面语法也是基于数组创建一个切片：
x := [3]string{&Лайка&, &Белка&, &Стрелка&}
s := x[:] // a slice referencing the storage of x
切片的内幕
一个切片是一个数组片段的描述。它包含了指向数组的指针，片段的长度， 和容量（片段的最大长度）。
前面使用make([]byte, 5)创建的切片变量s的结构如下：
长度是切片引用的元素数目。容量是底层数组的元素数目（从切片指针开始）。 关于长度和容量和区域将在下一个例子说明。
我们继续对s进行切片，观察切片的数据结构和它引用的底层数组：
s = s[2:4]
切片操作并不复制切片指向的元素。它创建一个新的切片并复用原来切片的底层数组。 这使得切片操作和数组索引一样高效。因此，通过一个新切片修改元素会影响到原始切片的对应元素。
d := []byte{'r', 'o', 'a', 'd'}
e := d[2:]
// e == []byte{'a', 'd'}
e[1] = 'm'
// e == []byte{'a', 'm'}
// d == []byte{'r', 'o', 'a', 'm'}
前面创建的切片s长度小于它的容量。我们可以增长切片的长度为它的容量：
s = s[:cap(s)]
切片增长不能超出其容量。增长超出切片容量将会导致运行时异常，就像切片或数组的索引超 出范围引起异常一样。同样，不能使用小于零的索引去访问切片之前的元素。
切片的生长（copy and append 函数）
要增加切片的容量必须创建一个新的、更大容量的切片，然后将原有切片的内容复制到新的切片。 整个技术是一些支持动态数组语言的常见实现。下面的例子将切片s容量翻倍，先创建一个2倍 容量的新切片t，复制s的元素到t，然后将t赋值给s：
t := make([]byte, len(s), (cap(s)+1)*2) // +1 in case cap(s) == 0
for i := range s {
t[i] = s[i]
循环中复制的操作可以由 copy 内置函数替代。copy 函数将源切片的元素复制到目的切片。 它返回复制元素的数目。
func copy(dst, src []T) int
copy函数支持不同长度的切片之间的复制（它只复制较短切片的长度个元素）。 此外，copy函数可以正确处理源和目的切片有重叠的情况。
使用copy函数，我们可以简化上面的代码片段：
t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
一个常见的操作是将数据追加到切片的尾部。下面的函数将元素追加到切片尾部， 必要的话会增加切片的容量，最后返回更新的切片：
func AppendByte(slice []byte, data ...byte) []byte {
m := len(slice)
n := m + len(data)
if n & cap(slice) { // if necessary, reallocate
// allocate double what's needed, for future growth.
newSlice := make([]byte, (n+1)*2)
copy(newSlice, slice)
slice = newSlice
slice = slice[0:n]
copy(slice[m:n], data)
return slice
下面是AppendByte的一种用法：
p := []byte{2, 3, 5}
p = AppendByte(p, 7, 11, 13)
// p == []byte{2, 3, 5, 7, 11, 13}
类似AppendByte的函数比较实用，因为它提供了切片容量增长的完全控制。 根据程序的特点，可能希望分配较小的活较大的块，或则是超过某个大小再分配。
但大多数程序不需要完全的控制，因此Go提供了一个内置函数append， 用于大多数场合；它的函数签名：
func append(s []T, x ...T) []T
append函数将x追加到切片s的末尾，并且在必要的时候增加容量。
a := make([]int, 1)
// a == []int{0}
a = append(a, 1, 2, 3)
// a == []int{0, 1, 2, 3}
如果是要将一个切片追加到另一个切片尾部，需要使用...语法将第2个参数展开为参数列表。
a := []string{&John&, &Paul&}
b := []string{&George&, &Ringo&, &Pete&}
a = append(a, b...) // equivalent to &append(a, b[0], b[1], b[2])&
// a == []string{&John&, &Paul&, &George&, &Ringo&, &Pete&}
由于切片的零值nil用起来就像一个长度为零的切片，我们可以声明一个切片变量然后在循环 中向它追加数据：
// Filter returns a new slice holding only
// the elements of s that satisfy f()
func Filter(s []int, fn func(int) bool) []int {
var p []int // == nil
for _, v := range s {
if fn(v) {
p = append(p, v)
可能的&陷阱&
正如前面所说，切片操作并不会复制底层的数组。整个数组将被保存在内存中，直到它不再被引用。 有时候可能会因为一个小的内存引用导致保存所有的数据。
例如，FindDigits函数加载整个文件到内存，然后搜索第一个连续的数字，最后结果以切片方式返回。
var digitRegexp = regexp.MustCompile(&[0-9]+&)
func FindDigits(filename string) []byte {
b, _ := ioutil.ReadFile(filename)
return digitRegexp.Find(b)
这段代码的行为和描述类似，返回的[]byte指向保存整个文件的数组。因为切片引用了原始的数组， 导致 GC 不能释放数组的空间；只用到少数几个字节却导致整个文件的内容都一直保存在内存里。
要修复整个问题，可以将感兴趣的数据复制到一个新的切片中：
func CopyDigits(filename string) []byte {
b, _ := ioutil.ReadFile(filename)
b = digitRegexp.Find(b)
c := make([]byte, len(b))
copy(c, b)
可以使用append实现一个更简洁的版本。go语言陷阱之十二：数组与切片遍历时不必要的变量 - 简书
go语言陷阱之十二：数组与切片遍历时不必要的变量
在python，我们常用for i in x来遍历list/tuple，在go语言中，遍历数据或切片时可以用range,range会产生两个值，分别是数据的索引与值，
package main
import "fmt"
func main() {
x := []string{"a", "b", "c"}
for v := range x {
fmt.Println(v) //prints 0, 1, 2
这种写法非常不好（虽然没有报错），因为for...range的过程中，产生了index(索引)与value两个值，但是在遍历的时候，却没有显示地声明有这index变量，虽然我们此时不用index,时刻养成良好的编码习惯。
package main
import "fmt"
func main() {
x := []string{"a","b","c"}
for _, v := range x {
fmt.Println(v) //prints a, b, c
不用就将其忽略！！！
what-why-howgo的学习记录（二）--- 数组与数组切片 - CSDN博客
go的学习记录（二）--- 数组与数组切片
在go语言的学习中，少不了接触的就是数组和数组切片，并且这两者的使用也是非常频繁的。因此如果不能进行很好的理解，或许很容易犯错。那么在go中，数组和数组切片都有什么特点，又是怎么声明赋值的，如何使用的呢，下面我就自己的理解总结一下，个人总结可能不全或者有错，望指点。
一、数组和数组切片的特点
数组是什么就不用多说了，作为开发者，这是经常会用到的东西，相信大家都有自己的理解。现在先总结一下数组的特点
1. 数组的长度在定义之后就不可被更改
2. 数组声明时的长度必须为常量或常量表达式，即可以在编译器确定长度，分配内存
3. 数组的下标从0开始，最后一个元素的下标为（长度-1），即在go中可以写为 len(arr)-1
4. go语言的数组是值类型，在作为参数传递时会做数组的复制操作。因此作为参数传递的时候，被修改的内容不影响原来的数组内容，只影响传入函数内的副本
数组切片：是go提供的一种新型的数据类型，它在go语言中的使用有C或C++中的指针的功效。但由于它又不同于指针，所以没有C或C++中语言的指针操作方式。数组切片的底层是通过数组实现，很容易联想到C++的vector。
1. 与数组不同，数组切片的长度是可变的，即可以动态分配内存空间。但在每次新分配空间的时候，即会对当前的元素进行一次复制
2. go语言提供了内置函数copy用于将内容从一个数组切片复制到另外一个数组切片，但如果两个数组切片的长度不一样，则会按照较小的数组切片的个数进行复制。
3. 数组切片与数组一样，其下标从0开始，最后一个元素的下标为（长度-1），即在go中可以写为 len(arr)-1
4. go语言提供cap()内置函数可以获得数组切片分配的空间大小，该值的返回可能与len()返回的大小不同
5. 数组切片提供创建时指定长度和预留存储空间。在知道数组切片最终能用到的长度时，可以避免切片扩容所引发的内存的申请释放与复制。
6. 数组切片作为参数传递时，不会出现内存的复制操作，在函数中如果修改了传入的切片的参数，可以直接修改原数组切片的内容。
二、数组与数组切片的使用
（一） 声明与创建
数组的定义初始化比较简单，如下：
1. var arr [10]int
//声明长度为10，类型为int的数组。也可以声明多维数组，如：var twod [10][100]int。也可以定义复杂类型数组，如：var st_arr [100]struct {x, y int }
arr[1] = 1
//根据索引赋值
2. arr := [5]int{1,2,3,4,5}
//声明并初始化数组
3. var arr [5]int = [5]int{1,2,3,4,5}
//定义并初始化数组
数组切片的定义与初始化，如下：
1. 基于数组创建
arr := [10]int{1,2,3,4,5}
var slc1 []int = arr[:]
//基于数组全部元素创建切片
var slc2 []int = arr[:5]
//基于前五个元素创建切片
var slc3 []int = arr[5:]
//基于从第五个元素创建切片
var slc4 []int = arr[2:8]
//基于从第二个到第八个元素创建切片
以上几种创建切片的方式，都是基于一种创建规则：基于arr[first:last]这种方式创建数组切片
2. 直接创建
slice1 := make([]int, 5)
//创建一个初始元素个数为5的数组切片，元素初始值为0
slice2 := make([]int, 5, 10)
//创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间
slice3 := []int{1, 2, 3, 4, 5}
//直接创建并初始化包含5个元素的数组切片
3. 基于数组切片创建数组切片
基于数组切片创建数组切片和基于数组创建切片基本相同。但新创建的切片元素个数可以超过旧切片所包含的元素个数，该操作要求新创建切片的元素个数不超过旧切片的容量个数。如：
slice1 := &make([]int, 5, 10)
slice2 := slice1[:6]
（二）遍历元素
在go中，无论是数组还是数组切片，都提供了两种相同的遍历方式：
1. 使用传统的for遍历：
for i := 0; i & len(arr); i++ {
fmt.Println(&arr[&,i,&] is &, arr[i])
2. 使用range关键字：
for i, v := range arr {
fmt.Println(&arr[&,i,&] is &, v)
(三) 长度获取
对于数组和数组切片，go语言提供了内置函数len()，使用方式len(arr)，返回当前数组或数组切片的长度。对于数组切片，go语言提供内置函数cap()获取数组切片的容量
（四）添加元素
对于数组定长，因此没有添加元素的功能。但数组切片因为动态内存的问题，可以提供追加元素。在go语言中提供了内置函数append作为数组切片的元素追加。有以下两种使用方式：
1. 直接追加元素：
slice1 := []int{1,2,3,4}
slice1 = append(slice1, 5, 6, 7)
// append的第一个参数是基于的数组切片。第二个参数是不定参数，可以追加多个元素
2. 数组切片追加数组切片：
slice1 := []int{1,2,3,4}
slice2 := []int{5,6,7,8}
slice1 := append(slice1, slice2…)
//这里要特别注意的是：在第二个数组切片后面需要加三个点，否则会编译错误。主要原因是append第二个参数起都是待追加的元素，而加上三个点的作用就是把slice2的元素按照元素内容列表传入，而不是以切片作为参数传入。
（五）作为参数传递
1. 数组作为参数
func sort(arr [10] int) {
该函数的调用要如下：
arr1 := [10]int{8,6,5,4,7,3,9,1,2,10}
arr2 := [5]int{4,2,3,5,1}
slice1 := []int{8,6,5,4,7,3,9,1,2,10}
//编译正常，但由于数组穿参属于值传参，在传参的时候会进行数组复制，因此只修改了sort内部的arr的值，未修改arr1的实际元素值内容
sort(arr2)
//编译错误，对于go而言，[10]int 和[5]int 是两种不同的数据类型
sort(&arr)
//编译错误，对于C或C++而言，函数参数定义为int arr[10]这种实际是定义了数组的指针传入。但go语言中，数组指针和数组是两种完全不同的类型
sort(slice1)
//编译错误，同样是因为类型不同
2. 数组切片作为参数
func sort(arr []int) {
arr1 := [10]int{8,6,5,4,7,3,9,1,2,10}
slice1 := []int{8,6,5,4,7,3,9,1,2,10}
//编译错误，类型不同
sort(slice1)
//编译正确，且在sort中对于slice的修改会直接修改到原始的slice。
本文已收录于以下专栏：
相关文章推荐
一、slice的概念：
Slices（切片）slice是概念上一个结构包含三个域：一个数组的指针、长度和容量。切片支持[]操作符来访问底层数组的元素。内置的len函数返回的切片长度。内置的的cap函...
Go语言切片的用法和本质
##Go 语言中定义数组主要包括以下四种形式：
= []{元素1, 元素2, …}
[] = […]{元素1, 元素2, …}
[] = […]{...
func RemoveDuplicate(list *[]int) []int {
var x []int = []int{}
for _, i := range *lis...
一、数组　
与其他大多数语言类似，Go语言的数组也是一个元素类型相同的定长的序列。
（1）数组的创建。
数组有3种创建方式：[length]Type　、[N]Type{value1, value...
go语言函数参数与返回值示例，数组的简单应用package main
import "fmt"
func main() {
string1 ,string2 :=test_various_val...
Go语言的语法很灵活，以下展示了创建并初始化数组的多种方式：
//数组初始化的各种方式
func arraySliceTest0201() {
//创建数组(声明长度)
var array1 = ...
array是固定长度的数组，这个和C语言中的数组是一样的，使用前必须确定数组长度。但是和C中的数组相比，又是有一些不同的：
1. Go中的数组是值类型，换句话说，如果你将...
在任何一门语言里，数组应该都是非常基础的类型了，使用率当然也应该是很高的。go不但提供了数组，而且还在数组这个类型之上加了一层包装，这个包装也就是slice。
go的数组变量（也就是...
他的最新文章
讲师：王禹华
讲师：宋宝华
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)