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

Mojo 1.0.0 语言语法大全

发布于 2026-06-13 · 浏览数 368 · 最后编辑 2026-09-04 13:07

Mojo 1.0.0 语言语法大全

基于 Mojo 1.0.0 正式版（2024年10月发布）。本手册系统地整理了语言的核心语法、类型系统、所有权模型、元编程及标准库等主要内容，供开发者参考。

1. 基础语法

1.1 注释

# 单行注释

"""
多行注释
（实际上 Mojo 支持三引号字符串，但常规使用 #）
"""

1.2 标识符与关键字

标识符规则与 Python 类似：字母、数字、下划线，不能以数字开头。
关键字（部分）：fn, def, struct, trait, let, var, if, else, for, while, match, return, raise, try, except, inout, owned, borrowed, alias, parameter, import, from, as, with, pass, True, False, None 等。

1.3 变量声明

Mojo 是强类型语言，但支持类型推断。

不可变绑定：使用 let

let x: Int = 42
let y = 3.14        # 推断为 Float64

可变绑定：使用 var
```
var counter = 0
counter += 1
```

1.4 类型注解

类型注解使用冒号 : 后跟类型。

let name: String = "Mojo"
var numbers: List[Int] = [1, 2, 3]

1.5 字面量

整数：42, 0xFF, 0b1010
浮点数：3.14, 1e-3
字符串："hello", 'world'
布尔：True, False
空值：None（可选类型）

2. 数据类型

2.1 标量类型

类型	描述
`Int`	平台相关整数（通常 64 位）
`Int8`, `Int16`, `Int32`, `Int64`	有符号定长整数
`UInt8`, `UInt16`, `UInt32`, `UInt64`	无符号定长整数
`Float16`, `Float32`, `Float64`	IEEE 浮点数
`Bool`	布尔类型
`String`	字符串（值类型）
`SIMD`	SIMD 向量类型（见下文）

2.2 SIMD 类型

Mojo 通过 SIMD 类型提供底层向量化操作。

let v = SIMD[DType.float32, 4](1.0, 2.0, 3.0, 4.0)
let sum = v.reduce_add()

常用 dtype：DType.int8, DType.int32, DType.float32, DType.float64 等。

2.3 复合类型

List：动态数组

var list = List[Int]()
list.append(10)
list.append(20)

Dict：哈希表

var d = Dict[String, Int]()
d["key"] = 42

Tuple：固定长度异构元组
```
let t = (1, "hello", True)
```
Set：集合（若标准库提供）
```
var s = Set[Int]()
s.add(5)
```

2.4 指针类型

用于底层内存操作：

DTypePointer：指向特定 dtype 的指针

let p = DTypePointer[DType.int32].alloc(10)
p[0] = 42
p.free()

Pointer：通用指针

var p = Pointer[Int].alloc(1)
p.store(0, 42)

2.5 可选类型

使用 Optional[T] 或 T? 表示可能缺失的值。

var maybe: Optional[Int] = None
maybe = 42
if let value = maybe:
    print(value)

3. 运算符

3.1 算术运算符

+, -, *, /, //（整除），%（取余），**（幂）

3.2 比较运算符

==, !=, <, >, <=, >=

3.3 逻辑运算符

and, or, not

3.4 位运算符

&, |, ^, ~, <<, >>

3.5 赋值运算符

=, +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, <<=, >>=

3.6 身份运算符

is, is not（用于引用比较，但 Mojo 值语义下较少使用）

3.7 成员运算符

in, not in（用于容器）

3.8 其他

所有权转移运算符：^（后置）
范围构造：.., ..<

4. 控制流

4.1 if / elif / else

if condition:
    ...
elif other_condition:
    ...
else:
    ...

4.2 for 循环

for i in range(10):
    print(i)

for item in list:
    print(item)

for index, value in enumerate(list):
    print(index, value)

4.3 while 循环

while condition:
    ...

4.4 match 模式匹配

