So löschen Sie ein Element aus einem Slice in Golang

fmt.Println("Enter position to delete::")
fmt.Scanln(&pos)

new_arr := make([]int, (len(arr) - 1))
k := 0
for i := 0; i < (len(arr) - 1); {
    if i != pos {
        new_arr[i] = arr[k]
        k++
        i++
    } else {
        k++
    }
}

for i := 0; i < (len(arr) - 1); i++ {
    fmt.Println(new_arr[i])
}

Ich verwende diesen Befehl, um ein Element aus einem Slice zu löschen, aber es funktioniert nicht. Bitte schlagen Sie vor.

Ordnung ist wichtig

Wenn Sie Ihr Array geordnet halten möchten, müssen Sie alle Elemente rechts vom Löschindex um eins nach links verschieben. Hoffentlich kann dies in Golang leicht gemacht werden:

func remove(slice []int, s int) []int {
    return append(slice[:s], slice[s+1:]...)
}

Dies ist jedoch ineffizient, da Sie möglicherweise alle Elemente verschieben müssen, was teuer ist.

Ordnung ist nicht wichtig

Wenn Sie sich nicht für die Bestellung interessieren, haben Sie die viel schnellere Möglichkeit, das zu löschende Element gegen das am Ende des Slice zu tauschen und dann die ersten n-1 Elemente zurückzugeben:

func remove(s []int, i int) []int {
    s[len(s)-1], s[i] = s[i], s[len(s)-1]
    return s[:len(s)-1]
}

Bei der Reslicing-Methode dauert das Entleeren eines Arrays von 1 000 000 Elementen 224 s, bei diesem dauert es nur 0,06 ns. Ich vermute, dass intern go nur die Länge des Slice ändert, ohne es zu ändern.

Bearbeiten 1

Schnelle Notizen basierend auf den Kommentaren unten (danke!).

Da der Zweck darin besteht, ein Element zu löschen, wird der zweite verschwendet, wenn die Reihenfolge keine Rolle spielt und ein einzelner Austausch erforderlich ist:

func remove(s []int, i int) []int {
    s[i] = s[len(s)-1]
    // We do not need to put s[i] at the end, as it will be discarded anyway
    return s[:len(s)-1]
}

Diese Antwort führt auch keine Grenzüberprüfung durch . Es erwartet einen gültigen Index als Eingabe. Dies bedeutet, dass negative Werte oder Indizes, die größer oder gleich len sind, zu Panik führen. Slices und Arrays sind 0-indiziert. Wenn Sie das n-te Element eines Arrays entfernen, müssen Sie die Eingabe n-1 bereitstellen . Um das erste Element zu entfernen, rufen Sie remove (s, 0) auf , um das zweite zu entfernen, rufen Sie remove (s, 1) auf und so weiter und so fort.

Entfernen Sie ein Element aus dem Slice (dies wird als "erneutes Schneiden" bezeichnet):

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(all) //[0 1 2 3 4 5 6 7 8 9]
    all = RemoveIndex(all, 5)
    fmt.Println(all) //[0 1 2 3 4 6 7 8 9]
}

Kleiner Punkt (Code Golf), aber wenn die Reihenfolge keine Rolle spielt, müssen Sie die Werte nicht tauschen. Überschreiben Sie einfach die zu entfernende Array-Position mit einem Duplikat der letzten Position und geben Sie dann ein abgeschnittenes Array zurück.

func remove(s []int, i int) []int {
    s[i] = s[len(s)-1]
    return s[:len(s)-1]
}

Gleiches Ergebnis.

Das ist etwas seltsam zu sehen, aber die meisten Antworten hier sind gefährlich und beschönigen, was sie tatsächlich tun. Wenn Sie sich die ursprüngliche Frage ansehen, die zum Entfernen eines Elements aus dem Slice gestellt wurde, wird eine Kopie des Slice erstellt und dann gefüllt. Dies stellt sicher, dass beim Übergeben der Slices um Ihr Programm keine subtilen Fehler auftreten.

