AI 中文社/ 精选类库/ 开发类

Mojo 1.0.0b1 语言语法大全

发布于 2026-06-13 · 浏览数 12 · 最后编辑 2026-06-14 01:08

📖 Mojo 1.0.0b1 语言语法大全

注：本文档基于 Modular 官方 Mojo Manual（2026-03-19）整理，持续更新中。
前置知识：Mojo 是一门相对年轻的语言，部分特性仍在完善中。本语法大全假定你具备一定的编程经验，不求全面覆盖所有语言细节，而是提供一份足以让你起步的核心语法速览。

🚀 1. Hello, World!

def main():
    print("Hello, world!")

入口点：每个 Mojo 可执行程序必须包含 main() 函数作为入口点。
缩进：使用冒号 : 后跟缩进的代码块定义函数、条件、循环等。缩进使用空格（推荐 4 个）或 Tab。
注释：单行注释以 # 开头。

# 这是一行注释
def main():          # 这是行尾注释
    pass             # 占位符，什么也不做

✍️ 2. 变量与数据类型

2.1 变量声明

Mojo 支持隐式声明和显式声明两种方式，所有变量都是静态类型（类型在编译时确定，运行时不可变）且可变的（var 是其默认语义）。

def main():
    # 隐式声明（类型由初始值推断）
    x = 10
    name = "Sam"

    # 显式声明（使用 var 关键字）
    var y: Int = 20
    var z: Float64

    # 类型检查：一旦类型确定，不能改变
    count = 8
    # count = "Nine?"  # ❌ 错误：不能将 StringLiteral 转换为 Int

2.2 常量与编译时常量

如果希望定义运行时不可更改的值，应使用 comptime 关键字创建编译时常量。

def main():
    comptime MAX_SIZE = 1024   # 编译时常量，运行时不可变
    var buffer = List[UInt8](MAX_SIZE)

2.3 基本数据类型

类型	说明	示例
`Bool`	布尔值	`True`, `False`
`Int`	有符号整数（默认字长）	`-42`, `0`, `1000`
`UInt`	无符号整数（默认字长）	`42`, `0`
`Float64`	双精度浮点数	`3.14159`, `-0.5`
`String`	字符串	`"Hello"`, `'World'`
`Int8`, `Int16`, `Int32`, `Int64`	固定宽度有符号整数	`Int8(-128)`
`UInt8`, `UInt16`, `UInt32`, `UInt64`	固定宽度无符号整数	`UInt8(255)`
`SIMD`	向量类型（用于高性能计算）	`SIMD[DType.float32, 4]`

def main():
    var a: Int = 42          # 有符号整数
    var b: UInt8 = 255       # 无符号8位整数（范围 0-255）
    var c: Float64 = 3.14159
    var d: Bool = True
    var e: String = "Mojo"

更多内置类型（如 IntLiteral、FloatLiteral、SIMD 等）由 builtin 包提供。

2.4 类型转换

def main():
    var i: Int = 42
    var f: Float64 = i    # 隐式转换：Int → Float64（安全）
    # i = f               # ❌ 错误：Float64 不能隐式转换回 Int
    var i2: Int = Int(f)  # 显式转换（取整）

🎯 3. 字面量（Literals）

Mojo 支持多种字面量形式。

3.1 整数字面量

42          # 十进制
0xFF        # 十六进制（0x 或 0X 前缀）
0o52        # 八进制（0o 或 0O 前缀）
0b101010    # 二进制（0b 或 0B 前缀）
1_000_000   # 支持下划线分组（连续和尾部下划线也允许）

3.2 浮点数字面量

1.0          # 标准形式
3.14159
.5           # 仅小数部分（无整数部分）
2.           # 整数部分 + 小数点
2.5e-3       # 科学计数法
1_000.000_5  # 支持下划线分组

3.3 字符串字面量

"Hello"              # 双引号
'World'              # 单引号
"""多行字符串"""      # 三双引号
'''多行字符串'''      # 三单引号

