假如一个类型MyByte定义如下，如何将一个[]MyByte切片值和一个[]byte切片值互相转换为对方的类型？
package main
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
x = []byte(y) // error: 非法的转换
y = []MyByte(x) // error: 非法的转换
}
如上例所示，在Go中，这两个类型的值之间的类型转换是非法的。因为Go规定两个切片只有在它们的类型的底层类型（underlying type）相同的情况下才能转换到对方的类型。而一个非定义类型（undefined type）的底层类型为此非定义类型本身。类型]MyByte和[]byte均为非定义类型，所以它们的底层类型不同，从而它们的值也就不能转换到对方的类型。
难道真没有办法实现它们之间的转换了？有，而且有好几种。第一种方法是使用类型非安全指针来实现双向转换，另外两种方法只能实现单向转换。另外的这两种方法要么利用了编译器的漏洞，要么利用了reflect标准库包的设计失误。
先看使用类型非安全指针的实现。
package main
import "unsafe"
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
p := unsafe.Pointer(&y)
x = *(*[]byte)(p)
x[0] = 99
println(y[0]) // 99
}
在使用类型非安全指针的实现中，转换结果和原切片共享底层元素。
利用标准编译器的bug，我们可以将一个[]byte切片值转换为类型[]MyByte。转换结果和原切片不共享底层元素。
package main
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
// 下一行利用了编译器漏洞
y = []MyByte(string(x))
y[0] = 99
println(x[0]) // 1
}
Go白皮书提到一个字节切片可以转换为一个字符串，反之亦然。但是什么是字节切片类型呢？底层类型为[]byte的切片类型还是元素类型的底层类型为byte的切片类型？如果字节切片类型定义为元素类型的底层类型为byte的切片类型，则[]MyByte和[]byte都可称为字节切片类型。如果字节切片类型定义为底层类型为[]byte的切片类型，则只有[]byte可以被称为字节切片类型。我们认为标准编译器采纳了底层类型为[]byte的切片类型才称为字节切片这一定义，因为下面这个程序使用标准编译器是编译不过的。
package main
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
_ = string(y) // error: 非法转换
}
但是，标准编译器（v1.12）却认为转换[]MyByte("abc")是合法的。这显然是一个漏洞。
对于码点切片（rune slice）和字符串之间的转换，同样的情况也存在。
对于gccgo编译器来说，此漏洞是对称的，因而更严重。此更严重的漏洞使得上述两种类型的值之间的转换是双向有效的。比如，下面这段代码使用gccgo（v8.0）编译是没问题的。
package main
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
// 下一行利用了编译器漏洞
y = []MyByte(string(x))
y[0] = 99
println(x[0]) // 1
// 下一行利用了编译器漏洞
x = []byte(string(y))
x[0] = 127
println(y[0]) // 99
}
事实上，gccgo编译器在内置copy和append函数的实现中也存在着同样的漏洞。
package main
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
// 下一行利用了编译器漏洞
copy(y, string(x))
y[0] = 99
println(x[0]) // 1
// 下一行利用了编译器漏洞
y = append([]MyByte(nil), string(x)...)
y[0] = 99
println(x[0]) // 1
}
第三种方法利用了reflect标准库包的设计失误。此失误导致将[]MyByte值单向转换为类型[]byte是可行的，虽然这违反了Go类型系统确定的规则。使用第三种方法得到的结果切片和原切片共享底层元素。
package main
import "reflect"
type MyByte byte
var (
x = []byte{1, 2, 3}
y = []MyByte{1, 2, 3}
)
func main() {
v := reflect.ValueOf(y)
x = v.Bytes()
x[0] = 99
println(y[0]) // 99
}
本文首发在微信Go 101公众号，欢迎各位转载本文。Go 101公众号将尽量在每个工作日发表一篇原创短文，有意关注者请扫描下面的二维码。
关于更多Go语言编程中的事实、细节和技巧，请访问《Go语言101》官方网站：https://gfw.go101.org。如果官网被墙，请访问《Go语言101》github项目：https://github.com/golang101/golang101。
