Kiểu chuyển đổi lát giao diện

Tôi tò mò tại sao Go không hoàn toàn chuyển đổi []Tthành []interface{}khi nào nó sẽ hoàn toàn chuyển đổi Tthành interface{}. Có điều gì không tầm thường về chuyển đổi này mà tôi đang thiếu?

Thí dụ:

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

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

go build phàn nàn

không thể sử dụng một (kiểu [] chuỗi) làm kiểu [] giao diện {} trong đối số hàm

Và nếu tôi cố gắng làm điều đó một cách rõ ràng, điều tương tự: b := []interface{}(a)phàn nàn

không thể chuyển đổi một (loại [] chuỗi) sang loại [] giao diện {}

Vì vậy, mỗi khi tôi cần thực hiện chuyển đổi này (dường như xuất hiện rất nhiều), tôi đã làm một việc như thế này:

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

Có cách nào tốt hơn để làm điều này hoặc các chức năng thư viện tiêu chuẩn để trợ giúp với các chuyển đổi này không? Có vẻ hơi ngớ ngẩn khi viết thêm 4 dòng mã mỗi khi tôi muốn gọi một hàm có thể lấy danh sách ví dụ ints hoặc chuỗi.

Trong Go, có một quy tắc chung là cú pháp không được ẩn các hoạt động phức tạp / tốn kém. Chuyển đổi a stringthành an interface{}được thực hiện trong thời gian O (1). Chuyển đổi a []stringthành an interface{}cũng được thực hiện trong thời gian O (1) vì một lát vẫn là một giá trị. Tuy nhiên, chuyển đổi a []stringthành an []interface{}là thời gian O (n) vì mỗi phần tử của lát phải được chuyển đổi thành an interface{}.

Một ngoại lệ cho quy tắc này là chuyển đổi chuỗi. Khi chuyển đổi stringthành và từ a []bytehoặc a []rune, Go (O) hoạt động ngay cả khi chuyển đổi là "cú pháp".

Không có chức năng thư viện tiêu chuẩn sẽ thực hiện chuyển đổi này cho bạn. Bạn có thể tạo một phản xạ, nhưng nó sẽ chậm hơn tùy chọn ba dòng.

Ví dụ với sự phản ánh:

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
}

Mặc dù vậy, lựa chọn tốt nhất của bạn chỉ là sử dụng các dòng mã bạn đã đưa ra trong câu hỏi của mình:

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

Điều bạn đang thiếu là Tvà interface{}nắm giữ một giá trị Tđã trình bày khác nhau trong bộ nhớ do đó không thể được chuyển đổi trivially.

Một biến kiểu Tchỉ là giá trị của nó trong bộ nhớ. Không có thông tin loại liên quan (trong Go mỗi biến có một loại duy nhất được biết tại thời gian biên dịch không phải lúc chạy). Nó được biểu diễn trong bộ nhớ như thế này:

• giá trị

Một interface{}biến có kiểu biến Tđược biểu diễn trong bộ nhớ như thế này

• con trỏ để gõ T
• giá trị

Vì vậy, quay trở lại câu hỏi ban đầu của bạn: tại sao đi không hoàn toàn chuyển đổi []Tthành []interface{}?

Chuyển đổi []Tsang []interface{}sẽ liên quan đến việc tạo ra một lát interface {}giá trị mới, đây là một hoạt động không tầm thường vì cách bố trí trong bộ nhớ hoàn toàn khác nhau.

Dưới đây là lời giải thích chính thức: 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
}

Hãy thử interface{}thay thế. Để quay lại như lát, hãy thử

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

Chuyển đổi interface{}thành bất kỳ loại.

Cú pháp:

result := interface.(datatype)

Thí dụ:

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

Trong trường hợp bạn cần rút ngắn nhiều mã hơn, bạn có thể tạo loại mới cho trình trợ giúp

type Strings []string

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

sau đó

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