Go语言中怎么把interface{}类型当成slice使用？

Question

如题。我想要用interface{}实现泛型，尤其是动态数组，要求能够通过append函数动态修改数组内对象：

type S struct {
    arr interface{}
}

arr是一个数组，但是由于我不知道数组的元素是什么类型，所以我把类型写成了interface{}。但是这样状况下的arr无法使用append函数来操作。有没有什么办法能让我在不知道元素类型的情况下使用interface{}类型当作slice并且能够实现动态增删元素的功能？

Answer 1

想要用interface{}实现泛型？没明白什么意思。可以把interface{}想象成一个公共父类型，就想Java中的Object。

如果你需要interface{}数组的话直接这样就可以了：is := make([]interface{}, 0)，如果你需要针对某一个类型创建数组的话可以这样：slc := make([]Node, 0)，其中Node是你的自定义类型。

如果不是上述的情况，请补充描述一下你的问题。

问题细化之后：

貌似有点儿明白，你这样的话最好自己写结构S的append方法以满足你的这个需求。另外你这个结构S的定义貌似跟需要使用泛型的场景没什么关系吧。

如果，硬要达到你说的那个效果的话（虽然我感觉这么做在绕圈子），可以这么做：

// genericity
// genericity
package main

import (
    "fmt"
    "reflect"
)

type GenericSlice struct {
    elemType   reflect.Type
    sliceValue reflect.Value
}

func (self *GenericSlice) Init(sample interface{}) {
    value := reflect.ValueOf(sample)
    self.sliceValue = reflect.MakeSlice(value.Type(), 0, 0)
    self.elemType = reflect.TypeOf(sample).Elem()
}

func (self *GenericSlice) Append(e interface{}) bool {
    if reflect.TypeOf(e) != self.elemType {
        return false
    }
    self.sliceValue = reflect.Append(self.sliceValue, reflect.ValueOf(e))
    return true
}

func (self *GenericSlice) ElemType() reflect.Type {
    return self.elemType
}

func (self *GenericSlice) Interface() interface{} {
    return self.sliceValue.Interface()
}

func main() {
    gs := GenericSlice{}
    gs.Init(make([]int, 0))
    fmt.Printf("Element Type: %s\n", gs.ElemType().Kind()) // => Element Type: int
    result := gs.Append(2)
    fmt.Printf("Result: %v\n", result)             // => Result: true
    fmt.Printf("sliceValue: %v\n", gs.Interface()) // => sliceValue: [2]
}

Answer 2

我大概明白题主是什么问题，我遇到过类似的问题，题主应该是需要这个函数：

func ToSlice(arr interface{}) []interface{} {
  v := reflect.ValueOf(arr)
  if v.Kind() != reflect.Slice {
    panic("toslice arr not slice")
  }
  l := v.Len()
  ret := make([]interface{}, l)
  for i := 0; i < l; i++ {
    ret[i] = v.Index(i).Interface()
  }
  return ret
}

我是实际写代码时候遇到类似的就是[]int,[]float,[]string等作为输入，输出是将其元素都tostr然后join一下。每个元素tostr可以单独写一个泛型的实现，入参是float还是int等都是可以的：

func ToStr(i interface{}) string {
  return fmt.Sprintf("%v", i)
}
ToStr(1)
ToStr(float64(1))

而如果更进一步封装接口Join时候

func Join(i []interface{}) string {
}
Join([]int{1,2})  // 报错:类型不匹配

解决方法就是上面的ToSlice函数

Join(ToSlice([]int{1,2}))

Answer 3

同样的问题，正在找更好的写法，看到楼上写的，不忍直视（这么渣也好意思发出来？）
interface{}，代表任意类型，自然也包含 slice，自然也支持 append 操作

var ss interface{}
fmt.Printf("%T", ss)
ss = make([]int, 0)
fmt.Printf("%T", ss)
ss = append(ss.([]int), 4)
fmt.Println(ss)

一个 make 搞定的事情，给弄成什么了？
遗憾的是 make 之后还需要继续 断言（可能是为了符合变量只能声明一次这个规范）

Answer 4

func SliceInterface(reflectValue reflect.Value) []interface{} {
    kind := reflectValue.Kind()
    if kind != reflect.Slice && kind != reflect.Array {
        panic(`only support slice or array type`)
    }

    newInterfaces := make([]interface{}, reflectValue.Len())
    for i := 0; i < reflectValue.Len(); i++ {
        newInterfaces[i] = reflectValue.Index(i).Interface()
    }

    return newInterfaces
}

// 调用

SliceInterface(reflect2.ValueOf(resource))