Rust语言精简手册

你好，欢迎来到Rust世界！

如果你以前从未接触过Rust，或者你想尝试写个Rust版的Hello World!。

你可以尝试在Rust练习场输入以下内容，并运行它：

fn main() {
    println!("Hello World!");
}

恭喜你，你已经成功地迈出学习Rust语言的第一步。

接下来会通过这个Rust语言的精简版，带你感受一下Rust世界的精彩。

数据结构

通过关键字定义的数据类型和内存位置。

示例

解释

struct S {}

struct S { x: T }

定义结构体S，包含一个类型为T的成员x

struct S (T);

定义元组结构体S，有一个类型为T的.0编号的成员

struct S;

定义零大小的单元结构体S

enum E {}

enum E { A, B(), C {} }

定义枚举E的成员，可以是单元A，元组B，结构体C

enum E { A = 1 }

如果成员仅是单元，可以拥有显式辨别值

union U {}

static X: T = T();

const X: T = T();

定义常量X，生命周期是全局的，但没有固定的内存地址

let x: T;

在栈上绑定变量x，一次分配，不可变

let mut x: T;

类似let，但允许可变借用

x = y;

y将内存地址转移给x，如果类型T是Copy的，则复制y；否则y后续不可用

创建和访问数据结构。

示例

解释

S { x: y }

实例化结构体S{}，或枚举E::S{}，将成员x设置为y

S { x }

类似上面，但使用了局部变量x

S { ..s }

S { 0: x }

类似下面的S(x)，设置索引.0成员为x

S (x)

设置索引.0成员为x

S

单元结构体S，实例就是其本身

E::C { x: y }

实例化枚举成员C

()

单元类型，唯一的值就是其本身

(x)

括号表达式

(x,)

(S,)

单元素元组类型

[S]

[S; n]

[x; n]

创建一个包含n份值x的拷贝

[x, y]

x[0]

用于不可变内容的索引操作

x[..]

x[a..]

生成在索引a之后所有元素的切片

x[..b]

生成在索引b之前所有元素的切片

x[a..b]

生成在索引a和b之间所有元素的切片

a..b

创建左闭右开区间的范围类型

a..=b

创建全闭区间的范围类型

s.x

通过字段名访问

s.0

通过索引访问，用于元组类型S(T)

类型别名和强制转换

示例

解释

type T = S;

创建类型T的另一个名字S

Self

用于表示trait和实现中的实现类型

self

用于表示方法对象本身

&self

同上，表示借用

&mut self

同上，表示可变借用

self: Box<Self>

智能指针

S as T

消除歧义，限定类型S使用trait``T

S as R

use语法中，导入S为R

x as u32

流程控制

示例

解释

while x {}

loop {}

for x in iter {}

if x {} else {}

'label: loop {}

break

使用break退出一个循环

break x

break 'label

中断'label标签的循环

continue

中断循环体的当前迭代，返回到下一轮循环

continue 'label

中断指定'label标签的循环体的当前迭代，返回到下一轮循环

函数，闭包与`trait`

定义代码块及其抽象。

示例

解释

trait T {}

trait T : R {}

T是R的子trait，任何类型实现T之前必须实现R

impl S {}

实现类型S

impl T for S {}

为类型S实现trait``T

impl !T for S {}

为类型S禁用自动派生auto traits

fn f() {}

fn f() -> S {}

同上，函数返回值为类型S

fn f(&self) {}

定义方法，作为impl的一部分

fn() -> S

|| {}

|x| {}

绑定参数x的闭包

|x| x + x

没有块表达式的闭包

move |x| x + y

|| true

没有参数的闭包

生命周期

示例

解释

'a

&'a S

一个拥有生命周期'a的引用

&'a mut S

同上，但引用的内容可变

S<'a>

一个拥有生命周期'a的类型

fn f<'a>(t: &'a T)

一个函数，其拥有生命周期'a的输入引用，其中'a的存活时间至少与函数的一样长

'static

在整个程序运行的时期中存在

泛型与`trait`约束

泛型会与许多其他结构相结合，例如：struct S<T>, fn f<T>(), ...

示例

解释

S<T>

S<T: R>

T: R, P: S

