为什么不能转换 Slice 类型？

Question

我想知道你为什么做不到：

type Foo struct { A int }
type Bar Foo

foos := []Foo{Foo{1}, Foo{2}}
bars := []Bar(foos)
//cannot convert foos (type []Foo) to type []Bar

我发现这需要运行时在切片上执行循环以转换每个元素，这将是 non-idiomatic Go。这是有道理的。

但是，编译器将 Bar 别名为 Foo，所以在内部它们是相同的，并且它们在下面使用相同的类型 header，难道不能解决这个问题吗？我猜答案是否定的，虽然我很好奇为什么。

Answer 1

如“Why can I type alias functions and use them without casting?”中所述

In Go, there is no such thing as a type alias.
The type keyword introduces new named types. They are not aliases

If you compare two named types, the names must match in order for them to be interchangeable

这就是 spec mentions:

A type declaration binds an identifier, the type name, to a new type that has the same underlying type as an existing type, and operations defined for the existing type are also defined for the new type.
The new type is different from the existing type.

Answer 2

这个：

[]Bar(foos)

是一个类型conversion。根据规范，转换有特定规则：

A non-constant value x can be converted to type T in any of these cases:

x is assignable to T.

x's type and T have identical underlying types.

x's type and T are unnamed pointer types and their pointer base types have identical underlying types.

x's type and T are both integer or floating point types.

x's type and T are both complex types.

x is an integer or a slice of bytes or runes and T is a string type.

x is a string and T is a slice of bytes or runes.

None 适用于此。为什么？

因为[]Foo的底层类型和[]Bar的底层类型不一样。和一个[]Foo类型的值不可分配给 []Bar 类型的变量，请参阅 Assignability rules here.

Foo的底层类型与Bar的底层类型相同，但同样不适用于元素类型为Foo和[=36的切片=].

因此以下工作：

type Foo struct{ A int }

type Foos []Foo
type Bars Foos

func main() {
    foos := []Foo{Foo{1}, Foo{2}}
    bars := Bars(foos)

    fmt.Println(bars)
}

输出（在 Go Playground 上尝试）：

[{1} {2}]

注意，由于Foo和Bar的实际内存表示是相同的（因为Bar的底层类型是Foo），在这种情况下使用包 unsafe 您可以将 []Foo 的值“查看”为 []Bar 的值：

type Foo struct{ A int }
type Bar Foo

func main() {
    foos := []Foo{Foo{1}, Foo{2}}

    bars := *(*[]Bar)(unsafe.Pointer(&foos))

    fmt.Println(bars)
    fmt.Printf("%T", bars)
}

这个：*(*[]Bar)(unsafe.Pointer(&foos))的意思就是取[=47=的地址，转换成unsafe.Pointer (according to spec所有的指针都可以转换成unsafe.Pointer)，那么这个Pointer 转换为 *[]Bar （同样根据规范 Pointer 可以转换为任何其他指针类型），然后这个指针被取消引用（* 运算符），所以结果是在输出中可以看到 []Bar 类型的值。

输出（在 Go Playground 上尝试）：

[{1} {2}]
[]main.Bar

备注：

引用unsafe的包文档：

Package unsafe contains operations that step around the type safety of Go programs.

Packages that import unsafe may be non-portable and are not protected by the Go 1 compatibility guidelines.

这是什么意思？这意味着您不应该每次都使用 package usafe 来让您的生活更轻松。你应该只在特殊情况下使用它，不使用它会使你的程序变得非常缓慢和复杂。

在你的程序中情况并非如此，因为我提出了一个工作示例，只需一点重构（Foos 和 Bars 是切片）。

unsafe 绕过 Go 的类型安全。这是什么意思？如果您要更改 foos 的类型（例如彻底改变 foos := "trap!"），您的程序仍会编译并运行，但很可能会发生运行time panic。使用 usafe 会丢失编译器的类型检查。

而如果您使用我的其他建议（Foos 和 Bars），这样的 changes/typos 会在编译时检测到。

为什么不能转换 Slice 类型？

Why are you unable convert Slice types?

type-conversion

go

slice

type-alias