Comment supprimer des éléments de la liste en langue Go

Dans le langage Go, vous pouvez utiliser la fonction remove() pour supprimer des éléments de liste. La syntaxe est "list object.Remove(element)". L'élément de paramètre indique que l'élément de liste doit être supprimé. L'élément element ne peut pas être vide. S'il n'est pas vide, la valeur de l'élément supprimé sera renvoyée. S'il est vide, une exception sera signalée.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

go fournit un package list, similaire à la liste de python, qui peut stocker tout type de données et fournit l'API correspondante, comme suit :

type Element
    func (e *Element) Next() *Element
    func (e *Element) Prev() *Element
type List
    func New() *List
    func (l *List) Back() *Element
    func (l *List) Front() *Element
    func (l *List) Init() *List
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element
    func (l *List) Len() int
    func (l *List) MoveAfter(e, mark *Element)
    func (l *List) MoveBefore(e, mark *Element)
    func (l *List) MoveToBack(e *Element)
    func (l *List) MoveToFront(e *Element)
    func (l *List) PushBack(v interface{}) *Element
    func (l *List) PushBackList(other *List)
    func (l *List) PushFront(v interface{}) *Element
    func (l *List) PushFrontList(other *List)
    func (l *List) Remove(e *Element) interface{}

Parmi eux, la fonction remove() est utilisée pour supprimer des éléments de la liste, et les éléments supprimés ne peuvent pas être vides, s'ils sont vides, une exception sera signalée.

Remove(e *Element) interface{}

Paramètres	Description
e	Pour supprimer des éléments de la liste.

Valeur de retour

• Renvoie la valeur de l'élément supprimé.

Exemple d'éléments de suppression de liste

Exemple 1 :

package main
import (
	"container/list"
	"fmt"
)
func main() {
	//使用 Remove 在列表中删除元素
	listHaiCoder := list.New()
	listHaiCoder.PushFront("Hello")
	listHaiCoder.PushFront("HaiCoder")
	element := listHaiCoder.PushFront("Hello")
	removeEle := listHaiCoder.Remove(element)
	fmt.Println("RemoveElement =", removeEle)
	for i := listHaiCoder.Front(); i != nil; i = i.Next() {
		fmt.Println("Element =", i.Value)
	}
}

Analyse :

• Nous avons créé une liste listHaiCoder via list.New, puis avons utilisé la fonction PushFront pour insérer trois éléments dans l’élément de liste, puis utilisez la fonction Supprimer pour supprimer le dernier élément inséré.

• Enfin, nous imprimons l'élément supprimé et la liste supprimée. La fonction Remove renvoie la valeur de l'élément supprimé. En même temps, nous constatons que le dernier élément inséré a été supprimé avec succès de la liste.

Exemple 2 : Supprimer les éléments vides

package main
import (
	"container/list"
	"fmt"
)
func main() {
	//使用 Remove 在列表中删除空元素，报错
	listHaiCoder := list.New()
	listHaiCoder.PushFront("Hello")
	listHaiCoder.PushFront("HaiCoder")
	listHaiCoder.Remove(nil)
}

Une fois le programme exécuté, la sortie de la console est la suivante :

Connaissances étendues : list supprime tous les éléments

Avec l'API fournie par le package list , la liste est vraiment facile à utiliser C'est pratique, mais lors de l'utilisation, si vous ne faites pas attention, vous rencontrerez des pièges difficiles à trouver, ce qui fera que les résultats du programme ne seront pas ceux attendus. Le piège ici est le problème rencontré lors du parcours de la liste via une boucle for et de la suppression de tous les éléments. Par exemple, l'exemple de programme suivant crée une liste, stocke 0 à 3 dans l'ordre, puis parcourt la liste pour supprimer tous les éléments via une boucle for :

package main
import (
    "container/list"
    "fmt"
)
func main() {
    l := list.New()
    l.PushBack(0)
    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)
    fmt.Println("original list:")
    prtList(l)
    fmt.Println("deleted list:")
    for e := l.Front(); e != nil; e = e.Next() {
        l.Remove(e)
    }
    prtList(l)
}
func prtList(l *list.List) {
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Printf("%v ", e.Value)
    }
    fmt.Printf("n")
}

Le résultat de l'exécution du programme est le suivant :

original list:
0 1 2 3
deleted list:
1 2 3

Depuis le En sortie, nous pouvons savoir que les éléments de la liste n'ont pas été complètement supprimés, seul le premier élément 0 a été supprimé, ce qui est différent de l'idée originale. Selon les habitudes d'utilisation de Go, parcourir une liste et supprimer tous les éléments devraient être. écrit comme suit :

for e := l.Front(); e != nil; e = e.Next() {
    l.Remove(e)
}

Mais selon le résultat de l'exemple de code ci-dessus, ceci est La suppression de tous les éléments de la liste n'est pas valide, alors quel est le problème ? Grâce au mécanisme de la boucle for, nous pouvons savoir que puisque le premier élément a été supprimé mais que le deuxième élément n'a pas été supprimé, il faut que la condition de la deuxième boucle soit invalide, provoquant la sortie de la boucle, c'est-à-dire après l'exécution l'instruction suivante :

l.Remove(e)

e Should est nulle, donc la boucle se termine. Ajoutez une instruction print à vérifier avant l'instruction l.Remove(e) dans la boucle for. Par exemple, ajoutez l'instruction suivante :

fmt.Println("delete a element from list")

Le résultat de l'exécution du programme est le suivant :

original list:
0 1 2 3
deleted list:
delete a element from list
1 2 3

Comme vous pouvez le voir. n'est en effet bouclé qu'une seule fois et la boucle est terminée. Autrement dit, une fois l'instruction l.Remove(e) exécutée, e est égal à e.Next() car e.Next() est nul, e est nul et la boucle se termine. Pourquoi e.Next() est-il nul ? En visualisant le code source de la go list, il se présente comme suit :

// remove removes e from its list, decrements l.len, and returns e.
func (l *List) remove(e *Element) *Element {
    e.prev.next = e.next
    e.next.prev = e.prev
    e.next = nil // avoid memory leaks
    e.prev = nil // avoid memory leaks
    e.list = nil
    l.len--
    return e
}
// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
func (l *List) Remove(e *Element) interface{} {
    if e.list == l {
        // if e.list == l, l must have been initialized when e was inserted
        // in l or l == nil (e is a zero Element) and l.remove will crash
        l.remove(e)
    }
    return e.Value
}

On peut voir à partir du code source que lorsque l.Remove(e) est exécuté, la méthode l.remove(e) sera appelée en interne pour supprimer l'élément e. Afin d'éviter les fuites de mémoire, attribuera e.next et e.prev à nil, ce qui est la source du problème.

Le programme corrigé est le suivant :

package main
import (
    "container/list"
    "fmt"
)
func main() {
    l := list.New()
    l.PushBack(0)
    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)
    fmt.Println("original list:")
    prtList(l)
    fmt.Println("deleted list:")
    var next *list.Element
    for e := l.Front(); e != nil; e = next {
        next = e.Next()
        l.Remove(e)
    }
    prtList(l)
}
func prtList(l *list.List) {
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Printf("%v ", e.Value)
    }
    fmt.Printf("n")
}

Le résultat de l'exécution du programme est le suivant :

original list:
0 1 2 3
deleted list:

Comme vous pouvez le voir, tous les éléments de la liste ont été correctement supprimés.

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!