寫了兩種對一個slice中刪除特定元素的方法，並做了效能對比，在這裡記錄一下。

第一種方法：

func DeleteSlice(a []int) []int{
	for i := 0; i < len(a); i++ {
		if a[i] == 0 {
			a = append(a[:i], a[i+1:]...)
			i--
		}
	}
	return a
}

解釋：這裡利用常見的方法對slice中的元素進行刪除，注意刪除時，後面的元素前移，i應該後移一位。

第二種方法：

func DeleteSlice1(a []int) []int {
	ret := make([]int, 0, len(a))
	for _, val := range a {
		if val == 1 {
			ret = append(ret, val)
		}
	}
	return ret
}
 

解釋：這種方法最容易理解，重新使用一個slice，將不合理的過濾掉。缺點是需要開闢另一個slice的空間，優點是容易理解，而且不對原來的slice進行操作。

第三種方法：

func DeleteSlice2(a []int) []int{
	j := 0
	for _, val := range a {
		if val == 1 {
			a[j] = val
			j++
		}
	}
	return a[:j]
}

解釋：這裡利用一個index，記錄應該下一個有效元素應該在的位置，遍歷所有元素，當遇到有效元素，index加一，否則不加，最終index的位置就是所有有效元素的下一個位置。最後做一個擷取就行了。這種方法會對原來的slice進行修改。

這裡對三種方法做了效能測試，測試程式碼如下：

package main

import (
	"testing"
)

func handle(data []int) {
	return
}
const N = 100

func getSlice()[]int {
	a := []int{}
	for i := 0; i < N; i++ {
		if i % 2 == 0 {
			a = append(a, 0)
		} else {
			a = append(a, 1)
		}
	}
	return a
}

func BenchmarkDeleteSlice(b *testing.B) {
	for i := 0; i < b.N; i++ {
		 data := DeleteSlice(getSlice())
		 handle(data)
	}
}

func BenchmarkDeleteSlice1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		data := DeleteSlice1(getSlice())
		handle(data)
	}
}

func BenchmarkDeleteSlice2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		data := DeleteSlice2(getSlice())
		handle(data)
	}
}
 

測試結果如下（slice大小為100）：

加大slice大小進行測試（slice大小為10000）：

繼續加大（slice大小為100000）

slice大小為10^6:

可以看出：

第一種方法在slice大小比較小時，比第2、3種方法慢一倍左右。但是slice大小變大時，效能顯著下降。

第2種方法和第3種方法差距基本處於同一量級，但是第3種方法稍快一些。但是當slice大小增加到10^6級別時，第三種方法的優勢就顯現出來。