# 相邻字符串自动连接
"Hello, " "World"    # → "Hello, World"

# 原始字符串（禁用转义）
r"C:\path\to\file"

转义序列：\n（换行）、\t（制表符）、\\（反斜杠）、\"（双引号）、\'（单引号）等。

3.4 布尔字面量

True       # 真
False      # 假

3.5 None

None       # 表示"无值"（NoneType 类型，仅有此实例）

🔢 4. 运算符

Mojo 的运算符语法与 Python 保持一致（符号、优先级、结合性）。

4.1 算术运算符

运算符	含义	示例	结果
`+`	加法	`7 + 3`	`10`
`-`	减法	`7 - 3`	`4`
`*`	乘法	`7 * 3`	`21`
`**`	幂	`2 ** 8`	`256`
`/`	除法（向零取整）	`-7 / 4`	`-1`
`//`	整除（向下取整）	`-7 // 4`	`-2`
`%`	取余	`7 % 3`	`1`
`@`	矩阵乘法（需实现 `__matmul__`）	—	—

4.2 一元运算符

运算符	含义	示例
`-x`	取负	`-7`
`+x`	恒等（无操作）	`+7`
`~x`	按位取反	`~a`

4.3 比较运算符

运算符	含义
`==`	相等
`!=`	不等
`<`	小于
`<=`	小于等于
`>`	大于
`>=`	大于等于

def main():
    print(10 > 5)        # True
    print(10 == 10)      # True
    print(1 < x < 10)    # ✅ 支持链式比较

浮点数比较：请使用 isclose() 而非 ==。

from std.math import isclose
var total: Float64 = 0.0
for _ in range(10): total += 0.1
print(total == 1.0)        # False
print(isclose(total, 1.0)) # True

4.4 逻辑运算符

运算符	含义
`and`	逻辑与
`or`	逻辑或
`not`	逻辑非

def main():
    if x > 0 and y > 0:
        print("Both positive")

4.5 成员与身份运算符

运算符	含义
`in`	成员测试
`is`	身份测试

def main():
    if item in container:
        print("Found")
    if a is b:
        print("Same object")

4.6 位运算符

运算符	含义
`&`	按位与
`	`
`^`	按位异或（⚠️ 同时也作为所有权转移符号，见后）
`<<`	左移
`>>`	右移

⚠️ 特别注意：^ 运算符具有双重含义——按位异或与所有权转移（Transfer）符号。作为转移符号时，a^ 表示将 a 的值所有权转移给另一个变量。详见第 7 节「所有权与内存管理」。

🔄 5. 控制流（Control Flow）

5.1 if / elif / else

def main():
    if x > 0:
        print("positive")
    elif x < 0:
        print("negative")
    else:
        print("zero")

条件按顺序求值，执行第一个为 True 的代码块。
单行写法：if x > 0: print("positive")。

5.2 while 循环

var count = 0
while count < 10:
    print(count)
    count += 1

5.3 for 循环

# 遍历序列
for item in items:
    process(item)

# 范围迭代（[0, 10)）
for i in range(10):
    print(i)

# 解构解包
for key, value in pairs:
    print(key, value)

5.4 break / continue

while True:
    var item = get_next()
    if item is None:
        break          # 退出循环
    if not is_valid(item):
        continue       # 跳过本次迭代，继续下一次
    process(item)

5.5 for-else / while-else

当循环正常结束（未通过 break 退出）时执行 else 块：

var found = False
for item in items:
    if item == target:
        found = True
        break
else:
    print("not found")   # 仅当未触发 break 时执行

5.6 条件表达式（三元运算符）

var result = "positive" if x > 0 else "negative"

⚠️ 注意：Mojo 不支持 x > 0 and print("positive") 或 print("positive") if x>0 else pass 等 Python 的"快捷写法"。

📦 6. 函数与参数

6.1 基本定义（`def`）

def greet(name: String) -> String:
    return "Hello, " + name

