Rust-CheatSheet

  1. Eric
  2. CheatSheet
  3. Rust-CheatSheet
4.5 周庆 CheatSheet
Rust-CheatSheet

1. Data Structure

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

  • struct S {} 定义一个名称为S的结构体
    • struct S { x: T } 定义结构体字段 x 类型为 T
    • struct S(T) 定义tuple结构体 .0 元素类型为 T
    • struct S 定义一个 Zero sized 的单元结构体.不占用空间,编译器优化
  • enum E {} 定义结构体
    • enum E { A, B(), C{} } 定义 enum, 可以是单元 A, 元组 B() 和 struct-like C{}
    • enum E { A = 1} 判别值 A - 1
  • union U {} 不安全的类似 C 的 Union, 用于 FFI 兼容性
  • static X:T = T() 全局变量 static 生命周期, 单内存地址
  • const X:T = T() 定义常量, 使用的时候拷贝到临时内存
  • let x:T 分配 T stack 数据 绑定到 x, 赋值一次, 不可变
  • let mut x:T 和 let 类似,是可变的,借用可变
    • x = y 如果 y 是不能被Copy, 移动(move) y 到 x, y将失效. 否则复制y

绑定变量存在于同步代码的stack中. 在 async {} 中,它们成为 async 状态机的一部分,可能驻留在heap. 从技术上讲,可变和不可变是用词不当. 不可变绑定或共享引用可能仍包含 Cell, 从而提供内部可变性.

创建和访问数据结构,和更多的符号类型

  • S { x: y } 创建 struct S {} 或者 enum E::S {} 的x字段设置y值
  • S { x } 设置变量 x 到 struct x字段
  • S { ..s } 使用 s 的全部同字段填充
  • S { 0: x} tuple struct .0 设置 x
  • S(x) 创建 struct S(T) 或者 使用 enum E::S() x 赋值给 元组结构体 .0 元素
  • S S 单元 struct, enum E::S 创建 S
  • E::C { x:y } 创建 enum 成员是 struct
  • () 空 tuple
  • (x) 括号表达式
  • (x,) 单元素 tuple
  • (S,) 单元素类型 tuple
  • [S] Slice 不知道长度的Type Array
  • [S;n] 元素类型为 S, 长度为 n Array
  • [x;n] Array 实例 n 个 x的拷贝
  • [x,y] Array 实例 x,y 元素
  • x[0] 集合索引 x.usize. Implementable with Index, IndexMut
  • x[..] slice 全部元素
  • x[a..b] 右索引元算不包含,第 a 到 b 个元素 slice
  • x[..b] 右索引元算不包含,第 0 到 b 个元素 slice
  • x[a..=b] 右索引元算包含,第 a 到 b 个元素 slice
  • x[..=b] 右索引元算包含,第 0 到 b 个元素 slice
  • s.x 命名字段访问,如果 x 不是类型 S 的一部分,可能会尝试Deref.
  • s.0 编号字段访问,用于元组类型 S

2. References & Pointers(引用和指针)

授予对未拥有的内存的访问权限. 另请参阅泛型和约束部分.

  • &S 共享引用
    • &[S] 特殊 slice 引用(包含地址,长度)
    • &str 特殊 string slice 引用(包含地址,长度)
    • &mut S 允许可变性的独占引用 (同 &mut [S], &mut dyn S, … )
    • &dyn T 特殊 Trait object 引用包含(address,vtable)
  • &s 共享borrow (e.g., address, len, vtable, … of this s, like 0x1234)
    • &mut s 独占借用可变
    • &raw const s 通过w/o引用创建原始指针, c.ptr:addr_of!()
    • &raw mut s 同上,可变. 原始指针,需要未对齐的压缩字段
  • ref s 通过引用绑定, 使绑定引用类型
    • let ref r = s 效果相同 let r = &s
    • let S {ref mut x } = s 可变绑定(let x = &mut s.x), 简写的析构
  • *r 取引用值
    • *r = s 如果 r 是可变引用,move or copy s 到目标memory
    • s = *r 如果r可以Copy,复制r
    • s = *r 如果r不可以Copy,错误
    • s = *my_box Box特殊用例,如果Box内容不能Copy,move Box的内容出来
  • 'a 静态分析中流的生命周期参数持续时间
    • &'a S 只接受一个带有 s 的地址, 地址存在生命周期比 ‘a 更长
    • &'a mut S 同上,但是可变
    • struct S<'a> {} S的地址生命周期是 ‘a, 创建 S 决定 ‘a 生命周期长短
    • trait T<'a> {} S impl T ,S 决定 ‘a 生命周期长短
    • fn f<'a>(t: &'a T) 调用者决定 ‘a 生命周期长短
  • 'static 持续整个程序执行的特殊生命周期

