Jai 入门 · 语法详解

2026-08-11T00:00:00+00:00

Jai 入门 · 语法详解</h1>

Jai 是 Jonathan Blow（《Braid》《The Witness》作者）设计的面向性能与数据导向的静态强类型语言，目标之一是做“C 的现代替代品“。本文语料主要来自 GitHub 上的 JaiPrimer 与 The Way to Jai 社区教程。 </blockquote>

1. Jai 的设计哲学</h2>
Jai 关注三件事：

写更快的代码：无 GC、无异常、无类继承包袱，程序员直接控制内存与性能特征；</li>
减少摩擦：语法一致、重构成本低、编译快速；</li>
数据导向（Data-Oriented Design）：程序本质是“填充内存的数据 + 高效算法“。</li> </ol>
与 C/C++ 对比</th> C / C++</th> Jai</th></tr></thead>

内存管理</td> malloc/free 或 RAII</td> new</code> / delete</code>，指针所有权 !</code> 标记，无 GC</td></tr>
多态</td> 虚函数 / 模板</td> 函数级多态 $T</code> + 编译期代码</td></tr>
构建</td> Make/CMake</td> 构建过程由 Jai 源码本身指定</td></tr>
数据组织</td> AoS 为主</td> struct SOA</code> 一键切换 SoA/AoS</td></tr>
反射</td> 无原生支持</td> 全类型信息运行时可查</td></tr> </tbody></table>