Mojo 1.0 支持 match 语句进行模式匹配。

match value:
    case 1:
        print("one")
    case 2 | 3:
        print("two or three")
    case _:
        print("other")

5. 函数

5.1 函数定义：`fn` 与 `def`

fn：严格函数，要求类型注解和返回类型，默认不可变参数。
```
fn add(a: Int, b: Int) -> Int:
    return a + b
```
def：宽松函数，类似 Python，可省略类型，自动推断返回类型，参数默认可变。
```
def greet(name):
    print("Hello,", name)
```

5.2 参数修饰符

默认（借用）：参数以只读方式传入，不可修改。
inout：借用可变引用，修改会影响调用方变量，但不转移所有权。
```
fn increment(inout x: Int):
    x += 1
```
owned：转移所有权到函数内，调用方变量失效。
```
fn consume(owned data: String):
    print(data)
```
borrowed：显式只读借用（默认行为，但可明确写出）。
```
fn read(borrowed data: String):
    print(data)
```

5.3 返回类型与 `raises`

函数可能抛出错误时，需标注 raises。

fn divide(a: Int, b: Int) raises -> Int:
    if b == 0:
        raise "division by zero"
    return a // b

5.4 默认参数与关键字参数

fn greet(name: String, greeting: String = "Hello") -> String:
    return greeting + ", " + name

let msg = greet("Alice", greeting="Hi")

5.5 函数重载

同名函数可通过参数类型或数量进行重载。

fn process(x: Int) -> Int:
    return x * 2

fn process(x: String) -> String:
    return x + x

5.6 嵌套函数与闭包

支持在函数内定义函数，并捕获外部变量。

fn outer() -> Int:
    let factor = 10
    fn inner(x: Int) -> Int:
        return x * factor
    return inner(5)

6. 结构体与类

Mojo 使用 struct 定义值类型（默认拷贝语义），也可以通过 @value 装饰器获得自动生成的构造函数、比较方法等。

6.1 基本 struct 定义

struct Point:
    var x: Float64
    var y: Float64

    fn __init__(inout self, x: Float64, y: Float64):
        self.x = x
        self.y = y

    fn norm(self) -> Float64:
        return sqrt(self.x * self.x + self.y * self.y)

6.2 `@value` 装饰器

自动生成 __init__、__eq__、__ne__、__hash__ 等。

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

let c = Color(255, 0, 0)   # 自动生成构造函数
if c == Color(255, 0, 0):
    print("same color")

6.3 析构函数 `del`

struct Resource:
    var handle: Int

    fn __init__(inout self):
        self.handle = acquire_resource()

    fn __del__(owned self):
        release_resource(self.handle)

6.4 移动语义

通过 __moveinit__ 自定义移动行为。

struct Buffer:
    var data: DTypePointer[DType.float32]

    fn __init__(inout self, size: Int):
        self.data = DTypePointer[DType.float32].alloc(size)

    fn __moveinit__(inout self, owned other: Buffer):
        self.data = other.data
        other.data = DTypePointer[DType.float32]()  # 置空，防止双重释放

    fn __del__(owned self):
        self.data.free()

6.5 生命周期与借用

Mojo 的借用检查确保引用不会超过所有者的生命周期。

7. Trait 与接口

7.1 定义 trait

trait Shape:
    fn area(self) -> Float64
    fn name(self) -> String:
        return "shape"   # 可提供默认实现

7.2 实现 trait

使用 @conforms 装饰器显式声明实现。

@conforms(Shape)
struct Circle:
    var radius: Float64

    fn area(self) -> Float64:
        return 3.14159 * self.radius * self.radius

7.3 trait 继承

trait Drawable:
    fn draw(self)

trait Shape2: Drawable:
    fn area(self) -> Float64

7.4 泛型约束中使用 trait

fn total_area[T: Shape](shapes: List[T]) -> Float64:
    var sum = 0.0
    for shape in shapes:
        sum += shape.area()
    return sum