def 声明函数（fn 为另一种选择，见后文）。
参数类型标注为 : 后跟类型名。
返回类型标注为 -> 后跟类型名。
没有返回值时省略 ->（隐式返回 None）。

6.2 入口点 `main()`

每个可执行程序必须包含 main() 函数作为入口点，其签名必须为无参数：

def main():
    print("Program starts here")

6.3 可选参数与默认值

def greet(name: String, loud: Bool = False) -> String:
    return f"Hello, {name.upper() if loud else name}!"

def main():
    greet("Alice")              # loud 使用默认值 False
    greet("Alice", loud=True)   # loud = True

6.4 仅位置参数（`/`）

/ 之前的参数必须按位置传递，不能使用关键字参数。

def div(a: Int, b: Int, /) -> Int:
    return a // b

def main():
    div(10, 3)       # ✅ 有效
    # div(a=10, b=3) # ❌ 错误：不能使用关键字参数

6.5 仅关键字参数（`*`）

* 之后的参数必须使用关键字参数传递。

def configure(*, verbose: Bool, retries: Int):
    pass

def main():
    configure(verbose=True, retries=3)   # ✅ 有效
    # configure(True, 3)                 # ❌ 错误

6.6 可变参数（*args / **kwargs）

def sum_all(*values: Int) -> Int:
    var total = 0
    for v in values:   # values 是一个元组
        total += v
    return total

def main():
    print(sum_all(1, 2, 3, 4))   # 10
    print(sum_all(1, 2))         # 3

双星号（**kwargs） 表示变长的关键字参数，接收一个 dict。

def print_attrs(**attrs: String):
    for key, value in attrs.items():
        print(t"{key}: {value}")

def main():
    print_attrs(name="Mojo", version="1.0", language="systems")
    # name: Mojo
    # version: 1.0
    # language: systems

6.7 参数传递规范（Conventions）

参数规范出现在参数名前，控制所有权和可变性：

规范	含义	说明
`read`（默认）	不可变引用	接收值的只读引用（默认行为）
`mut`	可变引用	可以修改传入的值（原 `inout`，Mojo 24.6 中更名为 `mut`）
`owned`	转移所有权	获取值的完全所有权（可变且唯一）

def modify(mut value: Int):
    value += 1          # 直接修改原变量

def consume(owned data: List[Int]):
    # 函数拥有 data 的所有权，离开作用域时自动销毁
    pass

def main():
    var x = 5
    modify(x)           # x 变为 6（传递可变引用）
    var list = [1, 2, 3]
    consume(list^)      # 使用 ^ 转移所有权
    # print(list)       # ❌ 错误：list 的所有权已转移

6.8 编译时参数（Parameters）与泛型

Mojo 使用方括号 [] 表示编译时参数（Parameters），区别于运行时参数的括号 ()。参数在编译时求值，作为运行时常量。

# 类型泛型函数（参数为类型）
def identity[T](value: T) -> T:
    return value

# 值泛型函数（参数为值）
def array[N: Int]() -> List[Int]:
    return List[Int](N)

def main():
    var x = identity[Int](42)      # 显式指定 T = Int
    var y = identity(42)           # T 自动推断为 Int
    var arr = array[10]()          # N = 10，返回容量为 10 的列表

标记 //：表示仅推断参数（infer-only parameters），编译器从调用参数推断，不能显式指定。