分别对类型T``P定义约束，类型间用逗号分隔

T: R + S

多重约束，T: R, S是错误的

T: ?Sized

Tb

T: 'a

T: R + 'a

T必须实现trait``R，并且T生命周期需要长于a

'b: 'a

b生命周期需要长于a

S<T> where T: R

类似S<T: R>，较长的约束时更可读

S<T = R>

默认类型参数，关联类型

S<'_>

S<_>

匿名类型推断

S::<T>

turbofish，为泛型中的方法指定具体参数

trait T<X> {}

trait泛型，类型参数X，可以多次实现T

trait T { type X; }

type X = R;

设置关联类型，impl T for S { type X = R; }

impl<T> S<T> {}

为泛型T实现功能

impl S<T> {}

实现S<T>功能

fn f() -> impl T

fn f(x: &impl T)

"impl Trait"语法约束，类似fn f<S:T>(x: &S)

fn f(x: &dyn T)

同上，但是动态分发

fn f() where Self: R

在trait中，只有实现了R的类型可访问f

for<'a>

高阶trait限定

组织代码

将项目划分为更小的单元，并最小化依赖性。

示例

解释

mod m {}

mod m;

定义模块m，在m.rs或m/mod.rs中定义内容

a::b

::b

从root crate搜索b

crate::b

从当前crate搜索b

self::b

从当前模块搜索b

super::b

从父模块搜索b）

use a::b;

use a::{b, c};

同上，多个

use a::b as x;

同上，将b命名为x

use a::b as _;

use a::*;

导入a中一切

pub use a::b;

重新导出a::b

pub T

将可见性修改为公开

pub(crate) T

在当前crate可见

pub(self) T

在当前模块可见

pub(super) T

在当前模块和父模块可见

pub(in a::b) T

对a::b模块路径可见

extern crate a;

extern "C" {}

extern "C" fn f() {}

定义函数暴露给FFI

FFI，Foreign Function Interface，外部语言函数接口

模式匹配与解构

在match或let表达式或函数参数中构造。

示例

解释

match m {}

let S { x } = s;

let绑定模式匹配

let (_, b, _) = abc;

忽略部分

let (a, ..) = abc;

忽略其余

if let Some(x) = get() {}

fn f(S { x }: S)

函数参数，类似let

引用和指针

示例

解释

&S

&[S]

切片引用，包含地址和长度

&str

字符串引用

&dyn S

&mut S

可变引用

*const S

*mut S

同上，可变裸指针

&s

借用，不获取所有权

&mut s

可变借用

ref s

*r

*r = s;

如果r是可变引用，移动或复制s到目标内存

宏和属性

元编程，代码生成，语法扩展

示例

解释

m!()

#[attr]

#[attr = "value"]

属性形式1

#[attr(key = "value")]

属性形式2

#[attr(value)]

属性形式3

#![attr]

属性作用于整个crate

学习心得

学习这种事，关键靠自己。被别人“喂”太多，不一定是好事。
不要期望短期内一次性学会一门编程语言，尤其是Rust语言。

学习资源

NextRust中初始化结构体的3种模式

Last updated 5 years ago

Was this helpful?

Rust语言精简手册

你好，欢迎来到Rust世界！

如果你以前从未接触过Rust，或者你想尝试写个Rust版的Hello World!。

你可以尝试在Rust练习场输入以下内容，并运行它：

fn main() {
    println!("Hello World!");
}

恭喜你，你已经成功地迈出学习Rust语言的第一步。

接下来会通过这个Rust语言的精简版，带你感受一下Rust世界的精彩。

数据结构

通过关键字定义的数据类型和内存位置。

示例

解释

struct S {}

定义结构体S，

struct S { x: T }

定义结构体S，包含一个类型为T的成员x

struct S (T);

定义元组结构体S，有一个类型为T的.0编号的成员

struct S;

定义零大小的单元结构体S

enum E {}

定义枚举E，

enum E { A, B(), C {} }

定义枚举E的成员，可以是单元A，元组B，结构体C

enum E { A = 1 }

如果成员仅是单元，可以拥有显式辨别值

union U {}

用于FFI兼容的不安全类C的联合体，参见Rust

