Go切片与技巧（2022年最新版本）

    var a [4]int // 数组类型: 定义指定长度和元素类型
    a[0] = 1     // 数组a的第一个索引的值设置为1
    i := a[0]
    fmt.Println(i)    // 输出：1， 说明已经设置成功
    fmt.Println(a[1]) // 输出：0，说明数组不需要显式初始化，其元素本身为零
    fmt.Println(a[4]) // 报错：invalid array index 4 (out of bounds for 4-element array)Copy

    a := [2]string{"johnny", "太白技术"} // 长度`2`，可以改成`...`，编译器会自动计算数组的长度
    b := a
    a[0] = "xujiajun"
    fmt.Println(a) // 输出：[xujiajun 太白技术]
    fmt.Println(b) // 输出：[johnny 太白技术]Copy

func double(arr *[3]int) {
    for i, num := range *arr {
        (*arr)[i] = num * 2
    }
}
a := [3]int{1, 2, 3}
double(&a)
fmt.Println(a) // [2 4 6]Copy

type slice struct {
    array unsafe.Pointer // 指针指向底层数组
    len   int  // 切片长度
    cap   int  // 底层数组容量
}Copy

    var s []byteCopy

    var x []byte
    fmt.Println(cap(x))   // 0
    fmt.Println(len(x))   // 0
    fmt.Println(x == nil) // trueCopy

a := []string{"johnny", "太白技术"} // 这是切片声明，少了长度的指定
b := [2]string{"johnny", "太白技术"} // 这是数组声明，多了长度的指定Copy

    y := make([]int, 0)
    fmt.Println(cap(y))   // 0
    fmt.Println(len(y))   // 0
    fmt.Println(y == nil) // falseCopy

    var s []byte
    s = make([]byte, 5, 5) // 指定了长度和容量
    fmt.Println(s) // 输出：[0 0 0 0 0]
Copy

s := make([]byte, 5)
fmt.Println(s) // 输出也是 [0 0 0 0 0]Copy

    fmt.Println(len(s)) // 5
    fmt.Println(cap(s)) // 5Copy

    n := *new([]int)
    fmt.Println(n == nil) // trueCopy

    n := [5]int{1, 2, 3, 4, 5}
    n1 := n[1:]     // 从n数组中截取
    fmt.Println(n1) // [2 3 4 5]
    n2 := n1[1:]    // 从n1切片中截取
    fmt.Println(n2) // [3 4 5]Copy

    n2[1] = 6 // 修改n2，会影响原切片和数组
    fmt.Println(n1) // [2 3 6 5]
    fmt.Println(n2) // [3 6 5]
    fmt.Println(n)  // [1 2 3 6 5]Copy

    n := make([]int, 0)
    n = append(n, 1)                 // 添加一个元素
    n = append(n, 2, 3, 4)           // 添加多个元素
    n = append(n, []int{5, 6, 7}...) // 添加一个切片
    fmt.Println(n)                   // [1 2 3 4 5 6 7]Copy

    fmt.Println(cap(n)) // 容量等于8
    n = append(n, []int{8, 9, 10}...)
    fmt.Println(cap(n)) // 容量等于16，发生了扩容Copy

    n := []int{1, 2, 3, 4, 5, 6}
 fmt.Println(n[1:4])      // [2 3 4]Copy

n := []int{1, 2, 3, 4, 5, 6}
fmt.Println(n[:4])      // [1 2 3 4]，:前面没有值，默认表示0
fmt.Println(n[1:])       // [2 3 4 5 6]，:后面没有值，默认表示切片的长度Copy

    s := "hello taibai"
    s1 := s[6:]
    fmt.Println(s1)                 // taibai
    fmt.Println(reflect.TypeOf(s1)) // stringCopy

    n := []int{1, 2, 3, 4, 5, 6}
    n1 := n[1:4]
    fmt.Println(n)       // [1 2 3 4 5 6]
    fmt.Println(n1)      // [2 3 4]
    n1 = append(n1, 100) // 把n的索引位置4的值从原来的5变成了100
    fmt.Println(n)       // [1 2 3 4 100 6]Copy

    fmt.Println(cap(n[1:4])) // 5
    fmt.Println(cap(n[1:4:5])) // 4Copy

    n2 := n[1:4:5]         // 长度等于3，容量等于4
    fmt.Printf("%p\n", n2) // 0xc0000ac068
    n2 = append(n2, 5)
    fmt.Printf("%p\n", n2) // 0xc0000ac068
    n2 = append(n2, 6)
    fmt.Printf("%p\n", n2) // 地址发生改变，0xc0000b8000Copy

a = append(a, b...)Copy

b := make([]T, len(a))
copy(b, a)

// 效率一般比上面的写法慢，但是如果有更多，他们效率更好
b = append([]T(nil), a...)
b = append(a[:0:0], a...)