def inferred_type[T: Writable, //](value: T):
    print(t"Type is {get_type_name[T]()}")

def main():
    inferred_type(5)        # T = Int，自动推断
    inferred_type("Hello")  # T = String
    # inferred_type[Int](5) # ❌ 错误：仅推断参数不能显式指定

🏗️ 7. 结构体（Structs）与面向对象

Mojo 使用 struct 定义自定义类型。结构体是值类型（value types），每个变量持有独立的副本。

struct Point:
    var x: Int
    var y: Int

    def __init__(out self, x: Int, y: Int):
        self.x = x
        self.y = y

    def distance(self) -> Float64:
        from std.math import sqrt
        return sqrt(Float64(self.x * self.x + self.y * self.y))

def main():
    var p = Point(3, 4)
    print(p.distance())     # 5.0

7.1 结构体成员

元素	语法	作用
字段（field）	`var name: Type`	实例数据
方法（method）	`def name(self, ...)`	实例行为（常规方法）
静态方法	`@staticmethod def name(...)`	类型级行为
编译时常量	`comptime name = value`	编译时求值的常量
初始化器	`def __init__(out self, ...)`	构建实例
析构器	`def __del__(deinit self)`	生命周期结束时清理

7.2 字段（Fields）

所有字段必须使用 var 声明并提供类型注解，且不能在字段声明中初始化，必须在 __init__() 中初始化。

struct Color:
    var r: UInt8
    var g: UInt8
    var b: UInt8

    def __init__(out self, r: UInt8, g: UInt8, b: UInt8):
        (self.r, self.g, self.b) = (r, g, b)

7.3 自动初始化器（`@fieldwise_init`）

使用 @fieldwise_init 装饰器可以自动合成 __init__()：

@fieldwise_init
struct Color:
    var r: UInt8
    var g: UInt8
    var b: UInt8

def main():
    var c = Color(255, 0, 0)   # 自动生成的 __init__()
    print(c.r)                  # 255

⚠️ 如果结构体包含非可复制且非可移动的字段，@fieldwise_init 无法自动生成。

7.4 结构体参数（泛型结构体）

通过结构体参数实现泛型（编译时确定具体类型）：

struct Box[T: AnyType]:
    var value: Self.T       # 使用 Self.T 访问参数 T

    def __init__(out self, value: T):
        self.value = value

def main():
    var int_box = Box[Int](42)      # T = Int
    var str_box = Box[String]("Mojo")

特殊语法：在结构体内部，Self 指向结构体自身类型（大写 S），self 是约定俗成的实例参数名（小写 s）。

7.5 方法

struct Counter:
    var value: Int

    def __init__(out self):
        self.value = 0

    def increment(mut self):        # mut 表示会修改 self
        self.value += 1

    def get(self) -> Int:           # 无 mut ⇒ 只读
        return self.value

7.6 静态方法

struct MathUtils:
    @staticmethod
    def square(x: Int) -> Int:
        return x * x

def main():
    print(MathUtils.square(5))      # 25（无需实例化）

🧬 8. 所有权（Ownership）与内存管理

Mojo 使用所有权（ownership）系统确保内存安全，没有垃圾回收器（GC）或引用计数的运行时开销。

8.1 核心规则

每个值在同一时刻有且只有一个所有者（owner）。
当所有者生命周期结束时，Mojo 自动销毁该值。
默认采用值语义——赋值会创建独立副本；如需引用语义，使用 ref 显式声明。

8.2 `var` 与 `ref` 绑定

def main():
    # var：拥有值所有权（独立副本）
    var a = "hello"
    var b = a          # 副本，b 与 a 独立
    b = b + " world"
    print(a)           # "hello"（未改变）

    # ref：引用绑定（类似 Python 引用行为）
    var c: List[Int] = [1, 2, 3]
    ref d = c          # d 是 c 的引用，不复制
    d.append(4)
    print(c)           # [1, 2, 3, 4]（c 被改变了）

8.3 所有权转移（Transfer，`^` 运算符）

def main():
    var a = [1, 2, 3]
    var b = a^         # ^ 将 a 的所有权转移给 b
    # print(a)         # ❌ 错误：a 的所有权已转移
    print(b)           # [1, 2, 3]

为什么需要 ^？ 对于非复制类型（如 List），赋值操作默认要求复制。使用 ^ 表示"转移所有权"而非复制，避免不必要的内存复制开销。
对于实现了 Copyable trait 的类型（如 Int、Bool、String），不必须使用 ^。

8.4 显式复制（`.copy()`）

def main():
    var a = [1, 2, 3]
    var b = a.copy()   # 创建独立副本
    b.append(4)
    print(a)           # [1, 2, 3]（未改变）
    print(b)           # [1, 2, 3, 4]

8.5 函数参数所有权

# 默认：read（只读引用，不可修改）
def read_only(value: Int):
    # value += 1      # ❌ 错误：read-only 参数不可修改
    print(value)

# mut：可变引用（可以修改原值）
def modify(mut value: Int):
    value += 1         # ✅ 有效：会修改原变量

# owned：转移所有权（函数获得独占所有权）
def consume(owned data: List[Int]):
    pass               # data 在此作用域结束时自动销毁

def main():
    var x = 5
    modify(x)          # x 变为 6
    var list = [1, 2, 3]
    consume(list^)     # 转移所有权给函数
    # print(list)      # ❌ 错误：list 不再有效

📐 9. Trait（特性）与接口

Mojo 通过 trait 系统实现零成本编译时多态。

9.1 定义 trait

trait Drawable:
    def draw(self)

9.2 实现 trait（`:` 语法）

struct Circle:
    var radius: Float64

    def draw(self):
        print("Drawing a circle")

struct Square:
    var side: Float64

    def draw(self):
        print("Drawing a square")

9.3 使用 trait 作为约束

def draw_all[T: Drawable](shapes: List[T]):
    for shape in shapes:
        shape.draw()

def main():
    var circles = List[Circle]()
    circles.append(Circle(radius=5.0))
    draw_all(circles)

9.4 常见内置 trait

trait	作用
`AnyType`	所有 Mojo 类型默认扩展的基础 trait
`Copyable`	可隐式复制（如 `Int`、`Bool`）
`Movable`	可移动（所有权转移）
`Comparable`	可比较（实现 `<`, `>`, `==` 等）
`Equatable`	可相等性测试
`ImplicitlyDestructible`	可隐式销毁

🧬 10. 元编程（Metaprogramming）

Mojo 的参数化系统（方括号 []）和编译时计算（comptime）构成了元编程的核心。

10.1 编译时参数（Parameterization）

# 类型参数化（泛型）
def clamp[T: Comparable & ImplicitlyCopyable](val: T, lo: T, hi: T) -> T:
    if val < lo:
        return lo
    if val > hi:
        return hi
    return val

# 值参数化（编译时数值）
struct FixedArray[N: Int, T: AnyType]:
    var data: T[N]   # 编译时已知数组长度

    def __init__(out self, value: T):
        for i in range(N):
            self.data[i] = value

10.2 编译时执行（`comptime`）

def main():
    comptime SIZE = 1024
    comptime RESULT = SIZE * 2   # 编译时求值
    var arr = List[Int](SIZE)    # 使用编译时常量

# 使用 comptime 块执行编译时代码
def generate_code():
    comptime:
        # 在编译时执行的代码
        var config = load_config_at_compile_time()
        var settings = process_config(config)
        # 影响生成的二进制文件

10.3 `@always_inline` 装饰器

强制编译器内联函数（inline）以消除函数调用开销：

@always_inline
def fast_square(x: Int) -> Int:
    return x * x

📁 11. 模块与包（Modules & Packages）

11.1 模块（Module）

模块是单个 .mojo 源文件，可被其他文件导入。

# mymodule.mojo（无 main() 函数，不可独立执行）
struct MyPair:
    var first: Int
    var second: Int

    def __init__(out self, first: Int, second: Int):
        self.first = first
        self.second = second

    def dump(self):
        print(self.first, self.second)

11.2 导入（Import）

# 导入整个模块（通过模块名称访问）
import mymodule
def main():
    var p = mymodule.MyPair(2, 4)
    p.dump()

# 从模块导入特定成员（直接访问）
from mymodule import MyPair
def main():
    var p = MyPair(2, 4)
    p.dump()

# 导入并使用别名
import mymodule as my
def main():
    var p = my.MyPair(2, 4)
    p.dump()

11.3 包（Package）

包是包含 __init__.mojo 文件的目录，用于组织多个模块。

mypackage/
├── __init__.mojo    # 必需，可为空
└── mymodule.mojo

# main.mojo 中导入包内的模块
from mypackage.mymodule import MyPair

def main():
    var p = MyPair(2, 4)
    p.dump()

11.4 Python 互操作

Mojo 支持与 Python 的双向互操作。

调用 Python 代码：

from python import Python

def main():
    var np = Python.import_module("numpy")
    var arr = np.array([1, 2, 3])
    print(arr.mean())

从 Python 调用 Mojo：

需使用 Python 绑定（bindings）声明 Mojo 中可供 Python 调用的函数。

# binding.mojo
@python_export("my_mojo_module")
def compute(x: Int) -> Int:
    return x * x

然后在 Python 中：

import my_mojo_module
print(my_mojo_module.compute(5))   # 25

类型自动转换：Mojo 原始类型（Int、Float64、Bool、String）能自动转换为 Python 对象。

🐛 12. 错误处理（Error Handling）

Mojo 使用 try / except 进行错误处理，与 Python 类似。

12.1 抛出错误（`raise`）

def divide(a: Int, b: Int) -> Int:
    if b == 0:
        raise Error("Division by zero")
    return a // b

12.2 捕获错误（`try` / `except`）

def main():
    try:
        result = divide(10, 0)
        print(result)
    except e:
        print("Error:", e)           # e 是被捕获的错误对象

except e: 将错误绑定到名称 e。
except:（无绑定）表示捕获错误但不访问错误信息，适用于只关心“发生了错误”而不需要细节的场景。

12.3 `else` 子句

仅当 try 块未抛出错误时执行：

try:
    result = risky_operation()
except e:
    handle_error(e)
else:
    print("Success!")   # 无错误时执行

12.4 `finally` 子句

无论是否发生错误都始终执行（用于清理资源）：

try:
    file = open("data.txt")
    process(file)
except e:
    print("Error:", e)
finally:
    file.close()        # 始终执行，确保文件关闭

12.5 带错误声明的函数（`raises`）

def risky_calculation() raises -> Int:
    if random() < 0.5:
        raise Error("Random failure")
    return 42

声明 raises 表示函数可能会抛出错误，调用方必须处理或传播。
Error 是 Mojo 内置错误类型，携带描述信息。

🚀 13. 进阶特性

13.1 `def` vs `fn`

关键词	适用场景	默认行为
`def`	Python 兼容代码	动态灵活，可使用 Python 语义
`fn`	性能关键代码	更严格类型检查，更强优化

# def：Python 风格（默认行为接近 Python）
def flexible(x):
    return x * 2

# fn：系统编程风格（更严格性能优化）
fn fast_add(a: Int, b: Int) -> Int:
    return a + b

13.2 内置集合类型

# 列表（List）
var numbers = [1, 2, 3]
numbers.append(4)

# 元组（Tuple）
var point = (10, 20)
print(point[0])    # 10

# 字典（Dict）
var ages = {"Alice": 30, "Bob": 25}
ages["Charlie"] = 28

# 集合（Set）
var primes = {2, 3, 5, 7}

13.3 列表/字典/集合推导式

var squares = [x**2 for x in range(10)]
var even_squares = [x**2 for x in range(10) if x % 2 == 0]
var cube_dict = {x: x**3 for x in range(5)}

13.4 字符串插值与格式化

def main():
    var name = "Mojo"
    var version = 1.0
    # f-string 风格
    print(f"Welcome to {name} version {version}")
    # t-string 风格（Mojo 原生）
    print(t"Welcome to {name} version {version}")
    # .format() 风格
    print("Welcome to {} version {}".format(name, version))

Mojo 同时支持 Python 风格的 f"{}" 和 Mojo 原生更高效的 t"{}" 字符串插值。

13.5 SIMD（单指令多数据流）

Mojo 内置 SIMD 类型，用于高性能计算（向量化）：

def main():
    # 4 个单精度浮点数组成的向量
    var vec: SIMD[DType.float32, 4] = SIMD[DType.float32, 4](1.0, 2.0, 3.0, 4.0)
    var result = vec + vec   # 元素级加法
    print(result[0], result[3])  # 2.0, 8.0

SIMD 类型是实现高性能向量化计算的基础，Mojo 的许多标准库类型（如固定宽度整数 Int8、Int16 等）都是 SIMD 的别名。

📊 14. 关键语法速览表

类别	语法	示例
入口点	`def main():`	—
变量（隐式）	`name = value`	`x = 10`
变量（显式）	`var name: Type`	`var count: Int`
变量（引用）	`ref name = value`	`ref b = a`
编译时常量	`comptime NAME = value`	`comptime SIZE = 1024`
函数	`def name(params) -> ReturnType:`	—
函数（抛出错误）	`def name(...) raises -> ReturnType:`	—
泛型函数	`def name[T](value: T) -> T:`	—
结构体	`struct Name:`	—
结构体泛型	`struct Name[T: AnyType]:`	—
Trait	`trait Name:`	—
参数传递	`read x` / `mut x` / `owned x`	—
错误捕获	`try:` / `except e:`	—
资源清理	`finally:`	—
导入	`import module` / `from module import name`	—
类型转换	`Type(value)`	`Int(3.14)`
所有权转移	`value^`	`b = a^`
显式复制	`value.copy()`	`b = a.copy()`

📚 15. 延伸阅读与资源

资源类型	链接	说明
Mojo Manual 完整手册	https://docs.modular.com/mojo/manual/	官方完整语言指南
Mojo API 参考	https://docs.modular.com/mojo/lib/	标准库 API 文档
所有权系统详解	https://docs.modular.com/mojo/manual/values/	深入理解所有权与内存管理
编译时参数系统	https://docs.modular.com/mojo/manual/parameters/	元编程与泛型详解
错误处理与上下文管理器	https://docs.modular.com/mojo/manual/errorhandling/	官方错误处理机制
Traits 系统	https://docs.modular.com/mojo/manual/traits/	零成本编译时多态
Python 互操作	https://docs.modular.com/mojo/manual/python/	Mojo 与 Python 双向集成指南
Mojo 中文社区	https://mojocn.org/	中文 Mojo 入门与参考资源
Mojo Changelog	https://docs.modular.com/mojo/changelog/	追踪语言版本变化与新特性

🎯 16. 常见陷阱提示

类型不可变：一旦变量类型确定，不能赋值为不同类型（如 Int → String）。
^ 的双重含义：既是按位异或也是所有权转移符号，根据上下文区分。
值语义默认：结构体赋值默认是复制而非引用，除非使用 ref。
所有权转移：使用 ^ 转移所有权后，原变量不再有效，不能继续使用。
仅推断参数：方括号 [] 中的参数如果是推断型（// 标记），不能显式指定。
浮点数比较：不要直接使用 ==，应使用 isclose() 函数。
单行条件限制：Mojo 不支持 Python 的 x > 0 and print("positive") 快捷写法。
for-else 语义：仅当循环未通过 break 退出时才执行 else 子句。
结构体字段不能递归：不能包含自身类型的字段，需使用指针（如 UnsafePointer）。
结构体字段必须显式初始化：不能在字段声明中赋初始值，必须在 __init__() 中初始化。

总结：Mojo 是一门融合 Python 语法亲和性与系统级语言性能优势的新兴编程语言。其核心特性包括强静态类型系统、值语义优先、所有权驱动的内存安全、零成本抽象（traits + 泛型）、编译时元编程、MLIR 异构硬件支持以及与 Python 生态的无缝互操作。祝你编码愉快！🚀

AI 中文社区（简称 AI 中文社），是国内学习交流AI人工智能技术的中文社区网站，这里可获取及贡献任何AI人工智能技术，我们追求自由、简洁、纯粹、分享的多元化人工智能社区。

Mojo 1.0.0b1 语言语法大全