3. Functions & Behavior (函数和行为)

定义代码单元及其抽象

  • trait T {} 定义一个 trait； 其他人可以 implement
  • trait T:R {} T 是子 trait, S 是父级 trait, S 必须 impl R trait 之后才能 impl T trait
  • impl S {} 实现 S 的方法
  • impl T for S {} S type 实现 T trait 方法
  • impl !T for S {} 禁用 T trait 的默认实现
  • fn f() {} 定义函数,如果在 impl 内部则是实现方法
  • fn f() -> S {} 返回值 Type S
  • fn f(&self) {} 在 impl 内部定义方法
  • const fn f() {} 常量函数,在编译时使用
  • async fn f() {} Async 函数变体, f 函数 返回 impl Future
  • async fn f() -> S {} 同上 返回 impl Future<Output=S>
  • async { x } 在函数内部使用, { x } 返回 impl Future<Output=X>
  • fn() -> S 函数指针,比包内存保存的地址
  • Fn() -> S Callable Trait, 被闭包 impl
  • || {} 闭包 borrow 捕捉变量
    • |x| {} 闭包参数 x
    • |x| x + x 闭包返回简单表达式
    • move |x| x + y 闭包对其捕获的所有权； 即 y 转移到闭包。
    • return || true 闭包有时候看其来像 or, 这里 return 的是闭包
  • unsafe 如果你喜欢周五晚上调试错误代码； 请使用不安全代码
    • unsafe fn f() {} Means “calling can cause UB, ↓ YOU must check requirements”
    • unsafe trait T {} Means “careless impl. of T can cause UB; implementor must check”
    • unsafe { f(); } Guarantees to compiler “I have checked requirements, trust me”
    • unsafe impl T for S {} Guarantees S is well-behaved w.r.t T; people may use T on S safely

4. Control Flow

  • while x {} 如果 x 是 true 一直执行
  • loop {} loop 直到 break, Can yield value with break x
  • for x in iter {} 语法糖 loop over iterators
  • if x {} else {} 条件分支
  • 'label: loop {} Loop label, 多见嵌套 loop
  • break beak exit a loop
    • break x 跳出loop with x 值
    • break 'label 跳出 ‘label 的 loop
    • break 'label x 跳出 ‘label loop with x 值
  • continue 继续
  • continue 'lable 继续 ‘lable loop
  • x? Result 结果错误处理
  • x.await async 内部使用,直到 Future or Stream x Ready
  • return x 提前返回值
  • f() 函数闭包调用
  • x.f() 方法调用
  • X::f(x) 除非 impl Copy for X {},否则只能被调用一次
  • X::f(&x) 方法调用
  • X::f(&mut x) 方法调用
  • S::f(&x) Same as x.f() if X derefs to S, i.e., x.f() finds methods of S
  • T::f(&x) Same as x.f() if X impl T, i.e., x.f() finds methods of T if in scope
  • X::f() 调用关联函数
  • <X as T>::f() 调用 trait T::f() X的实现

5. Organizing Code 组织代码

将项目分割成更小的单元并最小化依赖性

  • mod m {} 定义 mod, 从 {} 中获取 mod 定义代码
  • mod m; 定义 mod, 获取定义内容 m.rs or m/mod.rs 文件
  • a::b Namespace 路径
  • ::b 搜索 b 相对于 crate root️
  • crate::b 搜索 b 相对于 crate root️
  • self::b 搜索 b 相对于当前 module
  • super::b 搜索 b 相对于当前 parent
  • use a::b; 直接使用.
  • use a::{b, c}; 简写 a::b a::c.
  • use a::b as x; 重命名.
  • use a::b as _; 将 b 匿名带入作用域，对于名称冲突的特征很有用
  • use a::*; 把所有的东西都带进来，只有在 a 是一些prelude
  • pub use a::b; 将 a::b 带入范围并从此处导出
  • pub T 导出
    • pub(crate) T Visible at most 1 in current crate.
    • pub(super) T Visible at most 1 in parent.
    • pub(self) T Visible at most 1 in current module (default, same as no pub).
    • pub(in a::b) T Visible at most1 in ancestor a::b.
  • extern crate a; Declare dependency on external crate; just use a::b in ‘18.
  • extern "C" {} Declare external dependencies and ABI from FFI.
  • extern "C" fn f() {} Define function to be exported with ABI (e.g., “C”) to FFI.

1 Items in child modules always have access to any item, regardless if pub or not.

6. Type Aliases and Casts (类型别名和类型转换)

