Go Slice 高級實踐

1. 如下用法中，類型均使用 int64 作爲示例，不處理 interface 。
2. 代碼只是展現實現思路，不必定完善。

合併兩個有序切片，新切片仍然有序

func MergeSortedSlice(s1, s2 []int64) []int64 {
    // 從末尾元素開始遍歷
    i := len(s1) - 1
    j := len(s2) - 1
    // 合併後的長度
    newLen := len(s1) + len(s2)
    // 合併後的索引，也從末尾元素開始
    newIdx := newLen - 1
    // 建立一個新切片，表明合併後的
    newS := make([]int64, newLen)
    // 將 s1 的內容拷貝到新切片
    for k, v := range s1 {
        newS[k] = v
    }
    // 開始遍歷
    for i >= 0 && j >= 0 {
        // 新元素
        var newNum int64
        // 將較大的值賦給新元素，同時向前移動指針
        if newS[i] > s2[j] {
            newNum = newS[i]
            i--
        } else {
            newNum = s2[j]
            j--
        }
        newS[newIdx] = newNum
        newIdx--
    }
    // 若是 s2 還有剩餘元素，則剩餘元素必定都是最小的，直接放到頭部便可
    for j >= 0 {
        newS[newIdx] = s2[j]
        j--
        newIdx--
    }
    return newS
}

根據特定規則過濾元素

func FilterSlice(s []int64, filter func(x int64) bool) []int64 {
    // 返回的新切片
    // s[:0] 這種寫法是建立了一個 len 爲 0，cap 爲 len(s) 即和原始切片最大容量一致的切片
    // 由於是過濾，因此新切片的元素總個數必定不大於比原始切片，這樣作減小了切片擴容帶來的影響
    // 同時，也有一個問題，由於 newS 和 s 共享底層數組，那麼過濾後 s 也會被修改！
    newS := s[:0]
    // 遍歷，對每一個元素執行 filter，符合條件的加入新切片中
    for _, x := range s {
        if !filter(x) {
            newS = append(newS, x)
        }
    }
    return newS
}

去重

兩種思路，循環順序查找和使用 map 加快查找（引入一個 map 在各方面也是有開銷的）。選用哪一種，能夠經過具體場景的 Benchmark 決定

func RemoveDuplicates(s []int64) []int64 {
    var ret []int64
    for _, v := range s {
        found := false
        for _, v2 := range ret {
            if v == v2 {
                found = true
                break
            }
        }
        if !found {
            ret = append(ret, v)
        }
    }
    return ret
}

func RemoveDuplicates2(s []int64) []int64 {
    ret := s[:0]
    // 利用 struct{}{} 減小內存佔用
    assist := map[int64]struct{}{}
    for _, v := range s {
        if _, ok := assist[v]; !ok {
            assist[v] = struct{}{}
            ret = append(ret, v)
        }
    }
    return ret
}

反轉

func Reversing(s []int64) []int64 {
    for left, right := 0, len(s)-1; left < right; left, right = left+1, right-1 {
        s[left], s[right] = s[right], s[left]
    }
    return s
}

分塊

主要用於當單個切片過大，須要分屢次使用的時候，好比網絡調用等。

func SliceChunk(s []int64, size int) [][]int64 {
    var ret [][]int64
    for size < len(s) {
        // s[:size:size] 表示 len 爲 size，cap 也爲 size，第二個冒號後的 size 表示 cap
        s, ret = s[size:], append(ret, s[:size:size])
    }
    ret = append(ret, s)
    return ret
}

類型轉換

RPC 中，不一樣下游接收的類型可能不同，還有自定義類型，這裏提供一個快速轉換的方法

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var newS []int64
// 作法是利用 reflect 直接替換數據指針
// 可是這個不保證在之後的版本中一直可用 ╮(╯▽╰)╭
*(*reflect.SliceHeader)(unsafe.Pointer(&newS)) = *(*reflect.SliceHeader)(unsafe.Pointer(&s))
fmt.Printf("type:%T value:%v", newS, newS)

未完待續

主要參考：
https://github.com/golang/go/wiki/SliceTricks 官方使用技巧，建議多看看。