【问题标题】:How to remove items from a slice while ranging over it?如何在覆盖切片时从切片中删除项目?
【发布时间】:2013-12-12 14:08:21
【问题描述】:

在覆盖切片时从切片中删除项目的最佳方法是什么?

例如:

type MultiDataPoint []*DataPoint

func (m MultiDataPoint) Json() ([]byte, error) {
    for i, d := range m {
        err := d.clean()
        if ( err != nil ) {
            //Remove the DP from m
        }
    }
    return json.Marshal(m)
}

【问题讨论】:

  • @YasirG.:这是为了从map 中删除。 OP 想从slice 中删除。
  • 真的很抱歉错误的答案已经醒了 25 小时了:S
  • Go 迫切需要一个 descending 范围结构。没有它会导致大量的额外工作。
  • 这会如何改变? @Vector

标签: go


【解决方案1】:

正如您在其他地方提到的,您可以分配新的内存块并仅将有效元素复制到其中。但是,如果您想避免分配,您可以就地重写切片:

i := 0 // output index
for _, x := range s {
    if isValid(x) {
        // copy and increment index
        s[i] = x
        i++
    }
}
// Prevent memory leak by erasing truncated values 
// (not needed if values don't contain pointers, directly or indirectly)
for j := i; j < len(s); j++ {
    s[j] = nil
}
s = s[:i]

完整示例:http://play.golang.org/p/FNDFswPeDJ

注意这将在底层数组中的索引i 之后留下旧值,因此如果值是或包含指针,则此will leak memory 直到切片本身被垃圾收集。您可以通过在截断之前将所有值设置为 nil 或从 i 到切片末尾的零值来解决此问题。

【讨论】:

  • Go 中不需要分号
  • @Ectomorph:固定;那时我是一名 C++ 程序员——幸运的是,这些日子一去不复返了,带着分号。
  • 应该被接受的答案。比每次删除时复制数组要好得多。
  • @EugeneBeresovsky 我认为我的措辞在这里不太准确,我唯一的目的是警告人们我们正在覆盖原始数组,因此可能会产生副作用。将编辑。
  • 特别是如果您有一个指针切片,您可能会在数组末尾泄漏这些项目,因为包含原始指针的后备内存对于 GC 仍然有效。如果截断指针切片,请始终将截断的指针设置为 nil。 utcc.utoronto.ca/~cks/space/blog/programming/GoSlicesMemoryLeak
【解决方案2】:

我知道它很久以前就回答了,但我在其他语言中使用类似的东西,但我不知道它是否是 golang 方式。

只需从后向前迭代,您就不必担心索引会被删除。我使用与亚当相同的示例。

m = []int{3, 7, 2, 9, 4, 5}

for i := len(m)-1; i >= 0; i-- {
    if m[i] < 5 {
        m = append(m[:i], m[i+1:]...)
    }
}

【讨论】:

  • 最简单的答案,应该是第一名
  • 如果删除超过 1 个元素,则效率不高。它为每个删除的元素复制数组。从 10'000 个元素中删除 100 个会复制 500'000 个(平均)元素。 @tomasz 解决方案复制 10'000 的位置。快 50 倍。
【解决方案3】:

这是从切片中删除元素的更惯用的 Go 方法。

temp := s[:0]
for _, x := range s {
    if isValid(x) {
        temp = append(temp, x)
    }
}
s = temp

游乐场链接:https://play.golang.org/p/OH5Ymsat7s9

注意:示例和游乐场链接基于@tomasz 的回答https://stackoverflow.com/a/20551116/12003457

【讨论】:

  • 不错,简单的解决方案。
  • 对于 temp 的初始化,为什么要这样做 temp := s[:0] 而不是 temp := []int{}。有什么区别?
  • @Daryll s[:0] 将长度归零但保持与s 相同的容量,而[]int{} 两者均归零。它还避免了重新声明类型。
  • 使用 s[:0] 将重用相同的底层数组,而使用 []int{} 将创建一个新数组。
【解决方案4】:

可能有更好的方法,但这里有一个从切片中删除偶数值的示例:

m := []int{1,2,3,4,5,6}

deleted := 0
for i := range m {
    j := i - deleted
    if (m[j] & 1) == 0 {
        m = m[:j+copy(m[j:], m[j+1:])]
        deleted++
    } 
}

请注意,我没有使用 i, d := range m 语法获取元素,因为一旦您开始从切片中删除,d 最终会设置为错误的元素。