Hier ist ein Code, der die Antworten der Benutzer in diesem Thread mit dem ursprünglichen Beitrag vergleicht. Hier ist ein Spielplatz , auf dem Sie mit diesem Code herumspielen können.

Anhängebasierte Entfernung

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeIndex := RemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]

    removeIndex[0] = 999
    fmt.Println("all: ", all) //[999 1 2 3 4 6 7 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
}

Im obigen Beispiel können Sie sehen, wie ich ein Slice erstelle und es manuell mit den Nummern 0 bis 9 fülle. Wir entfernen dann Index 5 von allen und weisen ihn zu, um Index zu entfernen. Wenn wir jedoch jetzt alles ausdrucken, sehen wir, dass es ebenfalls geändert wurde. Dies liegt daran, dass Slices Zeiger auf ein zugrunde liegendes Array sind. Das Ausschreiben auf removeIndexUrsachen all, die ebenfalls geändert werden sollen, mit dem Unterschied, dass alles um ein Element länger ist, von dem aus es nicht mehr erreichbar ist removeIndex. Als nächstes ändern wir einen Wert in removeIndexund wir können sehen, dass er ebenfalls allgeändert wird. Effective go geht hier näher darauf ein.

Das folgende Beispiel werde ich nicht näher erläutern, aber es macht dasselbe für unsere Zwecke. Und zeigt nur, dass die Verwendung von Kopien nicht anders ist.

package main

import (
    "fmt"
)

func RemoveCopy(slice []int, i int) []int {
    copy(slice[i:], slice[i+1:])
    return slice[:len(slice)-1]
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeCopy := RemoveCopy(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
    fmt.Println("removeCopy: ", removeCopy) //[0 1 2 3 4 6 7 8 9]

    removeCopy[0] = 999
    fmt.Println("all: ", all) //[99 1 2 3 4 6 7 9 9]
    fmt.Println("removeCopy: ", removeCopy) //[999 1 2 3 4 6 7 8 9]
}

Die Fragen Originalantwort

Bei Betrachtung der ursprünglichen Frage wird das Slice, aus dem ein Element entfernt wird, nicht geändert. Die ursprüngliche Antwort in diesem Thread ist für die meisten Leute, die auf diese Seite kommen, die bisher beste.

package main

import (
    "fmt"
)

func OriginalRemoveIndex(arr []int, pos int) []int {
    new_arr := make([]int, (len(arr) - 1))
    k := 0
    for i := 0; i < (len(arr) - 1); {
        if i != pos {
            new_arr[i] = arr[k]
            k++
        } else {
            k++
        }
        i++
    }

    return new_arr
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    originalRemove := OriginalRemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("originalRemove: ", originalRemove) //[0 1 2 3 4 6 7 8 9]

    originalRemove[0] = 999
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("originalRemove: ", originalRemove) //[999 1 2 3 4 6 7 8 9]
}

Wie Sie sehen können, verhält sich diese Ausgabe so, wie es die meisten Leute erwarten würden und wahrscheinlich, was die meisten Leute wollen. Das Ändern von originalRemoveverursacht keine Änderungen in allund das Entfernen und Zuweisen des Index verursacht auch keine Änderungen! Fantastisch!

Dieser Code ist jedoch etwas langwierig, sodass der obige Code geändert werden kann.

Eine richtige Antwort

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    ret := make([]int, 0)
    ret = append(ret, s[:index]...)
    return append(ret, s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeIndex := RemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]

    removeIndex[0] = 999
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
}

Fast identisch mit der ursprünglichen Lösung zum Entfernen von Indizes. Wir erstellen jedoch ein neues Slice, an das angehängt werden muss, bevor Sie zurückkehren.

Dies ist , wie Sie löschen Von einer Scheibe der golang Art und Weise . Sie müssen keine Funktion erstellen, die in den Anhang integriert ist. Probieren Sie es hier aus https://play.golang.org/p/QMXn9-6gU5P