// 这个实现等价于make+copy。
// 但在Go工具链v1.16上实际上会比较慢。
b = append(make([]T, 0, len(a)), a...)Copy

a = append(a[:i], a[j:]...)Copy

copy(a[i:], a[j:])
for k, n := len(a)-j+i, len(a); k < n; k++ {
    a[k] = nil // or the zero value of T
}
a = a[:len(a)-j+i]Copy

a = append(a[:i], a[i+1:]...)
// or
a = a[:i+copy(a[i:], a[i+1:])]Copy

copy(a[i:], a[i+1:])
a[len(a)-1] = nil // or the zero value of T
a = a[:len(a)-1]Copy

a[i] = a[len(a)-1] 
a = a[:len(a)-1]Copy

a[i] = a[len(a)-1]
a[len(a)-1] = nil
a = a[:len(a)-1]Copy

a = append(a[:i], append(make([]T, j), a[i:]...)...)
Copy

a = append(a, make([]T, j)...)Copy

n := 0
for _, x := range a {
    if keep(x) {
        a[n] = x
        n++
    }
}
a = a[:n]Copy

a = append(a[:i], append([]T{x}, a[i:]...)...)Copy

s = append(s, 0 /* 先添加一个0值*/)
copy(s[i+1:], s[i:])
s[i] = xCopy

a = append(a[:i], append(b, a[i:]...)...)Copy

func Insert(s []int, k int, vs ...int) []int {
    if n := len(s) + len(vs); n <= cap(s) {
        s2 := s[:n]
        copy(s2[k+len(vs):], s[k:])
        copy(s2[k:], vs)
        return s2
    }
    s2 := make([]int, len(s) + len(vs))
    copy(s2, s[:k])
    copy(s2[k:], vs)
    copy(s2[k+len(vs):], s[k:])
    return s2
}

a = Insert(a, i, b...)Copy

a = append(a, x)Copy

 x, a = a[len(a)-1], a[:len(a)-1]Copy

a = append([]T{x}, a...)Copy

x, a = a[0], a[1:]
Copy

b := a[:0]
for _, x := range a {
    if f(x) {
        b = append(b, x)
    }
}Copy

for i := len(b); i < len(a); i++ {
    a[i] = nil // or the zero value of T
}Copy

for i := len(a)/2-1; i >= 0; i-- {
    opp := len(a)-1-i
    a[i], a[opp] = a[opp], a[i]
}Copy

for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
    a[left], a[right] = a[right], a[left]
}Copy

for i := len(a) - 1; i > 0; i-- {
    j := rand.Intn(i + 1)
    a[i], a[j] = a[j], a[i]
}Copy

actions := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
batchSize := 3
batches := make([][]int, 0, (len(actions) + batchSize - 1) / batchSize)

for batchSize < len(actions) {
    actions, batches = actions[batchSize:], append(batches, actions[0:batchSize:batchSize])
}
batches = append(batches, actions)

// 结果：
// [[0 1 2] [3 4 5] [6 7 8] [9]]
Copy

import "sort"

in := []int{3,2,1,4,3,2,1,4,1} // any item can be sorted
sort.Ints(in)
j := 0
for i := 1; i < len(in); i++ {
    if in[j] == in[i] {
        continue
    }
    j++
    // preserve the original data
    // in[i], in[j] = in[j], in[i]
    // only set what is required
    in[j] = in[i]
}
result := in[:j+1]
fmt.Println(result) // [1 2 3 4]Copy

// moveToFront moves needle to the front of haystack, in place if possible.
func moveToFront(needle string, haystack []string) []string {
    if len(haystack) != 0 && haystack[0] == needle {
        return haystack
    }
    prev := needle
    for i, elem := range haystack {
        switch {
        case i == 0:
            haystack[0] = needle
            prev = elem
        case elem == needle:
            haystack[i] = prev
            return haystack
        default:
            haystack[i] = prev
            prev = elem
        }
    }
    return append(haystack, prev)
}

haystack := []string{"a", "b", "c", "d", "e"} // [a b c d e]
haystack = moveToFront("c", haystack)         // [c a b d e]
haystack = moveToFront("f", haystack)         // [f c a b d e]Copy

func slidingWindow(size int, input []int) [][]int {
    // returns the input slice as the first element
    if len(input) <= size {
        return [][]int{input}
    }

    // allocate slice at the precise size we need
    r := make([][]int, 0, len(input)-size+1)

    for i, j := 0, size; j <= len(input); i, j = i+1, j+1 {
        r = append(r, input[i:j])
    }

    return r
}

func TestSlidingWindow(t *testing.T) {
    result := slidingWindow(2, []int{1, 2, 3, 4, 5})
    fmt.Println(result) // [[1 2] [2 3] [3 4] [4 5]]
}Copy