Wie kann man in Go so etwas wie eine Liste von void * (oder Variantentypen) erreichen?

Ich bin ein Go-Anfänger, der Golang seit ungefähr 3 Tagen studiert (obwohl es noch neu ist). Mit Lua konnten Sie einer Tabelle verschiedene Datentypen hinzufügen, aber was ist mit Go? Nach dem Studium von Go habe ich einige Nachforschungen angestellt, aber ich konnte die Antwort nicht finden, deshalb schreibe ich sie hier.

• Ich lerne die Go-Sprache. Bitte lassen Sie mich wissen, ob es einen empfohlenen Weg gibt, sie so zu schreiben.

Variantentyp in Go

Nach vielen Recherchen scheint es, dass der Variantentyp in Go die Schnittstelle {} sein sollte. Ich bin der Seite "Beeilen Sie sich, um die Go lang # 6-Benutzeroberfläche zu lernen" dankbar, die auf sehr leicht verständliche Weise erklärt wird.

damit,

variant.go

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

Und wenn Sie es ausführen,

resut-variant.txt

s=1.230000
s=hello

Und Sie können bestätigen, dass Sie mit Sicherheit alles ersetzen können.

Liste der Variantentypen in Go

In Go werden Arrays mit variabler Länge als Slices bezeichnet. Wenn ein Typ durch den Buchstaben T dargestellt wird, ist der Slice-Typ von T [] T. Es scheint also, dass der Slice-Typ, der jeden Typ speichern kann, als var list \ [] interface \ {} geschrieben werden sollte. In der Tat scheint es zu funktionieren.

variant-slice.go

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

Erweitert: Erstellen Sie einen Stapel, der alles pushen und platzen kann

Deshalb ist es eine erweiterte Version. Definieren Sie einen Stapeltyp und versuchen Sie, verschiedene Datentypen zu verschieben und zu löschen.

Erstens ist die Definition des Stapels. Pop gibt zwei Werte zurück, wobei der zweite Rückgabewert angibt, ob er erfolgreich (= true) oder bei leerem Stapel (= false) gelöscht wurde.

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
}

Für den Pop aus dem Slice habe ich auf den Pop aus "SliceTricks" verwiesen (oder besser gesagt, so wie er ist ...).

Als nächstes kommt das Testprogramm.

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")
    }
}

Wenn ich es laufen lasse,

result-test-stack.txt

aaa
10
Data stack is empty

Zeigt an, dass Ganzzahlen und Zeichenfolgen auf denselben Stapel verschoben und abgelegt werden können.

Zusammenfassung

Wir haben festgestellt, dass Variantentypen in go durch die Nutzung einer leeren Schnittstelle erreicht werden können und dass Slices auch durch normales Schreiben erreicht werden können. Wenn Sie einen Stapel mit Multithreading oder Goroutine teilen möchten, müssen Sie möglicherweise mit Mutex sperren / entsperren, aber die allgemeine Weisheit in C oder C # funktioniert möglicherweise nicht. Ich würde gerne viel darüber lernen.