8. 泛型与参数化

8.1 泛型函数

fn max[T: Comparable](a: T, b: T) -> T:
    return a if a > b else b

8.2 泛型结构体

struct Pair[T, U]:
    var first: T
    var second: U

let p = Pair[Int, String](1, "one")

8.3 编译时参数（parameter）

使用 @parameter 标记函数在编译期执行，常用于元编程。

@parameter
fn pow2(x: Int) -> Int:
    return 1 << x

alias N = pow2(4)   # 编译时计算为 16

8.4 别名 `alias`

定义类型别名或编译时常量。

alias IntList = List[Int]
alias VERSION = "1.0.0"

9. 错误处理

Mojo 1.0 统一使用 raise 与 try/except 进行错误处理。

9.1 抛出错误

fn open_file(path: String) raises -> File:
    if not exists(path):
        raise "file not found"
    return File(path)

9.2 捕获错误

try:
    let f = open_file("data.txt")
    ...
except e:
    print("Error:", e)

9.3 错误类型

可以使用任何类型作为错误值，常用 String 或自定义错误类型。

struct MyError:
    var code: Int
    var message: String

fn risky() raises -> Int:
    raise MyError(code=404, message="not found")

10. 所有权与内存管理

Mojo 采用值语义 + 所有权系统，确保内存安全且无需垃圾回收。

10.1 值语义与复制

默认情况下，赋值和传参执行深拷贝（值复制）。对于大对象，应使用 owned 转移或 inout 借用。

10.2 所有权转移 `owned`

函数参数：owned 表示所有权转移给函数。

变量转移：使用后置 ^ 运算符显式转移所有权。

var s = "hello"
consume(s^)   # s 所有权转移，之后 s 不可用

10.3 借用

inout：可变借用，函数内可修改原变量。
borrowed：只读借用（默认行为）。

10.4 生命周期规则

引用不能超过所有者生命周期。
编译器会检查借用规则，避免悬垂引用。

11. 元编程与编译时计算

11.1 `@parameter` 函数

编译期执行的函数，结果可用于类型参数或常量。

@parameter
fn factorial(n: Int) -> Int:
    var result = 1
    for i in range(1, n+1):
        result *= i
    return result

alias FACT5 = factorial(5)   # 120

11.2 编译时条件

使用 @parameter if 或 constrained 进行条件编译。

@parameter
fn choose[T: AnyType]() -> Bool:
    return T is Int

fn process[T: AnyType](x: T):
    constrained[choose[T]()]():
        print("integer specialization")
    else:
        print("generic")

11.3 循环展开

编译器自动优化，也可用 @unroll 显式提示。

12. 模块与包管理

12.1 导入模块

from math import sqrt, pi
import os

12.2 标准库模块

Mojo 标准库位于 mojo 命名空间下，如 mojo.math, mojo.collections, mojo.os。

12.3 包管理

使用 mojo package 命令管理依赖，类似于 Cargo/npm。

mojo package init my_project
mojo package add <dependency>
mojo package build

12.4 命名空间与模块文件

模块文件以 .mojo 或 .🔥 为扩展名，目录可包含 __init__.mojo。

13. 并行与 SIMD

13.1 并行循环

使用 parallelize 简化多线程编程。

from algorithm import parallelize

var data = List[Float64](...)
parallelize[func](data, num_workers=4):
    for item in data:
        item.process()

13.2 SIMD 向量化

可直接操作 SIMD 类型，或使用 vectorize 装饰器自动向量化。

@vectorize
fn compute(x: Float64) -> Float64:
    return x * x + 2.0

14. Python 互操作

14.1 调用 Python 模块

from python import Python

let np = Python.import_module("numpy")
let arr = np.array([1, 2, 3])
print(arr)

14.2 与 Python 对象交互

Mojo 可以直接使用 Python 对象，但类型检查较松。适合逐步迁移性能热点。

15. 标准库概览

