Question

我有这样的事情：

a := []interface{}{}
b := []interface{}{}
type S struct {
  text string
}


s := S{"string"}
t := S{"string"}
a = append(a, s)
b = append(b, t)
a := append(a, b)

a

现在我想读一个元素或元素元素......但是怎么样？

Answer 1

您想要的是一种类型断言。 http://golang.org/ref/spec#Type_assertions

该页面上的简单示例是：

var x interface{} = 7  // x has dynamic type int and value 7
i := x.(int)           // i has type int and value 7`

另一个需要注意的是类型断言返回一个名为ok的值，如果断言成功，则返回true。这是一个简单的代码示例：

a := []interface{}{}
b := []interface{}{}
type S struct {
  text string
}


s := S{"string"}
t := S{"string"}
a = append(a, s)
b = append(b, t)
a = append(a, b)

assertedS,ok := a[0].(S)
if !ok { // If this is, in fact, not a value of type S, something is wrong
    // error handling
}

fmt.Println(assertedS) // Should show you the same thing as printing s

assertedB,ok := a[1].([]interface{})
if !ok {
    //...
}

assertedT,ok := assertedB[0].(S)
if !ok {
    //...
}

fmt.Println(assertedT) // Should show you the same thing as printing t

如果您事先不知道哪个列表元素是什么，您可以遍历它并使用“类型开关”。 http://golang.org/ref/spec#Switch_statements

switch x.(type) {
    // cases
}

允许您根据存储的接口{}的类型执行条件行为。

例如，您可以使用

func ExtractSlice(a []interface{}) {
  for _,x := range a {
    switch i := x.(type) {
    case S:
        fmt.Println(i)
    case []interface{}:
        ExtractSlice(i) // Recursively unpacks b once it's found within a
    }
  }
}

Answer 2

你是说这个吗？

a := []interface{}{}
b := []interface{}{}
type S struct {
    text string
}
s := S{"string"}
t := S{"string"}
a = append(a, s)
b = append(b, t)
a = append(a, b)
for _, v := range a {
    switch v.(type) {
    case S:
        fmt.Println("S", v)
    default:
        fmt.Println("Slice", v)
    }
}

Answer 3

This code example可能会有所帮助：

package main

import "fmt"

func main() {
    a := []interface{}{}
    b := []interface{}{}
    type S struct {
        text string
    }

    s := S{"string s"}
    t := S{"string t"}
    a = append(a, s)
    b = append(b, t)
    a = append(a, b)

    for _, v := range a {
        fmt.Println(v)
    }
}

但请注意，您已将a和b定义为接口片段。这意味着，当您执行a = append(a, b)时，您需要在b切片中的现有a字符串之后放置a切片，因此当您{{1}时超过range你得到：

{string s} //字符串的接口
[{string t}] //字符串
的接口切片

如何在Go中读取类似[] interface {}的片段？

3 个答案: