var/auto 与类型推断

本章导读

从第 4 章起，var 和 auto 就反复出现：var 装过容器、接过 JSON 式的字典，auto 接过几乎一切。它们看着都像"不用写类型"，本质却南辕北辙：var 是动态类型——变量的类型随所装的值流动；auto 是类型推断——编译器替你写下那个静态类型，之后与普通静态变量毫无区别。本章把这对"假双胞胎"彻底分开，顺便回答一个工程问题：var 灵活，代价是什么？

15.1 var 的动态本质

var 变量没有固定类型——它的类型就是"此刻装着的值的类型"，随时可变：

var v = 42
println(type(v))     // int
v = "hello"
println(type(v))     // string
v = [1, 2]
println(type(v))     // array

底层上，var 对应 XRT 的统一值类型 xvalue：一个带类型标签的"盒子"，装 int、装 string、装容器都是同一个盒子换内容。用 xl cgen 看证据——同一个 a = 1，两种写法生成的 C 截然不同：

这就是 var 的全部真相：静态类型是编译期的承诺，var 是运行期的容器。好处是无所不装（JSON 式数据、异构数组、可变参 arg），代价是每次触碰都要开箱验货（15.4 节与拾遗 1）。

15.2 auto 推断规则

auto 让编译器从初始化器推断类型，推断结果一经确定就是静态类型，终身锁定：

auto x = 42
println(type(x))          // int：推断为 int
x = 100                      // OK：同为 int

auto s = "txt"             // string
auto f = 1.5               // float
auto b = true              // bool
auto a = [1, 2, 3]          // array<int>：静态泛型数组！
println(type(a))           // array<int>

四条规则：

• 必须有初始化器——auto x 无初值是语法错误（编译器无从推断）；
• 类型锁定——x = "hello" 报 [sem] 赋值表达式类型和目标变量类型不匹配: target int, value string，与手写 int x 完全同等；
• 字面量推断走默认类型——整数得 int（64 位，第 3 章），小数得 float，同类容器字面量得静态泛型容器；
• 从 var 推断得 var——var v = 1; auto x = v 中 x 是 var（动态性"传染"），想静态必须 auto x = v as int。

auto 的定位是少写字、不少类型：长类型名（array<dict<int>>、第 13 章的函数签名）和一眼明了的初始化（auto m = max(3, 7)）是它的主场。

15.3 var vs auto 的对照

把两节的结论压成一张表——这是本章最需要刻进脑子的一页：

一句话：auto 是"帮我写类型"，var 是"先别管类型"。前者不损失任何静态安全，后者用安全换灵活——换得值不值，15.7 节谈。

15.4 var 参与运算的边界

var 可以参与运算——第 8 章复习题已见过 println(v + 1) 合法。规则实测如下：

var a = 10
var b = 3
println(a + b)              // 13：var 运算合法
println(type(a + b))        // int：结果的"内容"是 int

var s = "ab"
var t = "cd"
println(s + t)              // abcd：按内容的类型分派

auto r = a + 1              // r 是 var：运算结果的静态类型是 var
println(type(r))            // int（运行期内容）

关键在静态类型与运行期内容的分离：a + b 的运行结果是 int 值，但它的静态类型是 var——这带来一条铁律（第 8、11 章反复出现）：

var 世界的产出要进入静态世界，只有一座桥：as 显式取出（int n = (v as int) + 1），而 as 的纪律第 8 章已立——先 is 后 as。这就是 xlang 的"关税制度"：动态世界内部自由贸易，跨境必申报。

15.5 var 与容器

var 装容器时是动态容器（[1, 2]、{"a": 1} 直接赋给 var 的形态），读写自由：

var m = {"a": 1}
m["b"] = 2                  // 动态字典：随手加键
println(string(m["a"]))    // 1
println(string(m["b"]))    // 2

var arr = [1, "two", 3.0]  // 异构数组：静态容器做不到
println(string(arr[1]))   // two

容器语义经 2026-07-18 复测更正（第 12、16 章同步勘误）：var 容器与静态容器一样是共享引用——赋值、传参不复制，函数内修改对调用方可见；var b = a 之后改 b，a 同样变。唯一例外是静态 array<T> 传给 var 形参：编译器插入转换，函数内拿到隔离副本。早先版本此处按文档口径记为写时复制（COW），RC0 实测从未触发分离。选型对照：

15.6 type() 的运行时之眼

第 7 章学过：type() 返回值的确切类型身份。在 var 身上，它是观察"盒子里现在装的是什么"的窗口：

var v = 42
println(type(v))      // int
v = "hi"
println(type(v))      // string

auto w = 42
println(type(w))      // int：auto 的结果永远不变

分工回链第 7 章：type() 做精确身份判断与比较，is 做分支条件。在 var 的调试中 type() 尤其顺手——var 变量"实际装着什么"不再靠猜：

var data = [1, 2, 3]
if data is array then
    println("是数组，长度待查")
end
println(type(data))     // array

注意一个语义细节：type(var) 回答的是内容物的类型，不是"var"——var 是容器的静态身份，int/string/array 才是内容的运行期身份。这也正是 is var 被禁止的原因（第 7 章：is 目标类型不能是 auto/var）——问"是不是动态值"没有意义，要问就问内容。

15.7 何时该用 var

var 的代价清单（证据见拾遗 1）：每次运算经过 XRT 运行期分派；每次装箱/拆箱有内存与引用计数开销；编译期检查全面让位（类型错误推迟到运行期）；IDE 式的静态导航无从谈起。灵活从来不是免费的。

工程准则——该用：

• 结构由外部数据决定的场景：JSON/XSON 解析结果、配置袋、动态查询结果；
• 异构容器：一个数组里确实要装多种类型；
• 语言机制要求处：可变参 arg、catch 到的 error 之外的动态回调值；
• 脚本化小工具：生命周期短、逻辑直白，静态标注收益低。

不该用：

• "懒得想类型"——用 auto，别用 var；
• 热路径计算：循环体内的密集运算，静态类型快一个数量级；
• 库与 API 的公开签名：静态类型是文档也是契约，var 签名把检查责任推给所有调用方；
• 长期演进的大项目主干：var 每多一处，重构时的盲区就大一块。

一句话收束：var 是边境口岸，不是居民区——数据从动态世界进来，尽快 as 成静态类型再加工。

深入细节

⚠️ 常见错误

以下报错全部来自真实编译器输出（文件路径已缩短）。

本章小结

复习题

编程练习