Введіть перетворювальні фрагменти інтерфейсів

Мені цікаво , чому Go does't неявно перетворити []Tв []interface{}коли він буде неявно перетворити Tв interface{}. Чи є щось нетривіальне в цьому перетворенні, чого я пропускаю?

Приклад:

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

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

go build скаржиться

не може використовувати рядок (type []) як інтерфейс type [] {} в аргументі функції

І якщо я спробую це зробити явно, те саме: b := []interface{}(a)скаржиться

не може конвертувати (type [] рядок) у тип [] інтерфейсу {}

Тому щоразу, коли мені потрібно робити це перетворення (яке, здається, виникає багато), я робив щось подібне:

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

Чи є кращий спосіб зробити це, або стандартні функції бібліотеки, щоб допомогти у цих перетвореннях? Дуже нерозумно писати 4 зайвих рядки коду кожного разу, коли я хочу викликати функцію, яка може взяти список, наприклад, ints або string.

У Go є загальне правило, що синтаксис не повинен приховувати складні / дорогі операції. Перетворення a stringв an interface{}робиться в O (1) час. Перетворення a []stringв interface{}також робиться в O (1) час, оскільки зріз все ще одне значення. Однак перетворення a []stringв an []interface{}- це O (n) час, оскільки кожен елемент фрагмента повинен бути перетворений в an interface{}.

Єдиним винятком із цього правила є перетворення рядків. При перетворенні a stringв і з a []byteабо a []rune, Go does O (n) працює, навіть якщо перетворення є "синтаксисом".

Не існує стандартної бібліотечної функції, яка б перетворила це перетворення на вас. Ви можете зробити одне з відображенням, але це буде повільніше, ніж три рядковий варіант.

Приклад з відображенням:

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
}

Хоча ваш найкращий варіант - просто використовувати рядки коду, які ви вказали у своєму запитанні:

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

Річ вам не вистачає в тому , що Tі interface{}яка має значення Tпо-різному трактують в пам'яті , тому не може бути тривіальним перетворити.

Змінна типу T- це лише її значення в пам'яті. Інформація про тип не пов'язана (у Go кожна змінна має один тип, відомий під час компіляції, а не під час виконання). Він представлений у пам'яті так:

• значення

Утримувана interface{}змінна типу Tпредставлена ​​в такій пам'яті

• покажчик на тип T
• значення

Так що, повертаючись до початкового питання: чому йдуть does't неявно перетворити []Tв []interface{}?

Перетворення []Tв []interface{}передбачає створення нового фрагмента interface {}значень, що є нетривіальною операцією, оскільки макет в пам'яті зовсім інший.

Ось офіційне пояснення: 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
}

Спробуйте interface{}замість цього. Щоб повернути як фрагмент, спробуйте

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

Перетворити interface{}в будь-який тип.

Синтаксис:

result := interface.(datatype)

Приклад:

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

Якщо вам потрібно більше скоротити код, ви можете створити новий тип для помічника

type Strings []string

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

тоді

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