Geben Sie konvertierende Schnittstellenschnitte ein

Ich bin neugierig , warum implizit Go does't konvertieren []Tzu , []interface{}wenn es implizit konvertieren Tzu interface{}. Gibt es etwas nicht Triviales an dieser Konvertierung, das mir fehlt?

Beispiel:

func foo([]interface{}) { /* do something */ }

func main() {
    var a []string = []string{"hello", "world"}
    foo(a)
}

go build beschwert sich

kann keine (Typ [] Zeichenfolge) als Typ [] Schnittstelle {} im Funktionsargument verwenden

Und wenn ich es explizit versuche, dasselbe: sich b := []interface{}(a)beschweren

Ein (Typ [] String) kann nicht in Typ [] Schnittstelle {} konvertiert werden

Jedes Mal, wenn ich diese Konvertierung durchführen muss (was sehr häufig vorkommt), habe ich so etwas gemacht:

b = make([]interface{}, len(a), len(a))
for i := range a {
    b[i] = a[i]
}

Gibt es eine bessere Möglichkeit, dies zu tun, oder Standardbibliotheksfunktionen, um bei diesen Konvertierungen zu helfen? Es scheint irgendwie albern, jedes Mal, wenn ich eine Funktion aufrufen möchte, die eine Liste von z. B. Ints oder Strings aufnehmen kann, 4 zusätzliche Codezeilen zu schreiben.

In Go gibt es eine allgemeine Regel, nach der die Syntax komplexe / kostspielige Vorgänge nicht verbergen soll. Die Konvertierung von a stringin a interface{}erfolgt in O (1) -Zeit. Das Konvertieren von a []stringin a interface{}erfolgt ebenfalls in O (1) -Zeit, da ein Slice immer noch einen Wert hat. Die Konvertierung von a []stringin a []interface{}ist jedoch O (n), da jedes Element des Slice in eine konvertiert werden muss interface{}.

Die einzige Ausnahme von dieser Regel ist das Konvertieren von Zeichenfolgen. Beim Konvertieren von a stringnach und von a []byteoder a []runefunktioniert Go mit O (n), obwohl Konvertierungen "Syntax" sind.

Es gibt keine Standardbibliotheksfunktion, die diese Konvertierung für Sie durchführt. Sie könnten eine mit Reflect erstellen, diese ist jedoch langsamer als die Option mit drei Zeilen.

Beispiel mit Reflexion:

func InterfaceSlice(slice interface{}) []interface{} {
    s := reflect.ValueOf(slice)
    if s.Kind() != reflect.Slice {
        panic("InterfaceSlice() given a non-slice type")
    }

    ret := make([]interface{}, s.Len())

    for i:=0; i<s.Len(); i++ {
        ret[i] = s.Index(i).Interface()
    }

    return ret
}

Ihre beste Option ist jedoch, nur die Codezeilen zu verwenden, die Sie in Ihrer Frage angegeben haben:

b := make([]interface{}, len(a))
for i := range a {
    b[i] = a[i]
}

Das , was Sie fehlt, ist , dass Tund interface{}die einen Wert von hält Thaben unterschiedliche Darstellungen im Speicher so nicht triviale Weise umgewandelt werden können.

Eine Variable vom Typ Tist nur ihr Wert im Speicher. Es sind keine Typinformationen zugeordnet (in Go hat jede Variable einen einzelnen Typ, der zur Kompilierungszeit und nicht zur Laufzeit bekannt ist). Es wird im Gedächtnis wie folgt dargestellt:

• Wert

Ein interface{}Halten einer Variablen vom Typ Twird im Speicher wie folgt dargestellt

• Zeiger auf Typ T
• Wert

Kommen wir also zu Ihrer ursprünglichen Frage zurück: Warum konvertiert go nicht implizit []Tzu []interface{}?

Das Konvertieren []Tin []interface{}würde das Erstellen einer neuen Wertscheibe umfassen interface {}, was nicht trivial ist, da das speicherinterne Layout völlig anders ist.

Hier ist die offizielle Erklärung: https://github.com/golang/go/wiki/InterfaceSlice

var dataSlice []int = foo()
var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))
for i, d := range dataSlice {
    interfaceSlice[i] = d
}

Versuchen Sie es interface{}stattdessen. Versuchen Sie es, um es als Scheibe zurückzuwerfen

func foo(bar interface{}) {
    s := bar.([]string)
    // ...
}

interface{}In einen beliebigen Typ konvertieren .

Syntax:

result := interface.(datatype)

Beispiel:

var employee interface{} = []string{"Jhon", "Arya"}
result := employee.([]string)   //result type is []string.

Falls Sie mehr Kurzschluss für Ihren Code benötigen, können Sie einen neuen Typ für den Helfer erstellen

type Strings []string

func (ss Strings) ToInterfaceSlice() []interface{} {
    iface := make([]interface{}, len(ss))
    for i := range ss {
        iface[i] = ss[i]
    }
    return iface
}

dann

a := []strings{"a", "b", "c", "d"}
sliceIFace := Strings(a).ToInterfaceSlice()