类型断言和强制转换

这是一篇译文，原文出处：https://www.sohamkamani.com/golang/type-assertions-vs-type-conversions/。

在Go语言中，类型断言和类型转换是一个令人困惑的事情，他们似乎都在做同样的事情。

这篇文章，我们将看到类型断言和类型转换实际上是如何截然不同的，并深入了解在Go中使用它们会发生什么。

下面是一个类型断言的例子:

var greeting interface{} = "hello world"
greetingStr := greeting.(string)

接着看一个类型转换的例子:

greeting := []byte("hello world")
greetingStr := string(greeting)

最明显的不同点是他们具有不同的语法variable.(type) vs type(variable)。接下来，我们进一步去研究。

类型断言

顾名思义，类型断言用于断言变量是属于某种类型。类型断言只能发生在interface{}空接口类型上。
上面类型断言的例子，greeting是一个interface{}类型，我们为其分配了一个字符串。现在，我们可以认为greeting实际上是一个string，但是对外展示的是一个interface{}。
如果我们想获取greeting的原始类型，那么我们可以断言它是个string，并且此断言操作会返回其string类型。

这意味着在做类型断言的时候，我们应该知道任何变量的基础类型，但是情况并非总是这样的。当我们不知道这个interface{}底层的具体类型的时候，我们可以采用comma ok-idiom范式的形式进行判断。

var greeting interface{} = "42"
greetingStr, ok := greeting.(string)

第二个值是一个布尔值，如果断言正确，返回 true ，否则返回 false。另外，类型断言是在程序运行时执行。

类型判断

类型判断是一个很实用的构造。当你不确定interface{}真正类型的时候，可以使用它。

var greeting interface{} = 42
switch g := greeting.(type) {
  case string:
      fmt.Println("g is a string with length", len(g))
  case int:
      fmt.Println("g is an integer, whose value is", g)
  default:
      fmt.Println("I don't know what g is")
}

为什么需要断言

在上面的例子中，我们似乎在将greeting从interface{}转换成int类型或者string类型。但是greeting的类型是固定的，并且和初始化期间声明时的内容一样。

当我们把greeting分配给interface{}类型的时候，请勿修改其原始类型。同样，当我们断言类型的时候，我们只是使用了原始类型功能，而不是使用interface公开的有限方法。

类型转换

首先，我们花点时间了解一下什么是 “类型”。在 Go 每种类型都定义了两件事:

• 变量的存储方式 (存储结构)
• 你可以使用变量做什么 (可以使用的方法和函数)

这里介绍了基本类型，包括了string和int。以及一些复合类型，比如struct map array 和 slice。

你可以从基本类型或通过创建复合类型来声明一个新类型。

// myInt 是一个新类型，它的基类型是 `int`. 
type myInt int
// AddOne 方法适用于 `myInt` 类型，不适用于 `int` 类型
func (i myInt) AddOne() myInt { return i + 1}
var i myInt = 4
fmt.Println(i.AddOne())

当我们声明一个myInt类型，我们可以将变量数据基于基本的int类型，但是如果要进行变量修改，我们可以通过myInt类型变量进行操作 (通过在myInt上面声明一个新方法)。

由于myInt 底层的类型基于int，意味着他们的底层基础类型是一样的。因此这些类型的变量可以相互转换。

var i int = 4
originalInt := myInt(i)
/* 同理
var i myInt = 4
originalInt := int(i)
*/

上面i的类型是int，originalInt的类型是myInt。

什么时候使用类型转换？

只有当基础数据结构类型相同，类型之间才可以相互转换。来看一个使用struct例子。

type person struct {
    name string
    age  int
}
type child struct {
    name string
    age  int
}
type pet struct {
    name string
}
func main() {
    bob := person{name: "bob", age: 15}
    babyBob := child(bob) // 结构体内有相同的数据类型，可以相互转换
    //babyBob := pet(bob) // 会导致编译错误 
    fmt.Println(bob, babyBob)
}

在这里，person 和 child 拥有相同的数据结构，即：

struct {
    name string
    age  int
}

因此他们可以相互转换。

type可用于声明具有相同数据结构的多种类型。

type pet person

这只是意味着child和person基于相同的数据结构 (类似于之前的int和myInt)。

类型为什么称为转换

就像上面说的，虽然不同类型的基础结构可能相同，但是他们可能也具有不同的限制和方法。当我们从一种类型转换成另一种类型时，会改变对类型的处理方式，而不是像类型断言那样仅公开其基础类型，这就是他们本质的差别。
如果尝试去转换错误的类型，类型转换会提示编译错误。这和类型断言所提供的运行时通过返回值判断错误，完全不同。

类型小结

• 类型断言和类型转换有着比语法层面上更根本的区别。它还强调了在Go中接口类型 (interface{}) 和非接口类型之间的区别。
• 接口类型没有任何数据结构，而是公开了已有的具体类型 (具有底层数据结构) 的一些方法。
• 类型断言引出了接口的具体类型；而类型转换改变了 在具有相同数据结构 的 两个具体类型之间 对类型的处理方式（限制和方法）。