关于golang:Go语言数组和切片的坑点记录

虽说 golang 的数组和切片应用简略，然而当你编码到一定量的时候，你就会发现原来简略的数组和切片也有很多坑点啊，上面就记录了我理论工作中的采坑点，话不都说间接上代码，各种留神点都在代码正文里了。

package main
 
import "fmt"
 
func main() {test01()
    //test02()
    test03()
    test04()
    test05()
    //test06()
    test07()}
 
/*
  下标索引操作的一些误区 s[i:l:c] i 是起始偏移的起始地位，l 是起始偏移的长度完结地位，l-i 就是新 slice 的长度，c 是起始偏移的容量完结地位，c-i 就是新 slice 的容量。其中 i、l、c 并不是以后 slice 的索引，而是援用底层数组
  绝对以后 slice 起始地位的偏移量，所以是可超出以后 slice 的长度的，但不能超出以后 slice 的容量，具体请看 test01, test02
*/
func test01() {mySlice := []string{"21"}
    //mySlice := [1]string{"21"} // 数组也和切片一样
    //fmt.Println("Result1:", mySlice[1]) // 数组越界, panic
    // 上面这行代码是正确的，不会产生数组越界问题
    fmt.Println("Result2:", mySlice[1:])
}
 
func test02() {s := make([]string, 100)
    s[20] = "100"
    s1 := s[10:10]
    s2 := s1[10:20]
    s3 := s[100:100]
    s4 := s[100:102] // 数组越界, panic
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(s4)
}
 
func test03() {//mySlice := make([]string, 2, 3) // 这条语句是创立一个长度为 2 且容量为 3 的, 并且含有两个空字符串的切片, 当 append 一个元素时不会从新分配内存
    mySlice := make([]string, 2) // 这条语句创立了一个长度和容量都为 2 的, 并且含有两个空字符串的切片
    fmt.Println(len(mySlice), cap(mySlice))
    mySlice = append(mySlice, "21") // 当新增加一个元素的时候，原来 2 的容量曾经不够，所以须要重新分配一个长度是原来 2 倍的空间
    fmt.Printf("Content:%s, Len:%d, Cap:%d\n", mySlice, len(mySlice), cap(mySlice))
}
 
/*
  切片的 append 操作有一个非凡的中央, 当是字节切片时, 能够 append 一个字符或字符串, 具体如下:
*/
func test04() {hisSlice := make([]byte, 10, 20)
    hisSlice = append(hisSlice, 'd')
    //hisSlice = append(hisSlice, 'd'...) // 不非法
    hisSlice = append(hisSlice, []byte{'d'}...)
    hisSlice = append(hisSlice, 'd', 'e')
    hisSlice = append([]byte("Tokyo"), "London"...)
    hisSlice = append(hisSlice, "Tokyo"...)
    //hisSlice=append(hisSlice,"Singapore","NewYork"...) // 不非法
    fmt.Println("hisSlice:", string(hisSlice))
}
 
func test05() {slice := []string{"1", "2", "3", "4", "5", "6"}
    fmt.Println("Slice:", slice)
 
    sli := slice[:] // 援用一个切片
    fmt.Println("sli:", sli)
 
    slice = slice[:0] // 清空一个切片
    fmt.Println("Slice:", slice)
}
 
/*
  从数组或切片中截取切片:
  1. 若没有指定 max, max 的值为截取对象 (数组 / 切片) 的容量
  2. 若指定 max, max 值不能超过原对象 (数组 / 切片) 的容量
  3. 利用数组创立切片, 切片操作的是同一个底层数组
  具体例子如下:
*/
func test06() {mySlice := []string{"1", "2", "3", "4", "5", "6"}
    mySlice = append(mySlice, []string{"1", "2", "3"}...) // 附加切片
 
    hisSlice := mySlice[1:6:13] // 13 超过了原切片的容量, 所以会 panic
    //hisSlice := mySlice[1:5:5]
    //hisSlice := mySlice[1:5]  // 未指定 max, 则 max 为原切片最大容量
 
    fmt.Println("MySliceCap:", cap(mySlice))
    fmt.Println("HistSliceCap:", cap(hisSlice))
}
 
func test07() {arr := [3]string{"1", "2", "3"}
    //arr = append(arr, "3") // 数组不能够应用 append 办法
    //fmt.Println(len(arr), cap(arr)) // 数组能够应用 len,cap 办法
 
    //var arr1 []string // 应用 copy 的切片必须是有长度的, 这种 nil 的切片会拷贝为空
    //arr1 := make([]string, 0, 10) // 应用 copy 的切片必须是有长度的, 这种零长度的切片会拷贝为空
    arr1 := make([]string, 1)
    //arr1 := make([]string, 6)
    n := copy(arr1, arr[:]) // n: 返回的是理论被拷贝的元素数量
    fmt.Println("arr1:", arr1, "len:", n)
 
    // 非凡的中央是能够把字符串或字符拷贝到字节切片中, 
    // 并且拷贝的程序是从前到后，例子如下:
    arr2 := make([]byte, 2, 4)
    copy(arr2, "Tokyo")
    copy(arr2, []byte{'A'})
    fmt.Println("arr2:", string(arr2))
}