Mojo 1.0 标准库包含常用模块（部分）：

模块	功能
`mojo.collections`	List, Dict, Set, Optional, Tuple 等容器
`mojo.math`	数学函数、常量
`mojo.os`	操作系统接口、文件 I/O
`mojo.string`	字符串处理
`mojo.algorithm`	排序、搜索、并行算法
`mojo.random`	随机数生成
`mojo.testing`	单元测试框架
`mojo.tensor`	张量运算
`mojo.python`	Python 互操作

16. 附录：关键字与运算符优先级

16.1 关键字列表

alias, and, as, borrowed, break, case, constrained, continue, def, del,
elif, else, except, False, fn, for, from, if, import, in, inout, is, let,
match, None, not, or, owned, pass, parameter, raise, return, struct, trait,
True, try, var, while, with, yield

16.2 运算符优先级（从高到低）

() [] .
^（所有权转移）
**
~ + -（一元）
* / // %
+ -（二元）
<< >>
&
^（位异或）
|
== != < > <= >=
not
and
or
= += -= 等赋值运算符

结语

本手册尽可能全面地概括了 Mojo 1.0.0 正式版的核心语法与特性。由于语言仍在演进，建议以官方文档和更新日志为最终依据。掌握这些语法元素，你将能够充分发挥 Mojo 在系统编程、AI 加速和高性能计算领域的强大能力。

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

Mojo 1.0.0 语言语法大全

Mojo 1.0.0 语言语法大全

目录

1. 基础语法

1.1 注释

1.2 标识符与关键字

1.3 变量声明

1.4 类型注解

1.5 字面量

2. 数据类型

2.1 标量类型

2.2 SIMD 类型

2.3 复合类型

2.4 指针类型

2.5 可选类型

3. 运算符

3.1 算术运算符

3.2 比较运算符

3.3 逻辑运算符

3.4 位运算符

3.5 赋值运算符

3.6 身份运算符

3.7 成员运算符

3.8 其他

4. 控制流

4.1 if / elif / else

4.2 for 循环

4.3 while 循环

4.4 match 模式匹配

5. 函数

5.1 函数定义：fn 与 def

5.2 参数修饰符

5.3 返回类型与 raises

5.4 默认参数与关键字参数

5.5 函数重载

5.6 嵌套函数与闭包

6. 结构体与类

6.1 基本 struct 定义

6.2 @value 装饰器

6.3 析构函数 __del__

6.4 移动语义

6.5 生命周期与借用

7. Trait 与接口

7.1 定义 trait

7.2 实现 trait

7.3 trait 继承

7.4 泛型约束中使用 trait

8. 泛型与参数化

8.1 泛型函数

8.2 泛型结构体

8.3 编译时参数（parameter）

8.4 别名 alias

9. 错误处理

9.1 抛出错误

9.2 捕获错误

9.3 错误类型

10. 所有权与内存管理

10.1 值语义与复制

10.2 所有权转移 owned

10.3 借用

10.4 生命周期规则

11. 元编程与编译时计算

11.1 @parameter 函数

11.2 编译时条件

11.3 循环展开

12. 模块与包管理

12.1 导入模块

12.2 标准库模块

12.3 包管理

12.4 命名空间与模块文件

13. 并行与 SIMD

13.1 并行循环

13.2 SIMD 向量化

14. Python 互操作

14.1 调用 Python 模块

14.2 与 Python 对象交互

15. 标准库概览

16. 附录：关键字与运算符优先级

16.1 关键字列表

5.1 函数定义：`fn` 与 `def`

5.3 返回类型与 `raises`

6.2 `@value` 装饰器

6.3 析构函数 `del`

8.4 别名 `alias`

10.2 所有权转移 `owned`

11.1 `@parameter` 函数

欢迎来到 AI 中文社区（简称 AI 中文社），这里是学习交流 AI 人工智能技术的中文社区。按下 Ctrl+D 或 ⌘+D 收藏本站。