【讨论】:

  • 虽然我刚刚意识到创建第二个 MultiDataPoint 对象、向其附加有效内容并对其进行编组非常简单(可能效率较低?)。不知道我一开始怎么没看到:-/
  • 我猜效率取决于预期的删除与元素总数的比率。不过,代码很可能会更直接。
  • for i, _ := 应该只是 for i :=
  • @newacct:哎呀。已编辑。
  • 你应该使用for i := 0; i &lt; len(m); i++ {的形式循环,范围可能会给你一个index out of range错误。
【解决方案5】:

另一种选择是使用正常的 for 循环,使用切片的长度,并在每次删除值时从索引中减去 1。请参阅以下示例:

m := []int{3, 7, 2, 9, 4, 5}

for i := 0; i < len(m); i++ {
    if m[i] < 5 {
        m = append(m[:i], m[i+1:]...)
        i-- // -1 as the slice just got shorter
    }
}

我不知道len() 是否使用了足够的资源来产生任何影响,但您也可以只运行一次并从长度值中减去:

m := []int{3, 7, 2, 9, 4, 5}

for i, s := 0, len(m); i < s; i++ {
    if m[i] < 5 {
        m = append(m[:i], m[i+1:]...)
        s--
        i--
    }
}

【讨论】:

    【解决方案6】:

    类似:

    m = append(m[:i], m[i+1:]...)
    

    【讨论】:

    • 值得注意:Slice Tricks wiki page
    • 我正在尝试在一段字符串上使用此方法 - 我收到此错误:“无法使用 m[i + 1:] (type []string) 作为附加字符串类型”期望一个字符串而不是字符串切片作为第二个参数。有什么想法吗?
    • Nvmd - 我刚刚意识到“...”实际上是代码的一部分。
    • 如果你在迭代m时使用它,你会得到runtime error: slice bounds out of range。这就是这个问题的意义所在。您可以使用 m = append(m[:i], m[i+1:]...) 从切片中删除项目,但不能在使用 for i, element := range m 对其进行迭代时删除。
    【解决方案7】:

    试试Sort 和Binary search。

    例子:

    package main
    
    import (
        "fmt"
        "sort"
    )
    
    func main() {
        // Our slice.
        s := []int{3, 7, 2, 9, 4, 5}
    
        // 1. Iterate over it.
        for i, v := range s {
            func(i, v int) {}(i, v)
        }
    
        // 2. Sort it. (by whatever condition of yours)
        sort.Slice(s, func(i, j int) bool {
            return s[i] < s[j]
        })
    
        // 3. Cut it only once.
        i := sort.Search(len(s), func(i int) bool { return s[i] >= 5 })
        s = s[i:]
    
        // That's it!
        fmt.Println(s) // [5 7 9]
    }
    

    https://play.golang.org/p/LnF6o0yMJGT

    【讨论】:

    • 这需要更多的代码,速度较慢(排序通常不比 O(n log n) 快,而从切片中迭代删除将是 O(n))并且不能正确地演示如何当你有过滤功能而不是比较功能时,会使用它从切片中删除元素。
    • 我相信这更节省内存,并且可能更快,因为它不会将任何元素从一个切片复制到另一个切片。为要删除的每个元素更改数据存储位置的整个结构是危险的,并且可能比仅迭代切片花费更多。
    【解决方案8】:

    您甚至不需要倒数,但您确实需要检查您是否位于建议的append() 将失败的数组末尾。下面是一个从排序列表中删除重复正整数的示例:

    // Remove repeating numbers
    numbers := []int{1, 2, 3, 3, 4, 5, 5}
    log.Println(numbers)
    for i, numbersCount, prevNum := 0, len(numbers), -1; i < numbersCount; numbersCount = len(numbers) {
        if numbers[i] == prevNum {
            if i == numbersCount-1 {
                numbers = numbers[:i]
            } else {
                numbers = append(numbers[:i], numbers[i+1:]...)
    
            }
            continue
        }
        prevNum = numbers[i]
        i++
    
    }
    log.Println(numbers)
    

    游乐场:https://play.golang.org/p/v93MgtCQsaN

    【讨论】:

      【解决方案9】:

      我只是实现了一个删除切片中所有 nil 元素的方法。

      我用它解决了一个leetcode问题,效果很好。

      /**
       * Definition for singly-linked list.
       * type ListNode struct {
       *     Val int
       *     Next *ListNode
       * }
       */
       func removeNil(lists *[]*ListNode) {
          for i := 0; i < len(*lists); i++ {
              if (*lists)[i] == nil {
                  *lists = append((*lists)[:i], (*lists)[i+1:]...)
                  i--
              }
          }
      }
      

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 2013-09-05
        • 1970-01-01
        • 2021-09-21
        • 1970-01-01
        • 2014-08-24
        • 1970-01-01
        • 2017-07-08
        相关资源
        最近更新 更多