Question

我有一个功能。

func doSome(v interface{}) {

}

如果我通过指针将一片struct传递给函数，该函数必须填充切片。

type Color struct {
}
type Brush struct {
}

var c []Color
doSome(&c) // after с is array contains 3 elements type Color

var b []Brush
doSome(&b) // after b is array contains 3 elements type Brush

也许我需要使用反射，但是如何？

Answer 1

func doSome(v interface{}) {

    s := reflect.TypeOf(v).Elem()
    slice := reflect.MakeSlice(s, 3, 3)
    reflect.ValueOf(v).Elem().Set(slice)

}

Answer 2

typeswitch !!

package main
import "fmt"

func doSome(v interface{}) {
  switch v := v.(type) {
  case *[]Color:
    *v = []Color{Color{0}, Color{128}, Color{255}}
  case *[]Brush:
    *v = []Brush{Brush{true}, Brush{true}, Brush{false}}
  default:
    panic("unsupported doSome input")
  }
}  

type Color struct {
    r uint8
}
type Brush struct {
    round bool
}

func main(){
    var c []Color
    doSome(&c) // after с is array contains 3 elements type Color

    var b []Brush
    doSome(&b) // after b is array contains 3 elements type Brush

    fmt.Println(b)
    fmt.Println(c)

}

Answer 3

Go没有泛型。你的可能性是：

接口调度

type CanTraverse interface {
    Get(int) interface{}
    Len() int
}
type Colours []Colour

func (c Colours) Get(i int) interface{} {
    return c[i]
}
func (c Colours) Len() int {
    return len(c)
}
func doSome(v CanTraverse) {
    for i := 0; i < v.Len; i++ {
        fmt.Println(v.Get(i))
    }
}

键入开关为@Plato建议

func doSome(v interface{}) {
  switch v := v.(type) {
  case *[]Colour:
    //Do something with colours
  case *[]Brush:
    //Do something with brushes
  default:
    panic("unsupported doSome input")
  }
}

反射为fmt.Println（）。反射非常强大但非常昂贵，代码可能很慢。最小的例子

func doSome(v interface{}) {
    value := reflect.ValueOf(v)
    if value.Kind() == reflect.Slice {
        for i := 0; i < value.Len(); i++ {
            element := value.Slice(i, i+1)
            fmt.Println(element)
        }
    } else {
        fmt.Println("It's not a slice")
    }
}

如何在Go中创建一个变量类型的片段？

3 个答案: