键入转换为类似的类型

Question

我试图重新使用代码（键/值）对来构建ec2.Tag和autoscaling.Tag类型，它们也是键/值对。但我不认为我对转换/铸造有足够的了解，请指教。先感谢您。

panic：接口转换：interface {}是[] struct {Key string;值字符串}，而不是[] * ec2.Tag

func (c *CloudWorks) GetTagCollection() interface{} {

    return []struct {
        Key   string
        Value string
    }{
     {
        Key:   "key-a",
        Value: "value-a",
    },
    {
        Key:   "key-b",
        Value: "value-b",
    },
    {
        Key:   "key-c",
        Value: "value-c",
    },
    }

}

func (c *CloudWorks) GetTags() []*ec2.Tag {

    //return []*autoscaling.Tag{

    // WORKS
    //return []*ec2.Tag{
    //  {
    //      Key:   aws.String("key1"),
    //      Value: aws.String("value1"),
    //  },
    //  {
    //      Key:   aws.String("key2"),
    //      Value: aws.String("value3"),
    //  },
    //  {
    //      Key:   aws.String("key3"),
    //      Value: aws.String("value3"),
    //  },
    //}

    // FAIL
    return c.GetTagCollection().([]*ec2.Tag)

}

编辑我的目标是避免代码重复，如何在两个函数中重用键值对，非常感谢。

func (c *CloudWorks) GetEC2Tags() []*ec2.Tag {

return []*ec2.Tag{
    {
        Key:   aws.String("key1"),
        Value: aws.String("value1"),
    },
    {
        Key:   aws.String("key2"),
        Value: aws.String("value3"),
    },
}

}

func (c *CloudWorks) GetAutoscalingTags() []*autoscaling.Tag {

return []*autoscaling.Tag{
    {
        Key:   aws.String("key1"),
        Value: aws.String("value1"),
    },
    {
        Key:   aws.String("key2"),
        Value: aws.String("value3"),
    },
}

}

Answer 1

您使用的术语不是conversion/casting，它是类型断言，用于获取接口的基础值。由于在返回数据时用于包装函数内容的接口是struct的一部分。这就是错误背后的原因：

panic：接口转换：interface {}是[] struct {Key string;值字符串}，而不是[] * ec2.Tag

类型断言是错误的，因为您使用的是[]*ec2.Tag广告类型，它应该是从函数[]struct返回的struct c.GetTagCollection()的切片。所以你应该键入assert到那个类型：

result := c.GetTagCollection().([]struct)

在特殊表单的赋值或初始化中使用的类型断言，以便检查类型为asssertion是否有效：

v, ok = x.(T)
v, ok := x.(T)

对于接口类型的表达式x和类型T，主表达式

x.(T)

声明x不是nil并且存储在x中的值是T类型。符号x。（T）称为类型断言。

更确切地说，如果T不是接口类型，则x。（T）断言x的动态类型与类型T相同。在这种情况下，T必须实现x的（接口）类型;否则类型断言无效，因为x不可能存储类型T的值。如果T是接口类型，则x。（T）断言x的动态类型实现接口T.

注意：如果类型断言成立，则表达式的值是存储在x中的值，其类型为T.如果类型断言为false，则会发生运行时混乱。

编辑：Golang对类型严格。因此，在将值转换为其他类型之前，不能将一种类型的值分配给其他类型。 AWS使用提供的字符串创建自己的类型。举个例子：

package main

import (
    "fmt"
)

type MyInt int 

func main() {
    var x int
    x = 1
    var y MyInt
    y = 1
    fmt.Println(x==y)
}

上面的代码会抛出不匹配类型的错误

prog.go:14:18：无效操作：x == y（不匹配的类型int和MyInt）

关于Playground的工作守则