For loop Go中的惯用拼接

我检查了一个现有的案例，但它与我的案例不同

我需要在索引中提取一个元素，并根据

Compare

函数在运行时中断

for

循环

问题： 如果在

0

index

，

index-1

将抛出范围错误的切片边界，同样，如果

index+1

大于

len（elements）

问题：实现上述目标的最佳简明方法是什么

for index, element := range elements {
    if element.Compare() == true {
        elements = append(elements[:index-1], elements[index+1:]...)
        break
    }
}

尝试

for index, element := range elements {
    if element.Compare() == true {
        if len(elements) > 1 {
            elements = append(elements[:index-1], elements[index+1:]...)
        } else if len(elements) == 1 {
            delete(elements, 0)
        }
        break
    }
}

尝试2有什么改进/建议吗

其思想是将剩余的元素从开始复制到索引，然后再复制后面的任何元素

var elements = []string {"a", "b", "c", "d"}
fmt.Println(elements)
for index, element := range elements {
    if element == "c" {
        var temp = elements[:index]
        for i := index + 1; i<len(elements); i++ {
            temp = append(temp, elements[i])
        }
        elements = temp
        break
    }
}
fmt.Println(elements)

var元素=[]字符串{“a”、“b”、“c”、“d”}
fmt.Println（要素）
对于索引，元素：=范围元素{
如果元素==“c”{
变量温度=元素[：索引]
对于i:=index+1；ia中的高指数是独占的

这意味着你的例子是有缺陷的，而且不需要特殊处理

正确的切片表达式为：

elements = append(elements[:index], elements[index+1:]...)

如果
index
是第一个元素（
0
），那么
元素[：0]
将是一个空片段

如果
index
是最后一个元素（
len-1
），那么
elements[index+1:][/code>也将是一个空切片，因为
index+1
将等于切片的长度。因此，解决方案很简单：

for index, element := range elements {
    if element.Compare() {
        elements = append(elements[:index], elements[index+1:]...)
        break
    }
}

为了在运动场上演示它，让我们用一个简单的索引检查代替
Compare（）
方法：

for _, idxToRemove := range []int{0, 2, 4} {
    s := []int{0, 1, 2, 3, 4}
    for i := range s {
        if i == idxToRemove {
            s = append(s[:i], s[i+1:]...)
            break
        }
    }
    fmt.Println(idxToRemove, ":", s)
}

输出（在上尝试）：

如果切片
s
已排序且
len（s）
较大，则使用二进制搜索查找
x
。例如

package main

import (
    "fmt"
    "sort"
)

func pluck(s []string, x string) []string {
    i := sort.SearchStrings(s, x)
    if i >= 0 && i < len(s) && s[i] == x {
        s = append(s[:i], s[i+1:]...)
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

package main

import "fmt"

func pluck(s []string, x string) []string {
    for i, v := range s {
        if v == x {
            s[i] = s[len(s)-1]
            s = s[:len(s)-1]
            break
        }
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

package main

import "fmt"

func pluck(s []string, x string) []string {
    for i, v := range s {
        if v == x {
            s = append(s[:i], s[i+1:]...)
            break
        }
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

如果切片
s
的顺序不需要保留，则切换元素。例如

package main

import (
    "fmt"
    "sort"
)

func pluck(s []string, x string) []string {
    i := sort.SearchStrings(s, x)
    if i >= 0 && i < len(s) && s[i] == x {
        s = append(s[:i], s[i+1:]...)
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

package main

import "fmt"

func pluck(s []string, x string) []string {
    for i, v := range s {
        if v == x {
            s[i] = s[len(s)-1]
            s = s[:len(s)-1]
            break
        }
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

package main

import "fmt"

func pluck(s []string, x string) []string {
    for i, v := range s {
        if v == x {
            s = append(s[:i], s[i+1:]...)
            break
        }
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

输出：

[a b c d]
[a c d]

[a b c d]
[a d c]

[a b c d]
[a c d]

否则，拼接片
s
元件。例如

package main

import (
    "fmt"
    "sort"
)

func pluck(s []string, x string) []string {
    i := sort.SearchStrings(s, x)
    if i >= 0 && i < len(s) && s[i] == x {
        s = append(s[:i], s[i+1:]...)
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

package main

import "fmt"

func pluck(s []string, x string) []string {
    for i, v := range s {
        if v == x {
            s[i] = s[len(s)-1]
            s = s[:len(s)-1]
            break
        }
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

package main

import "fmt"

func pluck(s []string, x string) []string {
    for i, v := range s {
        if v == x {
            s = append(s[:i], s[i+1:]...)
            break
        }
    }
    return s
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = pluck(s, "b")
    fmt.Println(s)
}

输出：

[a b c d]
[a c d]

[a b c d]
[a d c]

[a b c d]
[a c d]

您的问题是什么？从切片中提取元素的最佳方法是什么？您是否尝试删除单个元素？位于索引
索引
？是的，仅单个元素，然后断开