golang 刪除切片的某個元素及剔除切片內的零值方式

Posted on by

看代碼吧~

func remove(slice []interface{}, elem interface{}) []interface{}{
    if len(slice) == 0 {
        return slice
    }
    for i, v := range slice {
        if v == elem {
            slice = append(slice[:i], slice[i+1:]...)
            return remove(slice,elem)
            break
        }
    }
    return slice
}
func removeZero(slice []interface{}) []interface{}{
    if len(slice) == 0 {
        return slice
    }
    for i, v := range slice {
        if ifZero(v) {
            slice = append(slice[:i], slice[i+1:]...)
            return removeZero(slice)
            break
        }
    }
    return slice
}
//判斷一個值是否為零值，隻支持string,float,int,time 以及其各自的指針，"%"和"%%"也屬於零值范疇，場景是like語句
func IfZero(arg interface{}) bool {
    if arg == nil {
        return true
    }
    switch v := arg.(type) {
    case int, int32, int16, int64:
        if v == 0 {
            return true
        }
    case float32:
        r:=float64(v)
        return math.Abs(r-0)<0.0000001
    case float64:
        return math.Abs(v-0)<0.0000001
    case string:
        if v == "" || v == "%%" || v == "%" {
            return true
        }
    case *string, *int, *int64, *int32, *int16, *int8, *float32, *float64, *time.Time:
        if v == nil {
            return true
        }
    case time.Time:
        return v.IsZero()
    default:
        return false
    }
    return false
}

補充：golang刪除slice中特定條件的元素，優化版

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

假設我們的切片有0和1，我們要刪除所有的0，此處有三種方法：

第一種方法：

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級別時，第三種方法的優勢就顯現出來。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：