Convert [] stringa [] interfaccia {}

Question

Voglio solo scrivere del codice in questo modo:

func (w Writer) WriteVString(strs []string) (int, error) { 
    return writeV(func(index int, str interface{}) (int, error) { 
     return w.WriteString(str.(string)) 
    }, strs) // it doesn't work 
} 

func (w Writer) WriteV(bs [][]byte) (int, error) { 
    return writeV(func(index int, b interface{}) (int, error) { 
     return w.Write(b.([]byte)) 
    }, []interface{}{bs...}) // it also can't be compiled 
} 
type writeFunc func(int, interface{}) (int, error) 

func writeV(fn writeFunc, slice []interface{}) (n int, err error) { 
    var m int 
    for index, s := range slice { 
     if m, err = fn(index, s); err != nil { 
      break 
     } 
     n += m 
    ) 
    return 
} 

ho pensato interface{} può rappresentare qualsiasi tipo, in modo da []interface può anche rappresentare qualsiasi []type prima, ora lo so Ho torto, []type è un tipo intero, non può essere considerato come []interface{}.

Quindi, qualcuno può aiutarmi a far funzionare questi codici o qualsiasi altra soluzione ?.

PS: so che []byte o string possibile convertire in altro, ma in realtà non è la mia intenzione, può esserci qualsiasi altro tipo, piuttosto che []byte e string.

Answer 1

ora so che ho torto, []type è un tipo intero, non può essere considerato come []interface{}.

Sì, e questo è perché interface{} è un tipo proprio (e non un "alias" per qualsiasi altro tipo).
Come detto in "what is the meaning of interface{} in golang?" (se v è una variabile interface{}): Gopher

principianti sono portati a credere che “v è di qualsiasi tipo”, ma questo è sbagliato.
v non è di alcun tipo; è del tipo interface{}.

Il FAQ mentions

non hanno la stessa rappresentazione in memoria.

È necessario copiare gli elementi singolarmente nella sezione di destinazione.
Questo esempio converte una fetta di int in una fetta di interface{}:

t := []int{1, 2, 3, 4} 
s := make([]interface{}, len(t)) 
for i, v := range t { 
    s[i] = v 
}