2. 程序入口与基本结构</h2>
#import "Basic"; main :: () { print("Hello, Jai!\n"); }</code></pre> 要点： main :: ()</code> 是入口过程；</li> #import</code> 导入标准/自定义模块；</li> print</code> 支持 %</code> 占位符：print("x = %\n", x)</code>。</li> </ul> 3. 变量与类型</h2> 声明语法：名字 : 类型 = 值;</code></h3> counter : int = 0; name : string = "Jon"; average : float = 0.5 * (x + y);</code></pre>类型省略（编译器推断）：名字 ::= 值;</code></h3> counter := 0; // int name := "Jon"; // string average := 0.5 * (x+y); // float</code></pre>只声明不初始化</h3> counter : int; flag : bool;</code></pre>基本类型</h3> bool</code>、int</code>、int8/16/32/64</code>、uint</code>、float</code>、float32/64</code>、string</code>、rawptr</code> 等。整数和浮点不隐式混用，需显式转换（cast</code>）。 4. 函数（过程）</h2> 语法统一：局部函数、匿名函数、全局函数写法完全一致，这是 Jai 重构友好的核心设计。 sum :: (x: float, y: float, z: float) -> float { return x + y + z; } main :: () { print("Sum: %\n", sum(1, 2, 3)); }</code></pre> 匿名函数： add_one := (x: int) -> int { return x + 1; }</code></pre> ::</code> 表示“绑定一个常量名字到右侧值“；过程、结构体、枚举、常量都用它声明。 5. 结构体 / 枚举 / 联合</h2> struct</h3> Vector3 :: struct { x: float = 1; y: float = 4; z: float = 9; } v : Vector3; v.x = 2;</code></pre> 成员可以带默认值。没有构造函数/析构函数（Jai 刻意去掉 RAII）。 enum</h3> Color :: enum u16 { RED, GREEN, BLUE = 80, ALPHA, }</code></pre>union</h3> Value :: union { i: int; f: float; }</code></pre> 6. 数组与切片</h2> a : [50] int; // 定长数组 b : [..] int; // 动态数组 c : [] int; // 切片（宽指针，携带长度）</code></pre> 数组不会退化为指针，自带长度信息 count</code>： print_int_array :: (a: [] int) { n := a.count; for i : 0..n-1 { print("array[%] = %\n", i, a[i]); } }</code></pre> 7. 控制流</h2> if / else</h3> if a == b { print("equal\n"); } else if a > b { print("greater\n"); } else { print("less\n"); }</code></pre>if-case（对值列表匹配）</h3> if x { 1, 2, 3 => print("small\n"); else => print("other\n"); }</code></pre>for</h3> for i : 0..9 { // 范围 print("%\n", i); } for item : items { // 遍历集合 print("%\n", item); }</code></pre>while</h3> while count < 10 { count += 1; }</code></pre>defer（作用域退出时执行）</h3> { ptr := new int; defer delete(ptr); // 离开作用域时自动释放 }</code></pre> 8. 指针与内存</h2> p : *int = new int; // 分配 p.* = 42; // 解引用（后缀 .*） delete p; // 释放</code></pre> 结构体指针所有权：成员类型前加 !</code> 表示“该指针由本结构体拥有，删除结构体时一并删除“： node :: struct { owned_a : !*node = null; } example := new node; example.owned_a = new node; delete example; // owned_a 也会被释放</code></pre> Jai 没有 GC 与自动内存管理，但用所有权标注 + defer</code> 让手动管理可控。 9. 函数级多态（$T</code>）</h2> Jai 的多态在函数级，参数前加 $</code> 声明类型变量： sum :: (a: $T, b: T) -> T { return a + b; } f3 := sum(1.0, 2.0); // float + float i3 := sum(1, 2); // int + int</code></pre> 类型由 $</code> 标记的参数推断，并可以做类型特化（#if</code> 按类型分支）。 Any 类型</h3> print_any :: (a: Any) { if a.type.type == Type_Info_Tag.FLOAT { print("a is float\n"); } }</code></pre> Any</code> 携带类型信息，适合需要“任意类型“参数的场景。 进阶 1：类型约束（$T/Foo</code> 与 $T/interface</code>）</h3> $T</code> 不限制类型；要约束“必须拥有某组字段/成员“，用 /</code> 写法（类似 trait / interface）： Vec3 :: struct { x, y, z: float; } dot_product :: (a: $T/interface Vec3, b: T) -> float { return a.x * b.x + a.y * b.y + a.z * b.z; } // 任何"拥有 x/y/z float 字段"的结构体都能传入，不必继承 Vec3</code></pre> 区别： 写法</th> 含义</th></tr></thead> a: $T</code></td> 任意编译期已知类型</td></tr> a: Foo($T)</code></td> 必须是 Foo</code> 的某种特化，内层 $T</code> 任意</td></tr> a: $T/Foo</code></td> 只要结构体内 using 了 Foo 即可（组件式组合）</td></tr> a: $T/interface Foo</code></td> 只要拥有 Foo 的全部字段即可（结构鸭子类型）</td></tr> </tbody></table> 进阶 2：多态结构体（编译期参数化）</h3> Foo :: struct(T: Type) { some_data : T; // 运行时成员，随 T 变化 } f : Foo(int); print("%\n", f.T); // => int</code></pre> 编译期参数不止类型，还可以是常量值，甚至函数： Foo :: struct( T: Type, fun: (T) -> T, // 编译期烘焙，不占运行时内存 ) { value: T; // 运行时数据 }</code></pre> 多态结构体的“模式匹配“写法——三种等价风格： Hash_Table :: struct (K: Type, V: Type, N: int) { keys: [N] K; values: [N] V; } // 1) 显式模式匹配 f1 :: (t: Hash_Table($K, $V, $N), k: K, v: V) { } // 2) $T/类型 + T.K 访问参数 f2 :: (t: $T/Hash_Table, k: T.K, v: T.V) { } // 3) 隐式多态：直接用具体类型访问其编译期参数 f4 :: (t: Hash_Table, k: t.K, v: t.V) { }</code></pre>进阶 3：多态数组（长度与元素类型都是类型的一部分）</h3> foo :: (x: [$N]$T) { print("%: %, %\n", type_of(N), N, T); } x := int.[1, 2, 3, 4]; foo(x); // => s64: 4, s64（N 本身是编译期 int）</code></pre> 注意：[4] int</code> 与 [5] int</code> 是不同类型，不能互相赋值。 进阶 4：由参数推导返回类型（Helper 结构体 + #run</code>）</h3> Helper :: struct(A: Type, B: Type) { T :: #run helper(A, B); // 编译期计算返回类型 } helper :: ($A: Type, $B: Type) -> Type { T : Type = A; // 这里可以做类型层面的逻辑 return T; } combine :: (a: $A, b: $B) -> Helper(A, B).T { // ... }</code></pre>进阶 5：#modify</code>——编译期校验/变换多态参数</h3> do_something :: (T: Type) -> bool { ti := cast(*Type_Info) T; return ti.type == .INTEGER || ti.type == .ENUM || ti.type == .POINTER; } function :: (dest: *$T, value: T) #modify { return do_something(T); } // false => 编译错误 { // 运行时实现 }</code></pre> #modify</code> 在每次调用解析时执行，可检查参数类型、做约束，是 Jai 在“类型层“做特化的入口。 10. 编译期执行（元编程核心）</h2> #run：编译期运行任意代码</h3> generate_table :: () -> [256] float { table : [256] float; for i : 0..255 { table[i] = pow(i / 255.0, 2.2); } return table; } srgb_table := #run generate_table(); // 编译期生成，运行期直接查表</code></pre> 编译期函数由编译器解释执行，结果直接烘焙进二进制。 #if：编译期条件</h3> #if OS == "windows" { print("Windows build\n"); } else { print("Other build\n"); }</code></pre> #if</code> 也可用于结构体字段与枚举值的条件定义。 #bake：参数烘焙</h3> add :: (a: int, b: int) -> int { return a + b; } add_one := #bake add(1); // 等价于单参数函数</code></pre> 11. 数据导向结构（SOA）</h2> 普通 AoS 与 struct SOA</code> 只差一个关键字，内存布局自动切换： Vector3 :: struct { // AoS：x y z x y z ... x: float = 1; y: float = 4; z: float = 9; } Vector3SOA :: struct SOA { // SoA：x x x y y y z z z x: float = 1; y: float = 4; z: float = 9; }</code></pre> 对缓存友好、批量更新场景（游戏实体、粒子系统）收益明显，且业务代码无需改动。 12. 反射与运行时类型信息</h2> 程序数据段保存完整类型表，可在运行时遍历： for _type_table { print("%\n", it.name); }</code></pre> 可用于序列化、网络复制、存档、调试器等（C/C++ 需要手写或宏实现）。 13. 模块与项目组织</h2> #import "Basic"; #load "part2.jai"; // 追加编译另一个源文件</code></pre> 大型项目常用 main.jai</code> 作为结构总览：#import</code> 模块、#load</code> 分片源文件，再定义 main()</code>。 14. 学习路径建议</h2> 语法骨架：变量 → 过程 → 结构体 → 控制流；</li> 内存：指针、new/delete</code>、所有权 !</code>、defer</code>；</li> 元编程：#run</code>、#if</code>、$T</code> 多态、#bake</code>；</li> 数据导向：struct SOA</code>、数组/切片、缓存局部性；</li> 实战：参考 The Way to Jai</a> 与 JaiPrimer</a> 的示例项目。</li> </ol> 注意：Jai 仍处于开发期，语法细节随编译器迭代可能变化，以官方最新文档为准。 </blockquote>

Rocky‘s Blog - Language

Jai 入门 · 语法详解

3. 变量与类型</h2>

5. 结构体 / 枚举 / 联合</h2>

7. 控制流</h2>

10. 编译期执行（元编程核心）</h2>