Comment réaliser quelque chose comme une liste de void * (ou de type de variante) dans Go?

Je suis un débutant en Go qui étudie le Golang depuis environ 3 jours (bien que ce soit encore nouveau). Lua vous a permis d'ajouter différents types de données à une table, mais qu'en est-il de Go? Après avoir étudié le Go, j'ai fait des recherches, mais je n'ai pas trouvé de réponse, je vais donc l'écrire ici.

• J'étudie la langue Go, alors faites-moi savoir s'il existe une façon recommandée de l'écrire comme ça.

Type de variante dans Go

Après de nombreuses recherches, il semble que le type de variante dans Go devrait être interface {}. Je suis reconnaissant à la page "Dépêchez-vous d'apprendre l'interface Go lang # 6" qui explique d'une manière très facile à comprendre.

alors,

variant.go

var s interface{}
s=1.23
fmt.Printf("s=%f\n",s.(float64))
s="hello"
fmt.Printf("s=%s\n",s.(string))

Si vous écrivez et exécutez,

resut-variant.txt

s=1.230000
s=hello

Et vous pouvez confirmer que vous pouvez certainement remplacer n'importe quoi.

Liste des types de variantes dans Go

Dans Go, les tableaux de longueur variable sont appelés tranches. Lorsqu'un type est représenté par la lettre T, le type de tranche de T est [] T. Ainsi, il semble que le type de tranche qui peut stocker n'importe quel type devrait être écrit comme var list \ [] interface \ {}. En fait, cela semble fonctionner.

variant-slice.go

var list []interface{}
list=append(list,10)
fmt.Printf("list[0]=%d\n",list[0].(int))

Avancé: créez une pile qui peut pousser et faire sauter n'importe quoi

C'est pourquoi c'est une version avancée. Définissez un type de pile et essayez de pousser et de faire apparaître divers types de données.

La première est la définition de la pile. Pop renvoie deux valeurs de sorte que la deuxième valeur de retour indique si Pop a réussi (= true) ou si la pile était vide mais Popped (= false).

stack.go

package main

type Stack struct {
    index int
    dataBody []interface{}
}

func (self *Stack) Push(inData interface{}) {
    self.index++
    self.dataBody=append(self.dataBody,inData)
}

func (self *Stack) Pop() (interface{},bool) {
    if self.index<=0 {
        return nil,false
    }
    var ret interface{}
    ret,self.dataBody=self.dataBody[len(self.dataBody)-1],
                      self.dataBody[:len(self.dataBody)-1]
    self.index--
    return ret,true
}

Pour le Pop de la tranche, j'ai fait référence au Pop de "SliceTricks" (ou plutôt, tel quel ...).

Vient ensuite le programme de test.

test-stack.go

package main

import "fmt"

var DS Stack

func main() {
    DS.Push(10)
    DS.Push("aaa")
    t,_:=DS.Pop()
    fmt.Printf("%s\n",t.(string))
    t,_=DS.Pop()
    fmt.Printf("%d\n",t.(int))
    t,ok:=DS.Pop()
    if ok {
        fmt.Println("OK")
    } else {
        fmt.Println("Data stack is empty")
    }
}

Quand je l'exécute,

result-test-stack.txt

aaa
10
Data stack is empty

Montre que les entiers et les chaînes peuvent être poussés et placés sur la même pile.

Résumé

Nous avons constaté que le type de variante dans go peut être obtenu en utilisant une interface vide, et que la tranche peut également être obtenue en l'écrivant normalement. Si vous souhaitez partager une pile avec multithreading ou goroutine, vous devrez peut-être verrouiller / déverrouiller avec mutex, mais la sagesse commune en C ou C # peut ne pas fonctionner, alors c'est à peu près tout. J'aimerais beaucoup étudier.