Étant donné le scénario dans lequel vous avez une fonction qui accepte t interface{}
. S'il est déterminé que la t
est une tranche, comment puis-je range
sur cette tranche? Je ne saurai pas le type entrant, tel que []string
, []int
ou []MyType
, au moment de la compilation.
func main() {
data := []string{"one","two","three"}
test(data)
moredata := []int{1,2,3}
test(data)
}
func test(t interface{}) {
switch reflect.TypeOf(t).Kind() {
case reflect.Slice:
// how do I iterate here?
for _,value := range t {
fmt.Println(value)
}
}
}
Go Playground Exemple: http://play.golang.org/p/DNldAlNShB
Bien, j’ai utilisé reflect.ValueOf
Et s’il s’agit d’une tranche, vous pouvez appeler Len()
et Index()
sur la valeur pour obtenir le len
de la tranche et élément à un index. Je ne pense pas que vous pourrez utiliser la gamme pour ce faire.
package main
import "fmt"
import "reflect"
func main() {
data := []string{"one","two","three"}
test(data)
moredata := []int{1,2,3}
test(moredata)
}
func test(t interface{}) {
switch reflect.TypeOf(t).Kind() {
case reflect.Slice:
s := reflect.ValueOf(t)
for i := 0; i < s.Len(); i++ {
fmt.Println(s.Index(i))
}
}
}
Go Playground Example: http://play.golang.org/p/gQhCTiwPAq
Vous n'avez pas besoin d'utiliser la réflexion si vous savez à quels types s'attendre. Vous pouvez utiliser un type switch , comme ceci:
package main
import "fmt"
func main() {
loop([]string{"one", "two", "three"})
loop([]int{1, 2, 3})
}
func loop(t interface{}) {
switch t := t.(type) {
case []string:
for _, value := range t {
fmt.Println(value)
}
case []int:
for _, value := range t {
fmt.Println(value)
}
}
}
il y a une exception à la manière dont l'interface {} se comporte, @Jeremy Wall a déjà donné un pointeur. si les données transmises sont définies initialement comme [] interface {}.
package main
import (
"fmt"
)
type interfaceSliceType []interface{}
var interfaceAsSlice interfaceSliceType
func main() {
loop(append(interfaceAsSlice, 1, 2, 3))
loop(append(interfaceAsSlice, "1", "2", "3"))
// or
loop([]interface{}{[]string{"1"}, []string{"2"}, []string{"3"}})
fmt.Println("------------------")
// and of course one such slice can hold any type
loop(interfaceSliceType{"string", 999, map[int]string{3: "three"}})
}
func loop(slice []interface{}) {
for _, elem := range slice {
switch elemTyped := elem.(type) {
case int:
fmt.Println("int:", elemTyped)
case string:
fmt.Println("string:", elemTyped)
case []string:
fmt.Println("[]string:", elemTyped)
case interface{}:
fmt.Println("map:", elemTyped)
}
}
}
sortie:
int: 1
int: 2
int: 3
string: 1
string: 2
string: 3
[]string: [1]
[]string: [2]
[]string: [3]
------------------
string: string
int: 999
map: map[3:three]