z := []int{9, 8, 7, 6, 5, 3, 2, 1, 0}
fmt.Println(z)  //will print Answer [9 8 7 6 5 3 2 1 0]

z = append(z[:2], z[4:]...)
fmt.Println(z)   //will print Answer [9 8 5 3 2 1 0]

Aus dem Buch The Go Programming Language

Um ein Element aus der Mitte eines Slice zu entfernen und dabei die Reihenfolge der verbleibenden Elemente beizubehalten, schieben Sie die höher nummerierten Elemente mit copy um eins nach unten, um die Lücke zu füllen:

func remove(slice []int, i int) []int {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

Ich gehe wie folgt vor, um das Element in Slice zu entfernen. Dies hilft bei der Lesbarkeit für andere. Und auch unveränderlich.

func remove(items []string, item string) []string {
    newitems := []string{}

    for _, i := range items {
        if i != item {
            newitems = append(newitems, i)
        }
    }

    return newitems
}

Vielleicht können Sie diese Methode ausprobieren:

// DelEleInSlice delete an element from slice by index
//  - arr: the reference of slice
//  - index: the index of element will be deleted
func DelEleInSlice(arr interface{}, index int) {
    vField := reflect.ValueOf(arr)
    value := vField.Elem()
    if value.Kind() == reflect.Slice || value.Kind() == reflect.Array {
        result := reflect.AppendSlice(value.Slice(0, index), value.Slice(index+1, value.Len()))
        value.Set(result)
    }
}

Verwendung:

arrInt := []int{0, 1, 2, 3, 4, 5}
arrStr := []string{"0", "1", "2", "3", "4", "5"}
DelEleInSlice(&arrInt, 3)
DelEleInSlice(&arrStr, 4)
fmt.Println(arrInt)
fmt.Println(arrStr)

Ergebnis:

0, 1, 2, 4, 5
"0", "1", "2", "3", "5"

Vielleicht hilft dieser Code.

Es löscht ein Element mit einem bestimmten Index.

Nimmt das Array und den Index zum Löschen und gibt ein neues Array zurück, ähnlich der Append-Funktion.

func deleteItem(arr []int, index int) []int{
  if index < 0 || index >= len(arr){
    return []int{-1}
  }

    for i := index; i < len(arr) -1; i++{
      arr[i] = arr[i + 1]

    }

    return arr[:len(arr)-1]
}

Hier können Sie mit dem Code spielen: https://play.golang.org/p/aX1Qj40uTVs

Der beste Weg, dies zu tun, ist die Verwendung der Append-Funktion:

package main

import (
    "fmt"
)

func main() {
    x := []int{4, 5, 6, 7, 88}
    fmt.Println(x)
    x = append(x[:2], x[4:]...)//deletes 6 and 7
    fmt.Println(x)
}

https://play.golang.org/p/-EEFCsqse4u

Sie müssen nicht jedes einzelne Element überprüfen, es sei denn, Sie kümmern sich um den Inhalt und können Slice Append verwenden. Versuch es

pos := 0
arr := []int{1, 2, 3, 4, 5, 6, 7, 9}
fmt.Println("input your position")
fmt.Scanln(&pos)
/* you need to check if negative input as well */
if (pos < len(arr)){
    arr = append(arr[:pos], arr[pos+1:]...)
} else {
    fmt.Println("position invalid")
}

Hier ist das Spielplatzbeispiel mit Zeigern. https://play.golang.org/p/uNpTKeCt0sH

package main

import (
    "fmt"
)

type t struct {
    a int
    b string
}

func (tt *t) String() string{
    return fmt.Sprintf("[%d %s]", tt.a, tt.b)
}

func remove(slice []*t, i int) []*t {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

func main() {
    a := []*t{&t{1, "a"}, &t{2, "b"}, &t{3, "c"}, &t{4, "d"}, &t{5, "e"}, &t{6, "f"}}
    k := a[3]
    a = remove(a, 3)
    fmt.Printf("%v  ||  %v", a, k)
}