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

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 或字符 Ö 的指针？是否所有值都通过表示其类型的字节 secret 传递？

Answer 1

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

在 Go 中，类型不存储在结构中，而是存储在接口(interface)值中:

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 本身。