Rust 快速参考备忘单,旨在为编写基本语法和方法提供帮助。
配置参考。下载 CodeLLDB,选择 rust 自动生成 launch.json 文件
{
"configurations": [
// 添加一下行,使 vec/hashmap 等类型显示正常
"sourceLanguages": ["rust"]
]
}
将编译文件与标准库的位置进行映射
{
"lldb.launch.sourceMap": {
// 你自己的映射 hash 和映射路径
"/rustc/4b91a6ea7258a947e59c6522cd5898e7c0a6a88f": "/Users/feiwu/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust"
}
}
fn main() {
println!("Hello, World!");
}
$ rustc Hello_World.rs
$ ./Hello_World
Hello, World!
:- | :- |
---|---|
bool | 布尔值 (true / false ) |
char | 字符 |
f32 , f64 | 32 位、64 位浮点数 |
i64 , i32 , i16 , i8 | 有符号 16- ... 整数 |
u64 , u32 , u16 , u8 | 无符号 16 位,... 整数 |
isize | 指针大小的有符号整数 |
usize | 指针大小的无符号整数 |
查看: Rust 类型
// 单个占位符
println!("{}", 1);
// 多个占位符
println!("{} {}", 1, 3);
// 位置参数
println!("{0} 是 {1} {2},{0} 也是 {3} 编程语言", "Rust", "cool", "language", "safe");
// 命名参数
println!("{country} 是一个团结的国家", country = "China");
// 占位符特征 :b 表示二进制, :0x 表示十六进制, :o 表示八进制
println!("让我们打印 76 是二进制的 {:b} ,十六进制等价物是 {:0x} 八进制等价物是 {:o}", 76, 76, 76);
// 调试特征
println!("使用调试特征 {:?} 在此处打印我们想要的任何内容", (76, 'A', 90));
// 1.58 中的新格式字符串
let x = "world";
println!("Hello {x}!");
// 打印输出
print!("Hello World\n");
// 打印后追加新行
println!("追加新行");
// 打印为错误
eprint!("这是一个错误\n");
// 打印为新行错误
eprintln!("这是新行的错误");
// 初始化和声明变量
let some_variable = "This_is_a_variable";
// 使变量可变
let mut mutable_variable = "Mutable";
// 分配多个变量
let (name, age) = ("ElementalX", 20);
// (全局)常量
const SCREAMING_SNAKE_CASE:i64 = 9;
// 行注释
/*.............块注释 */
/// 外部文档注释
//! 内部文档评论
另见: 注释 (doc.rust-lang.org)
fn test(){
println!("这是一个函数!");
}
fn main(){
test();
}
查看: Functions
macro_rules! foo {
($l:tt) => { bar!($l); }
}
macro_rules! bar {
(3) => {}
}
foo!(3);
:- | :- |
---|---|
item | 程序项 |
block | 块表达式 |
stmt | 语句 (注意此选择器不匹配句尾的分号) |
pat | 模式 |
expr | 表达式 |
ty | 类型 |
ident | 标识符或关键字 |
path | 类型表达式 形式的路径 |
tt | token 树(单个 token 或宏匹配定界符 () 、[] 或 {} 中的标记) |
meta | 属性,属性中的内容 |
lifetime | 生存期 token |
vis | 可能为空的可见性限定符 |
literal | 匹配 -? 字面量表达式 |
结构体是一个使用关键字 struct
定义的标称型(nominal)结构体类型
struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 11 };
let px: i32 = p.x;
struct Color (i32, i32, i32);
let black = Color(0,0,0);
不关心该类型的内容, 只关心它的行为。
struct Solution;
impl Solution{
// ...
}
在 rust 中,语句无需返回值,而表达式总要返回值
let a = "hello".to_string();
let b = a + " world";
println!("{}", b);
fn main(){
let x = {
let a = "hello".to_string();
a + " world"
};
println!("{}", x);
// hello world
}
产生式/句法规则 | 句法 | 类型 | 区间语义 |
---|---|---|---|
RangeExpr | start..end | std::ops::Range | start ≤ x < end |
RangeFromExpr | start.. | std::ops::RangeFrom | start ≤ x |
RangeToExpr | ..end | std::ops::RangeTo | x < end |
RangeFullExpr | .. | std::ops::RangeFull | - |
RangeInclusiveExpr | start..=end | std::ops::RangeInclusive | start ≤ x ≤ end |
RangeToInclusiveExpr | ..=end | std::ops::RangeToInclusive | x ≤ end |
type Point = (u8, u8);
let p: Point = (41, 68);
let mut a: u32 = 8;
let b = 877_u64;
let c = 8999i64;
let d = -90;
let mut sixty_bit_float: f64 = 89.90;
let thirty_two_bit_float: f32 = 7.90;
let just_a_float = 69.69;
let true_val: bool = true;
let false_val: bool = false;
let just_a_bool = true;
let is_true = 8 < 5; // => false
let first_letter_of_alphabet = 'a';
let explicit_char: char = 'F';
let implicit_char = '8';
let emoji = "\u{1f600}"; // => 😀
let community_name = "AXIAL";
let no_of_members: &str = "ten";
println!("社区的名称是 {community_name},它有 {no_of_members} 个成员");
查看: 字符串
这里介绍的是固定长度的数组。rust 中常用的是集合类型 vec 表示的动态数组
┌─────┬─────┬─────┬─────┬─────┬─────┐
| 92 | 97 | 98 | 99 | 98 | 94 |
└─────┴─────┴─────┴─────┴─────┴─────┘
0 1 2 3 4 5
let array: [i64; 6] = [92,97,98,99,98,94];
let mut array: [i32 ; 3] = [2,6,10];
array[1] = 4;
array[2] = 6;
使用 mut
关键字使其可变
let mut array: [ i64; 4] = [1,2,3,4];
// 下限包括在内,上限不包括在内
let mut slices: &[i64] = &array[0..3]
println!("切片的元素是:{slices:?}");
let tuple = (1, 'A' , "Cool", 78, true);
let cs:&str = "备忘清单";
// => 为开发者分享备忘单
println!("为开发者分享 {cs}");
// 创建一个空字符串对象
let my_string = String::new;
// 转换为字符串对象
let S_string = a_string.to_string()
// 创建一个初始化的字符串对象
let lang = String::from("Rust");
println!("First language is {lang}");
let rand = String::from("Random String");
rand.capacity() // => 13
以字节为单位计算字符串的容量
let s = String::with_capacity(10);
指定一个足够大的容量值,来减少内存拷贝
let name = String::from("ElementalX");
name.contains("Element") // => true
检查子字符串是否包含在原始字符串中
let mut half_text = String::from("Hal");
half_text.push('f'); // => Half
let mut hi = String::from("Hey there...");
hi.push_str("How are you doing??");
// => Hey there...How are you doing??
println!("{hi}");
let str1 = r#"\hello"#;
println!("{}", str1);
// \hello
原生字符串,无需增加转义字符(\
)转义
let str2 = b'a';
println!("{}", str2);
// 97
let str3 = b"\\hello";
println!("{:?}", str3);
// [92, 104, 101, 108, 108, 111]
let str4 = br#"\hello"#;
println!("{:?}", str4);
// [92, 104, 101, 108, 108, 111]
let v: Vec<i32> = Vec::new();
// 使用宏
let v1 = vec![1, 2, 3];
let v = vec![1, 2, 3, 4, 5];
let element = &v[100];
// panic,越界
let element2 = v.get(100);
println!("{:?}", element2);
//None
只读取数组中的元素
let v = vec![1, 2, 3];
for i in &v {
println!("{}", i);
}
遍历的同时修改数组中的元素
let mut v = vec![1, 2, 3];
for i in &mut v {
*i += 10
}
j0 j1 j2 j3 j4 j5
┌────┬────┬────┬────┬────┬────┐
i0 | 1 | 2 | 3 | 4 | 5 | 6 |
├────┼────┼────┼────┼────┼────┤
i1 | 6 | 5 | 4 | 3 | 2 | 1 |
└────┴────┴────┴────┴────┴────┘
let arr = vec![
vec![1, 2, 3, 4, 5, 6],
vec![6, 5, 4, 3, 2, 1]
];
- | :- |
---|---|
len() | 返回 vec 的长度 |
is_empty() | vec 是否为空 |
push(value) | 在 vec 尾部插入元素 |
pop() | 删除并返回 vec 尾部的元素或者返回 None |
insert(index,element) | 在指定索引处插入元素 |
remove(index) | 删除指定索引处的元素并返回被删除的元素,索引越界将 panic 报错退出 |
clear() | 清空 vec |
append(vec) | 将另一个 vec 中的所有元素追加移入 vec 中,移动的 vec 变为空 |
truncate(len) | 将 vec 截断到指定长度,多余的元素被删除 |
retain(f) | 根据给定的函数,保留满足条件的元素 |
drain(range) | 删除 vec 中指定范围的元素,同时返回一个迭代该范围所有元素的迭代器 |
split_off(index) | 切分 vec ,索引左边的元素保留在原 vec 中(含索引),索引右边的元素(不含索引)在返回的 vec 中 |
use std::collections::Ha