Ketik irisan antarmuka yang dikonversi

Saya ingin tahu mengapa Go tidak secara implisit dikonversi []Tke []interface{}ketika secara implisit dikonversi Tke interface{}. Apakah ada sesuatu yang tidak sepele tentang konversi ini yang saya lewatkan?

Contoh:

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

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

go build mengeluh

tidak dapat menggunakan (ketik [] string) sebagai tipe [] antarmuka {} dalam argumen fungsi

Dan jika saya mencoba melakukannya secara eksplisit, hal yang sama: b := []interface{}(a)mengeluh

tidak dapat mengonversi string (ketik []) ke antarmuka [] {}

Jadi setiap kali saya perlu melakukan konversi ini (yang tampaknya banyak muncul), saya telah melakukan sesuatu seperti ini:

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

Apakah ada cara yang lebih baik untuk melakukan ini, atau fungsi perpustakaan standar untuk membantu dengan konversi ini? Tampaknya konyol untuk menulis 4 baris kode tambahan setiap kali saya ingin memanggil fungsi yang dapat mengambil daftar misalnya int atau string.

Di Go, ada aturan umum bahwa sintaksis tidak boleh menyembunyikan operasi yang kompleks / mahal. Konversi a stringke a interface{}dilakukan dalam O (1) waktu. Konversi a []stringke a interface{}juga dilakukan dalam waktu O (1) karena irisan masih satu nilai. Namun, mengubah a []stringmenjadi waktu []interface{}O (n) karena setiap elemen slice harus dikonversi menjadi interface{}.

Satu-satunya pengecualian untuk aturan ini adalah mengonversi string. Saat mengonversi a stringke dan dari a []byteatau a []rune, Go do O (n) berfungsi meskipun konversi adalah "sintaksis".

Tidak ada fungsi perpustakaan standar yang akan melakukan konversi ini untuk Anda. Anda dapat membuat satu dengan pantulan, tetapi itu akan lebih lambat dari opsi tiga baris.

Contoh dengan refleksi:

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
}

Opsi terbaik Anda adalah menggunakan baris kode yang Anda berikan dalam pertanyaan Anda:

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

Hal yang Anda lewatkan adalah bahwa Tdan interface{}yang memiliki nilai Tmemiliki representasi yang berbeda dalam memori sehingga tidak dapat dikonversi secara sepele.

Variabel tipe Thanya nilainya dalam memori. Tidak ada informasi tipe terkait (dalam Go setiap variabel memiliki tipe tunggal yang diketahui pada waktu kompilasi bukan pada saat run time). Itu direpresentasikan dalam memori seperti ini:

• nilai

Sebuah interface{}memegang variabel jenis Tdirepresentasikan dalam memori seperti ini

• pointer untuk mengetik T
• nilai

Jadi kembali ke pertanyaan awal Anda: mengapa pergi tidak secara implisit dikonversi []Tke []interface{}?

Konversi []Tke []interface{}akan melibatkan pembuatan irisan interface {}nilai baru yang merupakan operasi non-sepele karena tata letak dalam memori benar-benar berbeda.

Berikut adalah penjelasan resmi: 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
}

Coba interface{}saja. Untuk membuang kembali sebagai irisan, coba

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

Konversikan interface{}ke dalam jenis apa pun.

Sintaksis:

result := interface.(datatype)

Contoh:

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

Jika Anda membutuhkan lebih banyak korslet kode, Anda dapat membuat tipe baru untuk helper

type Strings []string

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

kemudian

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