Supprimer un élément dans une tranche

func main() {
    a := []string{"Hello1", "Hello2", "Hello3"}
    fmt.Println(a)
    //[Hello1 Hello2 Hello3]
    a = append(a[:0], a[1:]...)
    fmt.Println(a)
    //[Hello2 Hello3]
}

Comment supprimer cette astuce, avec l'ajout de la fonction de travail?

Il semblerait qu'il accapare tout avant que le premier élément (tableau vide)

En ajoutant tout ce qui est après le premier élément (position zéro)

Ce qui ne l' ... (dot dot dot) faire?

Vérifier code.google.com/p/go-wiki/wiki/SliceTricks
Pourquoi ne pas prendre un coup d'oeil à la langue spec? ... est expliqué là, dans le détail?
D'une part, absolument vrai (golang.org/ref/spec, tout le monde); de l'autre, il y a assez peu familier au sujet de ces idiomes pour la migration Pythoneux, etc. que je ne me dérange pas d'avoir une explication pour les autres à trouver.
Voir github.com/golang/go/wiki/SliceTricks

InformationsquelleAutor Jorge Olivero | 2014-07-29

257

Où a est la tranche, et i est l'indice de l'élément que vous souhaitez supprimer:
```
a = append(a[:i], a[i+1:]...)
```
... est la syntaxe pour les variadic arguments en Aller.

En gros, quand définition une fonction, il met tous les arguments que vous passer dans une tranche de ce type. En faisant cela, vous pouvez passer autant d'arguments que vous le souhaitez (par exemple, fmt.Println peut prendre autant d'arguments que vous voulez).

Maintenant, quand appel une fonction, ... fait le contraire: il déballe une tranche et les transmet comme séparer les arguments d'une variadic fonction.

De sorte que cette ligne n':
```
a = append(a[:0], a[1:]...)
```
est essentiellement:
```
a = append(a[:0], a[1], a[2])
```
Maintenant, vous demandez peut-être, pourquoi ne pas
```
a = append(a[1:]...)
```
Bien, la définition de la fonction de append est
```
func append(slice []Type, elems ...Type) []Type
```
Donc le premier argument doit être une tranche du type correct, le second argument est le variadic, de sorte que nous passons dans un vide tranche, et puis de décompresser le reste de la tranche de remplir les arguments.
- Ne pas vous obtenir hors de portée de l'exception si i est le dernier élément de la tranche? a = append(a[:i], a[i+1:]...)
- non, vous n'avez pas: play.golang.org/p/hcUEguyiTC
- Je ne reçois cette erreur lorsque vous travaillez avec mon tranches dans mon projet :/
- à partir de la spécification: "Pour des tableaux ou des chaînes, les indices sont dans la gamme de si 0 <= low <= high <= len(a), sinon, ils sont hors de portée." Peut-être que dans votre cas, la < faible; dans ce cas, vous obtiendrez l'erreur. (golang.org/ref/spec#Slice_expressions)
- merci! 🙂
- Quelle est la performance de cela? J'ai sérieusement espère que c'est pas de la création d'une toute nouvelle tranche sous le capot..
- Si je mettre en œuvre cette méthode dans un tableau de tableau, comment puis-je le faire?
- voulez-vous supprimer l'un des parents des tableaux, ou un élément à partir d'un des enfants de tableaux? Si le parent, append(a[:i], a[i+1:]...). Si un élément de l'enfant, append(a[i][:j], a[i][j+1:]...)
- Je pense que vous avez essayé de supprimer des éléments de la tranche à l'intérieur d'une boucle. Donc, vous devez être prudent avec les index.
InformationsquelleAutor dave
42

Il y a deux options:

Un: vous Vous souciez de soutènement de la matrice de commande:
```
a = append(a[:i], a[i+1:]...)
//or
a = a[:i+copy(a[i:], a[i+1:])]
```
B: Vous n'avez pas de soins de maintien de l'ordre (ce qui est probablement le plus rapide):
```
a[i] = a[len(a)-1] //Replace it with the last one. CAREFUL only works if you have enough elements.
a = a[:len(a)-1]   //Chop off the last one.
```
Voir le lien pour voir les implications re fuites de mémoire si votre tableau est de pointeurs.

