Supprimer un élément dans une tranche

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

Comment fonctionne cette suppression avec la fonction append?

Il semblerait que cela prenne tout avant le premier élément (tableau vide)

Puis tout append après le premier élément (position zéro)

Que fait le … (dot dot dot)?

a est la tranche et i est l’index de l’élément que vous souhaitez supprimer:

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

... est la syntaxe des arguments variadiques dans Go.

Fondamentalement, lors de la définition d’ une fonction, elle place tous les arguments que vous transmettez dans une seule tranche de ce type. En faisant cela, vous pouvez transmettre autant d’arguments que vous le souhaitez (par exemple, fmt.Println peut prendre autant d’arguments que vous le souhaitez).

Maintenant, lorsque vous appelez une fonction, ... fait le contraire: elle décompresse une tranche et la transmet sous forme d’arguments séparés à une fonction variadique.

Alors qu’est-ce que cette ligne fait:

 a = append(a[:0], a[1:]...) 

est essentiellement:

 a = append(a[:0], a[1], a[2]) 

Maintenant, vous vous demandez peut-être, pourquoi ne pas faire

 a = append(a[:1]...) 

Eh bien, la définition de 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, nous passons donc une tranche vide, puis décompressez le rest de la tranche pour remplir les arguments.

Il y a deux options:

A: Vous tenez à conserver l’ordre du tableau:

 a = append(a[:i], a[i+1:]...) // or a = a[:i+copy(a[i:], a[i+1:])] 

B: Vous ne vous souciez pas de conserver l’ordre (c’est probablement plus rapide):

 a[i] = a[len(a)-1] // Replace it with the last one. a = a[:len(a)-1] // Chop off the last one. 

Voir le lien pour voir les implications de memory leaks si votre baie est constituée de pointeurs.

https://github.com/golang/go/wiki/SliceTricks

… est la syntaxe des arguments variadiques.

Je pense qu’il est implémenté par le complicateur en utilisant slice ( []Type) , tout comme la fonction append:

 func append(slice []Type, elems ...Type) []Type 

quand vous utilisez “elems” dans “append”, en fait c’est une tranche ([]). 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”

Voilà comment cela fonctionne

Dans le wiki de golang, il affiche des astuces pour les tranches, y compris la suppression d’un élément de la tranche.

Lien: entrez la description du lien ici

Par exemple, a est la tranche que vous souhaitez supprimer l’élément numéro i.

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

OU

 a = a[:i+copy(a[i:], a[i+1:])] 

Ou puisque vous essayez de trouver l’index de l’élément à supprimer de toute façon,

 // na = new a, da = a that's to be deleted var na []ssortingng for _, v := range a { if v == da { continue } else { na = append(na, v) } } a = na 

OK ne t’inquiète pas. Bonne réponse pour le sujet, mais une mauvaise réponse pour le corps de la question.