将 \[\]string 转换为 \[\]interface{}

Question

我只想写一些这样的代码：

 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
}

I thought interface{} can represent any type, so []interface can also represent any []type before, now I know I’m wrong, []type 是一个整体类型，不能认为是 []interface{} 。

那么，任何人都可以帮助我如何使这段代码工作，或者任何其他解决方案吗？

PS ：我知道 []byte 或 string 可以相互转换，但这实际上不是我的意图，可能还有另一种类型而不是 []byte string 。

原文由 zhuah 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

现在我知道我错了， []type 是一个整体类型，不能被认为是 []interface{} 。

是的，那是因为 interface{} 是它自己的类型（而不是任何其他类型的“别名”）。

正如我在“ golang 中 interface{} 的含义是什么？ ”中提到的那样（如果 v 是一个 interface{} 变量）：

初学者 gophers 被引导相信“ v 是任何类型”，但这是错误的。

v 不是任何类型；它是 interface{} 类型。

常见问题解答提到

它们在内存中没有相同的表示。

有必要 将元素单独复制到目标切片。

此示例将 int 切片转换为 interface{} 切片：

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

---

Tom L 提出 了这个例子（在 评论 中）：

 package main

import "fmt"

func main() {

    x := []string{"a", "b", "c", "d"}
    fmt.Printf("%T: %v\n", x, x)

    //converting a []string to a []interface{}
    y := make([]interface{}, len(x))
    for i, v := range x {
        y[i] = v
    }
    fmt.Printf("%T: %v\n", y, y)

    //converting a []interface{} to a []string
    z := make([]string, len(y))
    for i, v := range y {
        z[i] = fmt.Sprint(v)
    }
    fmt.Printf("%T: %v\n", z, z)

}

原文由 VonC 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

1. 创建一个效用函数，像这样

func ToGenericArray(arr ...interface{}) []interface{} {
    return arr
}

1. 并使用它：

 func yourfunc(arr []interface{})  {
....
}

yourfunc(ToGenericArray([...]string{"a", "b", "c"}))

1. 重要提示：以下将不起作用

func yourfunc(arr []interface{})  {
....
}

arr:=[...]string{"a", "b", "c"}

yourfunc(ToGenericArray(arr))

原文由 jashawnpeng 发布，翻译遵循 CC BY-SA 4.0 许可协议