类型的简写名称，以及将一种类型转换为另一种类型的方法

  • type T = S; 类型重命名(alias)
  • Self Alias implementing Type e.g. fn new() -> Self
  • self 在方法中出现 fn f(self) {} 和 fn f(self: Self) {}等效
    • &self 引用 borrow 等效于 fn f(self: Self) {}
    • &mut self 引用可变 borrow 等效于 fn f(self: &mut Self) {}
    • self: Box<Self> 任意自类型，为智能指针添加方法 my_box.f_of_self()
  • S as T 消除歧义 type S as Trait T eg <S as T>::f()
  • S as R 导入 use, 导入 S 重命名为 R, eg use a::S as R
  • x as u32 原始类型转换

7. Macros & Attributes 宏和属性

在实际编译发生之前扩展代码生成结构

  • m!() 宏调用 also m!{},m![]
  • #[attr] 外部属性,注解一下的item
  • #![attr] 内部属性,注解上面,周围的item

宏的内部

  • $x:ty 宏捕捉
  • $x 宏替换, eg 捕捉 上一个例子 $x:ty
  • $(x),* 宏重复>=0次
  • $(x),? 宏重复0 or 1次
  • $(x),+ 宏重复>=1次
  • $(x)<<+ << 和 上面例子 , 一样都是分割符

8. Pattern Matching

在 match 或 let 表达式或函数参数中找到的构造

  • match m {} 开始模式匹配
  • let S(x) = get(); let 析构
  • let S { x } = s; x 绑定到 s.x
  • let (_,b,_) = abc; b 绑定到 abc.1
  • let (a,..) = abc; a 绑定到 abc.0 丢弃之后数据
  • let (.., a, b) = (1,2); a b 绑定到最后两个元素,丢弃之前数据
  • let Some(x) = get(); 🛑 模式匹配被拒绝, 使用 if let
  • if let Some(x) = get() {} x 被匹配到 enum 成员值, 语法糖
  • while let Some(x) = get() {} 一直执行 get() 如果模式匹配
  • fn f(S {x} :S 函数参数析构, 在 f(s) 中 x 绑定到s.x

匹配表达式中的模式匹配 arms. 这些 arms 的左侧也可以在 let 表达式中找到

  • E::A => {} 匹配枚举变量 A
  • E::B ( .. ) => {} 匹配枚举 tuple 变量 B, 通配符任何索引
  • E::B { .. } => {} 匹配枚举 struct 变量 B, 通配符任何索引
  • S { x: 0, y: 1 } => {} 匹配枚举 struct, s.x == 0 && s.y == 1
  • S { x: a, y: b } => {} 匹配枚举 struct, 绑定 s.x 到 a,绑定 s.y 到 b
  • S { x, y } => {} 上面例子的简写
  • S { .. } => {} 匹配 struct 任意值
  • D => {} 匹配枚举D
  • _ => {} 匹配余下的其他值
  • 0 | 1 => {} 模式替代，或模式
    • E::A | E::Z 同上,枚举
    • E::C {x} | E::D {x} 同上,struct x值
  • (a, 0) => {} 模式匹配,a = s.0 s.1 == 0
  • [a, 0] => {} 模式匹配,a = s[0] s[1] == 0
    • [1, ..] => {} 模式匹配 Array s[0] == 1
    • [1, .., 5] => {} 模式匹配 Array 首元素 == 1 尾元素 == 5
    • [1, x @ .., 5] => {} Same, but also bind x to slice representing middle (c. next entry)
  • x @ 1..=5 => {} Bind matched to x; pattern binding, here x would be 1, 2, … or 5
    • Err(x @ Error {..}) => {} Also works nested, here x binds to Error, esp. useful with if below
  • S { x } if x > 10 => {} Pattern match guards, condition must be true as well to match

9. Generics & Constraints

泛型与类型构造函数、特征和函数相结合，为您的用户提供更大的灵活性

  • S<T> 泛型, T是泛型参数
  • S<T: R> 泛型,参数T trait bound R, R必须是trait
    • T: R, P: S 泛型参数 T 绑定 trait R , 泛型参数 P 绑定 trait S
    • T: R, S 🛑 错误写法
    • T: R + S 泛型参数 T 绑定 trait R 和 S
    • T: R + 'a 泛型参数 T 绑定 trait R 和 满足 ‘a 生命周期
    • T: ?Sized 泛型参数 T 禁止绑定 Sized trait
    • T: 'a 生命周期绑定 ‘a
    • T: 'static Same; does esp. not mean value t will 🛑 live ‘static, only that it could.
    • 'b: 'a ‘b 生命周期 必须和 ‘a生命周期相同
  • S<const N: usize> Generic const bound; ? user of type S can provide constant value N.
    • S<10> Where used, const bounds can be provided as primitive values.
    • S<{5+5}> Expressions must be put in curly brackets.
  • S<T> where T: R 语法糖 S<T: R>
    • S<T> where u8: R<T> where 也可以限制其他的类型.
  • S<T = R> 泛型参数 T 默认类型 R Default type parameter BK for associated type.
  • S<'_> Inferred anonymous lifetime; asks compiler to ‘figure it out’ if obvious.
  • S<_> 匿名类型 eg let x: Vec<_> = iter.collect()
  • S::<T> 调用函数消除未知 eg f::<u32>()
  • trait T<X> {} 泛型trait X. Can have multiple impl T for S (one per X).
  • trait T { type X; } Defines associated type BK RFC X. Only one impl T for S possible.
    • type X = R; Set associated type within impl T for S { type X = R; }.
  • impl<T> S<T> {} 实现方法 <T> 必须在类型之前写出来，以使类型 T 代表泛型。
  • impl S<T> {} 实现方法 S<T>, T 是具体类型 (e.g., S<u32>).
  • fn f() -> impl T 返回结果必须实现trait T.
  • fn f(x: &impl T) Trait bound, 参数x 类型必须实现 T trait, 类似于 fn f<S:T>(x: &S).
  • fn f(x: &dyn T) 标记动态分配, f 不会是单态.
  • fn f() where Self: R; In trait T {}, make f accessible only on types known to also impl R.
    • fn f() where Self: Sized; Using Sized can opt f out of dyn T trait object vtable, enabling trait obj.
    • fn f() where Self: R {} Other R useful w. dflt. methods (non dflt. would need be impl’ed anyway).

10. Higher-Ranked Items

  • for<'a> Marker for higher-ranked bounds
    • trait T: for<'a> R<'a> {} Any S that impl T would also have to fulfill R for any lifetime.
  • fn(&'a u8) Fn. ptr. type holding fn callable with specific lifetime 'a.
  • for<'a> fn(&'a u8) Higher-ranked holding fn callable with any lt.; subtype of above.
    • fn(&'_ u8) Same; automatically expanded to type for<'a> fn(&'a u8).
    • fn(&u8) Same; automatically expanded to type for<'a> fn(&'a u8).
  • dyn for<'a> Fn(&'a u8) Higher-ranked (trait-object) type, works like fn above.
    • dyn Fn(&'_ u8) Same; automatically expanded to type dyn for<'a> Fn(&'a u8).
    • dyn Fn(&u8) Same; automatically expanded to type dyn for<'a> Fn(&'a u8).

Yes, the for<> is part of the type, which is why you write impl T for for<'a> fn(&'a u8) below.

Implementing Traits Explanation

  • impl<'a> T for fn(&'a u8) {} For fn. pointer, where call accepts specific lt. 'a, impl trait T
  • impl T for for<'a> fn(&'a u8) {} For fn. pointer, where call accepts any lt., impl trait T
  • impl T for fn(&u8) {} Same, short version.