https://github.com/golang/go/wiki/SliceTricks
- Ce qui est intéressant, mais pas vraiment répondre à la question
- C'est sympa, mais ça aurait été mieux si il peut supprimer le seul élément dans le tableau
- Juste un heads-up, a tenté d'utiliser la première de b (remplacer par le dernier élément) n'est bien évidemment pas le travail si vous tentez de supprimer le dernier élément dans la tranche lol
InformationsquelleAutor Chris
8

Plutôt que de penser que des indices dans le [a:]-, [:b]- et [a:b]notations comme indice de l'élément, pensez à eux comme les indices des lacunes autour et entre les éléments, à commencer par l'écart indexé 0 avant de l'élément indexé comme 0.

Regardant seulement le bleu, il est beaucoup plus facile de voir ce qui se passe: [0:3] enferme tout, [3:3] est vide et [1:2] donnerait {"B"}. Puis [a:] est juste la version courte de [a:len(arrayOrSlice)], [:b] la version courte de [0:b] et [:] la version courte de [0:len(arrayOrSlice)]. Ce dernier est couramment utilisé pour transformer un tableau en une tranche en cas de besoin.

InformationsquelleAutor Zyl
5

... est la syntaxe pour les variadic arguments.

Je pense qu'il est mis en œuvre par le compilateur à l'aide de la tranche de[]Type), tout comme la fonction append :
```
func append(slice []Type, elems ...Type) []Type
```
lorsque vous utilisez "elems" dans "ajouter", en fait, c'est une tranche([]type).
Donc "a = append(a[:0], a[1:]...)" signifie "a = append(a[0:0], a[1:])"

a[0:0] est une tranche qui n'a rien

a[1:] est "Hello2 Hello3"

C'est la façon dont il fonctionne
- a[0:0] n'est pas nil mais une tranche de longueur 0. a[0:0] sera uniquement être nil si a est nil.
- oh oui, merci pour la correction
InformationsquelleAutor frank.lin
3

Dans golang wiki il montrer quelques trucs pour la tranche, y compris de supprimer un élément de la tranche.

Lien: entrez description du lien ici

Par exemple un est le morceau dont vous voulez supprimer le numéro, j'ai élément.
```
a = append(a[:i], a[i+1:]...)
```
OU
```
a = a[:i+copy(a[i:], a[i+1:])]
```
InformationsquelleAutor g10guang
2

Ou depuis que vous essayez de trouver l'indice de l'élément qui doit être supprimé de toute façon,
```
//na = new a, da = a that's to be deleted
var na []string
for _, v := range a {
    if v == da {
        continue
    } else {
        na = append(na, v)
    }
}
a = na
```
Ok jamais l'esprit. Bonne réponse pour le sujet, mais mauvaise réponse à la question du corps.

InformationsquelleAutor

Je suis à l'obtention d'un indice en dehors de la plage d'erreur avec la accepté de répondre à la solution.
Raison:
Lorsque le début de la plage, il n'est pas itération de la valeur, un par un, il est itérer par l'index.
Si vous avez modifié une tranche alors qu'il est à portée, il va induire un problème.

Vieille Réponse:

chars := []string{"a", "a", "b"}

for i, v := range chars {
    fmt.Printf("%+v, %d, %s\n", chars, i, v)
    if v == "a" {
        chars = append(chars[:i], chars[i+1:]...)
    }
}
fmt.Printf("%+v", chars)

Prévu :

[a a b], 0, a
[a b], 0, a
[b], 0, b
Result: [b]

Réel:

//Autual
[a a b], 0, a
[a b], 1, b
[a b], 2, b
Result: [a b]

Façon Correcte (Solution):

chars := []string{"a", "a", "b"}

for i := 0; i < len(chars); i++ {
    if chars[i] == "a" {
        chars = append(chars[:i], chars[i+1:]...)
        i-- //form the remove item index to start iterate next item
    }
}

fmt.Printf("%+v", chars)

Source: https://dinolai.com/notes/golang/golang-delete-slice-item-in-range-problem.html

InformationsquelleAutor timotew

Vous devez vous connecter pour publier un commentaire.