Wpisz konwertujące plastry interfejsów

Jestem ciekaw dlaczego Go does't niejawnie przekonwertować []Tdo []interface{}kiedy będzie niejawnie konwertować Tdo interface{}. Czy w tej konwersji brakuje czegoś nietrywialnego?

Przykład:

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

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

go build narzeka

nie można użyć (typu [] ciągu) jako interfejsu typu [] {} w argumencie funkcji

A jeśli spróbuję to zrobić wyraźnie, to samo: b := []interface{}(a)narzeka

nie można przekonwertować ciągu (typ []) na interfejs typu [] {}

Więc za każdym razem, gdy muszę wykonać tę konwersję (która wydaje się często pojawiać), robiłem coś takiego:

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

Czy jest lepszy sposób, aby to zrobić, lub standardowe funkcje biblioteki, aby pomóc w tych konwersjach? Głupio wydaje się pisać 4 dodatkowe wiersze kodu za każdym razem, gdy chcę wywołać funkcję, która może przyjąć listę np. Ints lub łańcuchów.

W Go obowiązuje ogólna zasada, że ​​składnia nie powinna ukrywać skomplikowanych / kosztownych operacji. Konwersja a stringna an interface{}odbywa się w czasie O (1). Konwersja a []stringna an interface{}odbywa się również w czasie O (1), ponieważ plasterek jest nadal jedną wartością. Jednak konwersja a []stringna an []interface{}to czas O (n), ponieważ każdy element wycinka musi zostać przekonwertowany na an interface{}.

Jedynym wyjątkiem od tej reguły jest konwersja ciągów. Podczas konwersji a stringna a []bytelub a []runeGo działa O (n), nawet jeśli konwersje są „składniowe”.

Nie ma standardowej funkcji biblioteki, która wykonałaby tę konwersję za Ciebie. Możesz zrobić jeden z odbiciem, ale byłby wolniejszy niż opcja trzech linii.

Przykład z refleksją:

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
}

Najlepszą opcją jest jednak użycie wierszy kodu podanych w pytaniu:

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

Brakuje tego, Ta interface{}która ma wartość polegającą na tym, Tże ma różne reprezentacje w pamięci, więc nie można jej trywialnie przekonwertować.

Zmienna typu Tjest tylko jej wartością w pamięci. Brak powiązanych informacji o typie (w Go każda zmienna ma jeden typ znany w czasie kompilacji, a nie w czasie wykonywania). Jest on reprezentowany w pamięci w następujący sposób:

• wartość

Trzymanie interface{}zmiennej typu Tjest reprezentowane w pamięci w ten sposób

• wskaźnik do pisania T
• wartość

Wracając do pierwotnego pytania: dlaczego go nie jest domyślnie konwertowany []Tna []interface{}?

Konwersja []T na []interface{}wymagałaby utworzenia nowego wycinka interface {}wartości, co nie jest trywialną operacją, ponieważ układ w pamięci jest zupełnie inny.

Oto oficjalne wyjaśnienie: 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
}

Spróbuj interface{}zamiast tego. Aby odrzucić jako plasterek, spróbuj

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

Konwertuj interface{}na dowolny typ.

Składnia:

result := interface.(datatype)

Przykład:

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

Jeśli potrzebujesz więcej skrótów kodu, możesz utworzyć nowy typ pomocnika

type Strings []string

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

następnie

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