11. String 字符串

  • "..." String literal, UTF-8, will interpret \n as line break 0xA, …
  • r"..." 原始字符串 不转义 \n, …
  • r#"..."# Raw string literal, UTF-8, but can also contain ". Number of # can vary.
  • b"..." Byte 字符串字面值; ASCII [u8], 不是字符串类型.
  • br"...", br#"..."# 原始 byte 字符串字面值, ASCII [u8], combination of the above.
  • '🦀' 固定 4 byte unicode ‘char’
  • b'x' ASCII byte 字面值.

类别和标签

TCP/IP notes CPP CheatSheet 快速入门 快速查询 Jekyll Github Python Golang Shell Bash docker 教程 container nginx dockerfile golang Spider 钉钉 PhantomJS RPC protobuf gRPC 文件 操作 GUI reflect 网络请求 代理 http chromedp Go进阶 工具 Vim Javascript seaweedfs Raft raft Git Nginx RESTful gitbook node npm github pages toml lumen laravel cors markdown 日志 log mysql 定时任务 php 程序员 Python教程 redis Dockerhub Docker OSS 网络协议 python 运维开发 kali linux 树莓派 raspberryPi algorithm 算法 黑客 hack ssh xtermjs shell context gcc g++ jekyll 破解 LDAP Linux 有声读物 CSS ES6 OAuth2 Prometheus Grafana Nes Game HTTP3 Java 动手 Gateway 网关 Rust笔记 fullstack chrome

英文主站 | Golang Captcha Open Source Project | Youtube Channel | Bilibli Channel | neochau@gmail.com  |  Github Account Mojocn | 鄂ICP备16006181号-4

目录