static X: T = T();

具有'static生命周期的全局静态变量，有个固定的内存地址，

const X: T = T();

定义常量X，生命周期是全局的，但没有固定的内存地址

let x: T;

在栈上绑定变量x，一次分配，不可变

let mut x: T;

类似let，但允许可变借用

x = y;

y将内存地址转移给x，如果类型T是Copy的，则复制y；否则y后续不可用

创建和访问数据结构。

示例

解释

S { x: y }

实例化结构体S{}，或枚举E::S{}，将成员x设置为y

S { x }

类似上面，但使用了局部变量x

S { ..s }

使用s设置结构体S剩余的成员，对默认值尤其有用，

S { 0: x }

类似下面的S(x)，设置索引.0成员为x

S (x)

设置索引.0成员为x

S

单元结构体S，实例就是其本身

E::C { x: y }

实例化枚举成员C

()

单元类型，唯一的值就是其本身

(x)

括号表达式

(x,)

单元素元组表达式，

(S,)

单元素元组类型

[S]

不确定大小的数组，切片，

[S; n]

数组类型，S表示数组中元素的类型，n表示数组的大小，

[x; n]

创建一个包含n份值x的拷贝

[x, y]

定义结构体S，

x[0]

用于不可变内容的索引操作

x[..]

用作切片的索引操作，

x[a..]

生成在索引a之后所有元素的切片

x[..b]

生成在索引b之前所有元素的切片

x[a..b]

生成在索引a和b之间所有元素的切片

a..b

创建左闭右开区间的范围类型

a..=b

创建全闭区间的范围类型

s.x

通过字段名访问

s.0

通过索引访问，用于元组类型S(T)

类型别名和强制转换

示例

解释

type T = S;

创建类型T的另一个名字S

Self

用于表示trait和实现中的实现类型

self

用于表示方法对象本身

&self

同上，表示借用

&mut self

同上，表示可变借用

self: Box<Self>

智能指针

S as T

消除歧义，限定类型S使用trait``T

S as R

use语法中，导入S为R

x as u32

原生类型的强制类型转换，

流程控制

示例

解释

while x {}

while循环，当x为true时循环，

loop {}

无限循环，

for x in iter {}

for表达式用于循环遍历迭代器iter，

if x {} else {}

条件表达式，所有分支必须返回相同的类型，

'label: loop {}

标签循环，对嵌套循环中的流程控制很有用，

break

使用break退出一个循环

break x

使loop表达式返回值x，

break 'label

中断'label标签的循环

continue

中断循环体的当前迭代，返回到下一轮循环

continue 'label

中断指定'label标签的循环体的当前迭代，返回到下一轮循环

函数，闭包与`trait`

定义代码块及其抽象。

示例

解释

trait T {}

定义trait，

trait T : R {}

T是R的子trait，任何类型实现T之前必须实现R

impl S {}

实现类型S

impl T for S {}

为类型S实现trait``T

impl !T for S {}

为类型S禁用自动派生auto traits

fn f() {}

定义函数，，或定义关联函数（在impl内部）

fn f() -> S {}

同上，函数返回值为类型S

fn f(&self) {}

定义方法，作为impl的一部分

fn() -> S

函数指针，，不要和trait``Fn混淆

|| {}

闭包，

|x| {}

绑定参数x的闭包

|x| x + x

没有块表达式的闭包

move |x| x + y

强制闭包取得被捕获变量的所有权，

|| true

没有参数的闭包

生命周期

示例

解释

'a

生命周期参数，

&'a S

一个拥有生命周期'a的引用

&'a mut S

同上，但引用的内容可变

S<'a>

一个拥有生命周期'a的类型

fn f<'a>(t: &'a T)

一个函数，其拥有生命周期'a的输入引用，其中'a的存活时间至少与函数的一样长

'static

在整个程序运行的时期中存在

泛型与`trait`约束

泛型会与许多其他结构相结合，例如：struct S<T>, fn f<T>(), ...

示例

解释

S<T>

具有类型参数T的泛型S，

S<T: R>

类型S的类型参数T必须实现trait``R，

T: R, P: S

分别对类型T``P定义约束，类型间用逗号分隔

