程序如何知道原始静态类型语言在运行时的类型

Question

Go 和 Scala 都提供了在运行时检查类型的方法：

斯卡拉：

class A
class B extends A

val a: A = new A // static type: A dynamic type: A
val ab: A = new B // static type: A dynamic type: B
val b: B = new B // static type: B dynamic type: B

def thing(x: Any): String = x match {
    case t: Int => "Int"
    case t: A => "A"
    case t: B => "B"
    case t: String => "String"
    case _ => "unknown type"
}

去：

package main

import (
    "fmt"
    "reflect"
)

struct A {
    field1 int
    field2 string
}

func printTypeOf(t interface{}) {
    fmt.Println(reflect.TypeOf(t))
}

func main() {
    i := 234234 // int
    s := "hello world" // string
    p := &A{3234234, "stuff"} // *A

    fmt.Print("The type of i is: ")
    printTypeOf(i)
    fmt.Print("The type of s is: ")
    printTypeOf(s)
    fmt.Print("The type of p is: ") // pass a pointer
    printTypeOf(p)
    fmt.Print("The type of the reference of p is: ") // pass a value
    printTypeOf(*p)
}

这在内部究竟是如何工作的？我假设对于结构和类，对象的类型存储在一个隐藏字段中（所以 golang 中的结构实际上是 struct { field1 int field2 string type type }。但是到底如何才能发挥作用，给出 11010110 并知道它是否是指向内存地址 214 的指针，整数 214 还是字符 Ö？是否所有的值都偷偷地用一个代表其类型的字节传递？

Answer 1

在 Scala 中，每个对象都有一个指向其类的指针。当您使用原始参数（Int、Char 等）调用 thing 时，它会自动装箱到一个对象（java.lang.Integer、java.lang.Character 等）。代码中与Int 的匹配实际上被转换为与Integer 的匹配。

在 Go 中，类型不存储在结构中，而是存储在接口值中：

Interface values are represented as a two-word pair giving a pointer to information about the type stored in the interface and a pointer to the associated data. Assigning b to an interface value of type Stringer sets both words of the interface value.

因此，当您调用 printTypeOf(whatever) 时，whatever 将转换为 interface {}，并且其类型与 whatever 本身一起存储在此新值中。