phạm vi trên giao diện {} lưu trữ một lát

Đưa ra tình huống mà bạn có một hàm chấp nhận t interface{}. Nếu nó được xác định rằng đó tlà một lát cắt, làm thế nào để tôi rangevượt qua lát cắt đó?

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)
        }
    }
}

Ví dụ về Go Playground: http://play.golang.org/p/DNldAlNShB

Tôi đã sử dụng reflect.ValueOfvà sau đó nếu nó là một lát cắt, bạn có thể gọi Len()và Index()trên giá trị để lấylen lát cắt và phần tử tại một chỉ mục. Tôi không nghĩ rằng bạn sẽ có thể sử dụng hoạt động phạm vi để làm điều này.

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))
        }
    }
}

Ví dụ về Go Playground: http://play.golang.org/p/gQhCTiwPAq

Bạn không cần phải sử dụng phản xạ nếu bạn biết loại nào mong đợi. Bạn có thể sử dụng một công tắc loại , như sau:

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)
        }
    }
}

Kiểm tra mã trên sân chơi .

có một ngoại lệ từ cách giao diện {} hoạt động, @Jeremy Wall đã đưa ra con trỏ. nếu dữ liệu được truyền vào được xác định là [] giao diện {} ban đầu.

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)
        }
    }
}

đầu ra:

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]

thử nó ra