T: R + S

多重约束，T: R, S是错误的

T: ?Sized

Tb

T: 'a

T生命周期约束，需要长于a），

T: R + 'a

T必须实现trait``R，并且T生命周期需要长于a

'b: 'a

b生命周期需要长于a

S<T> where T: R

类似S<T: R>，较长的约束时更可读

S<T = R>

默认类型参数，关联类型

S<'_>

匿名生命周期推断，

S<_>

匿名类型推断

S::<T>

turbofish，为泛型中的方法指定具体参数

trait T<X> {}

trait泛型，类型参数X，可以多次实现T

trait T { type X; }

trait关联类型，无需标注类型，

type X = R;

设置关联类型，impl T for S { type X = R; }

impl<T> S<T> {}

为泛型T实现功能

impl S<T> {}

实现S<T>功能

fn f() -> impl T

"impl Trait"语法，返回trait``T，

fn f(x: &impl T)

"impl Trait"语法约束，类似fn f<S:T>(x: &S)

fn f(x: &dyn T)

同上，但是动态分发

fn f() where Self: R

在trait中，只有实现了R的类型可访问f

for<'a>

高阶trait限定

组织代码

将项目划分为更小的单元，并最小化依赖性。

示例

解释

mod m {}

定义模块m，在{}中定义内容，

mod m;

定义模块m，在m.rs或m/mod.rs中定义内容

a::b

a中元素b的命名空间路径，

::b

从root crate搜索b

crate::b

从当前crate搜索b

self::b

从当前模块搜索b

super::b

从父模块搜索b）

use a::b;

use声明，导入b，

use a::{b, c};

同上，多个

use a::b as x;

同上，将b命名为x

use a::b as _;

同上，匿名引入b，

use a::*;

导入a中一切

pub use a::b;

重新导出a::b

pub T

将可见性修改为公开

pub(crate) T

在当前crate可见

pub(self) T

在当前模块可见

pub(super) T

在当前模块和父模块可见

pub(in a::b) T

对a::b模块路径可见

extern crate a;

链接外部crate``a，

extern "C" {}

用于FFI*链接外部库，比如"C"，

extern "C" fn f() {}

定义函数暴露给FFI

FFI，Foreign Function Interface，外部语言函数接口

模式匹配与解构

在match或let表达式或函数参数中构造。

示例

解释

match m {}

模式匹配，

let S { x } = s;

let绑定模式匹配

let (_, b, _) = abc;

忽略部分

let (a, ..) = abc;

忽略其余

if let Some(x) = get() {}

若get()匹配Some(x)，则执行代码块，

fn f(S { x }: S)

函数参数，类似let

引用和指针

示例

解释

&S

引用，

&[S]

切片引用，包含地址和长度

&str

字符串引用

&dyn S

trait对象引用，包含地址和虚表，

&mut S

可变引用

*const S

裸指针，不可变的，

*mut S

同上，可变裸指针

&s

借用，不获取所有权

&mut s

可变借用

ref s

引用绑定，

*r

解引用，

*r = s;

如果r是可变引用，移动或复制s到目标内存

宏和属性

元编程，代码生成，语法扩展

示例

解释

m!()

宏调用，

#[attr]

属性用于模块或项，

#[attr = "value"]

属性形式1

#[attr(key = "value")]

属性形式2

#[attr(value)]

属性形式3

#![attr]

属性作用于整个crate

学习心得

学习这种事，关键靠自己。被别人“喂”太多，不一定是好事。
不要期望短期内一次性学会一门编程语言，尤其是Rust语言。

学习资源

NextRust中初始化结构体的3种模式

Last updated 5 years ago

Was this helpful?

数据结构

类型别名和强制转换

流程控制

函数，闭包与trait

生命周期

泛型与trait约束

组织代码

模式匹配与解构

引用和指针

宏和属性

学习心得

学习资源

数据结构

类型别名和强制转换

流程控制

函数，闭包与trait

生命周期

泛型与trait约束

组织代码

模式匹配与解构

引用和指针

宏和属性

学习心得

学习资源

函数，闭包与`trait`

泛型与`trait`约束

函数，闭包与`trait`

泛型与`trait`约束