无类型

Go 中的"无类型"（untyped）是一个容易被误解的概念。它不是指"没有类型"，而是指有确定的类型(如整数、字符串)，但基础类型尚未确定(int、float64)，直到使用时才根据上下文推断。

有六种未明确类型的常量类型，分别是无类型的布尔型、无类型的整数、无类型的字符、无类型的浮点数、无类型的复数、无类型的字符串。

字面量

字面量（literal）本质上就是一种无类型常量。例如：

42      // 无类型整数常量
3.14    // 无类型浮点数常量
'a'     // 无类型 rune 常量
"hello" // 无类型字符串常量
true    // 无类型布尔常量

当你写下 42 时，它并不立即绑定为 int。它是一个"无类型整数常量"，只有在参与运算或赋值时，才会根据上下文确定具体类型。

var a int32 = 42   // 42 在此处被当作 int32
var b float64 = 42 // 42 在此处被当作 float64

如果 42 一开始就是 int 类型，那么 var b float64 = 42 就需要显式转换 float64(42)。正是因为它无类型，才能自然地适配目标类型。

常量的无类型

常量声明分为两种：

• 有类型常量：显式指定类型
• 无类型常量：不指定类型

const a int = 42 // 有类型常量，类型锁定为 int
const b = 42     // 无类型常量，保持灵活

无类型常量继承了字面量的灵活性，可以在多种兼容类型的上下文中直接使用：

const k = 1024

var x int32 = k   // OK
var y float64 = k // OK
var z byte = k    // 编译错误：1024 超出 byte 范围

相比之下，有类型常量则失去这种灵活性：

const k int = 1024
var y float64 = k // 编译错误：类型不匹配，需要 float64(k)

无类型的作用

隐式转换的灵活性

无类型常量在赋值或运算时会自动适配目标类型，无需显式转换。这让代码更简洁，同时保持类型安全（超出范围仍会报错）。

更高的运算精度

编译器为没有明确基础类型的数字常量提供比基础类型更高精度的算术运算；你可以认为至少有256bit的运算精度。

无类型常量在编译期以任意精度进行计算，不受具体类型的位宽限制。

const big = 1 << 62      // 无类型，可以正常表示
const huge = 1 << 100    // 编译期仍可参与计算

var n = big              // 此时才检查是否超出 int 范围

// ZiB和YiB的值已经超出任何Go语言中整数类型能表达的范围，但是它们依然是合法的常量
// 像下面的常量表达式依然有效（注：YiB/ZiB是在编译期计算出来的，并且结果常量是1024，是Go语言int变量能有效表示的）
fmt.Println(YiB/ZiB) // "1024" 

如果一开始就是 int 类型，1 << 100 会直接溢出。无类型让常量表达式可以在超出任何具体类型范围的情况下进行中间计算，只在最终赋值时才做范围检查。

默认类型

当无类型常量必须确定类型却缺乏明确上下文时（例如 := 赋值），会使用默认类型：

i := 42    // i 的类型为 int
f := 3.14  // f 的类型为 float64
c := 'a'   // c 的类型为 rune

Rust 中的整数字面量也有根据上下文确定字面量类型的能力(Integer literal expressions)，并且也提供了缺乏明确上下文时的默认类型。

这和 Go 中存在不同，Go 的无类型常量(和字面量)可以作为一种无明确类型的抽象值持续存在，直到在某个上下文中使用时才获得类型。

而 Rust 中，常量和字面量都是有明确类型的：

• 常量定义时不能使用类型推断，必须指定类型
• (整数)字面量的类型可以根据使用上下文来确定，但一定会被确定，而不是保持一个无明确类型的状态