From 5573459051b8dfbad6a67fa97fa17deceb58210a Mon Sep 17 00:00:00 2001 From: jaywcjlove Date: Thu, 3 Nov 2022 07:33:59 +0000 Subject: [PATCH] feat: add `rust.md` cheatsheet (#20). e66c1c57fd933156c85c8502e30789acf92acc6f --- docs/rust.html | 758 +++++++++++++++++++++++++++++++++++++++++++++++++ index.html | 4 + 2 files changed, 762 insertions(+) create mode 100644 docs/rust.html diff --git a/docs/rust.html b/docs/rust.html new file mode 100644 index 00000000..4e6d9abb --- /dev/null +++ b/docs/rust.html @@ -0,0 +1,758 @@ + + + + +Rust 备忘清单 + & rust cheatsheet & Quick Reference + + + + + + +

+ + +Rust 备忘清单

+

Rust 快速参考备忘单，旨在为编写基本语法和方法提供帮助。

+

入门

+

Hello_World.rs

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

编译运行

+
$ rustc Hello_World.rs
+$ ./Hello_World
+Hello, World!
+
+

原始类型

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
:-:-
bool布尔值 (true / false)
char字符
f32, f6432 位、64 位浮点数
i64, i32, i16, i8有符号 16- ... 整数
u64, u32, u16, u8无符号 16 位，... 整数
isize指针大小的有符号整数
usize指针大小的无符号整数
+

查看: Rust 类型

+

Formatting

+ +
// 单个占位符
+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

+

Rust 类型

+

整数

+
let mut a: u32 = 8;
+let b: u64 = 877;
+let c: i64 = 8999;
+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} 个成员");
+
+ +

查看: 字符串

+

数组

+
┌─────┬─────┬─────┬─────┬─────┬─────┐
+| 92  | 97  | 98  | 99  | 98  | 94  |
+└─────┴─────┴─────┴─────┴─────┴─────┘
+   0     1     2     3     4     5
+
+
+
let array: [i64; 6] = [92,97,98,99,98,94];
+
+

多维数组

+ +
     j0   j1   j2   j3   j4   j5
+   ┌────┬────┬────┬────┬────┬────┐
+i0 | 1  | 2  | 3  | 4  | 5  | 6  |
+   ├────┼────┼────┼────┼────┼────┤
+i1 | 6  | 5  | 4  | 3  | 2  | 1  |
+   └────┴────┴────┴────┴────┴────┘
+
+
+
let array: [[i64; 6] ;2] = [
+            [1,2,3,4,5,6],
+            [6,5,4,3,2,1]];
+
+

可变数组

+
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 some_vector = vec![1,2,3,4,5]; 
+
+

使用 vec! 宏声明向量

+

元组

+
let tuple = (1, 'A' , "Cool", 78, true);
+
+

Rust 字符串

+

字符串字面量

+
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}");
+
+

.capacity()

+
let rand = String::from("Random String");
+rand.capacity()  // => 13
+
+

以字节为单位计算字符串的容量

+

.contains()

+
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}");
+
+

Rust 运算符

+

比较运算符

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
:-:-
e == fe 等于 f
e != fe 不等于 f
e < fe 小于 f
e > fe 大于 f
e <= fe 小于或等于 f
e >= fe 大于或等于 f
+
+
let (e, f) = (1, 100);
+let greater = f > e;        // => true
+let less = f < e;           // => false
+let greater_equal = f >= e; // => true
+let less_equal = e <= f;    // => true
+let equal_to = e == f;      // => false
+let not_equal_to = e != f;  // => true
+
+

算术运算符

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
:-:-
a + ba 被添加到 b
a - b从 a 中减去b
a / ba 除以 b
a % b通过与 b 相除得到 a 的余数
a * ba 与 b 相乘
+
+
let (a, b) = (4, 5);
+let sum: i32 = a + b;            // => 9
+let subtractions: i32 = a - b;   // => -1
+let multiplication: i32 = a * b; // => 20
+let division: i32 = a / b;       // => 0
+let modulus: i32 = a % b;        // => 4
+
+

位运算符

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
运算符描述
g & h二进制与
`gh`
g ^ h二进制异或
g ~ h二进制补码
g << h二进制左移
g >> h二进制右移
+
+
let (g, h) = (0x1, 0x2);
+let bitwise_and = g & h;  // => 0
+let bitwise_or = g | h;   // => 3
+let bitwise_xor = g ^ h;  // => 3
+let right_shift = g >> 2; // => 0
+let left_shift = h << 4;  // => 32 
+
+

逻辑运算符

+ + + + + + + + + + + + + + + + + + + + + +
示例意义
c && d两者都是真的_(AND)_
`c
!cc 为假 (NOT)
+
+
let (c, d) = (true, false);
+let and = c && d;  // => false
+let or  = c || d;  // => true
+let not = !c;      // => false
+
+

复合赋值运算符

+
let mut k = 9;
+let mut l = k;
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
运算符描述
k += l添加一个值并赋值，然后 k=9
k -= lSubstrate 一个值并赋值，然后 k=18
k /= l除以一个值并赋值，然后 k=9
k *= l乘一个值并赋值，然后 k=81
k |= l按位或并赋值，则 k=89
+

Rust 流程控制

+

If表达式

+
let case1: i32 = 81;
+let case2: i32 = 82;
+if case1 < case2 {
+  println!("case1 大于 case2");
+}
+
+

If...Else 表达式

+
let case3 = 8;
+let case4 = 9;
+if case3 >= case4 {
+  println!("case3 优于 case4");
+} else {
+  println!("case4 大于 case3");
+}
+
+

If...Else...if...Else 表达式

+
let foo = 12;
+let bar = 13;
+if foo == bar {
+  println!("foo 等于 bar");
+} else if foo < bar {
+  println!("foo 小于 bar");
+} else if foo != bar {
+  println!("foo 不等于 bar");
+} else {
+  println!("Nothing");
+}
+
+

If...let 表达式

+ +
let mut arr1:[i64 ; 3] = [1,2,3];
+if let[1,2,_] = arr1{
+    println!("与数组一起使用");
+}
+let mut arr2:[&str; 2] = ["one", "two"];
+if let["Apple", _] = arr2{
+    println!("也适用于 str 数组");
+}
+
+
+
let tuple_1 = ("India", 7, 90, 90.432);
+if let(_, 7, 9, 78.99) = tuple_1{
+    println!("也适用于元组");
+}
+let tuple_2 = ( 9, 7, 89, 12, "Okay");
+if let(9, 7,89, 12, blank) = tuple_2 {
+    println!("一切{blank}伴侣？");
+}
+let tuple_3 = (89, 90, "Yes");
+if let(9, 89, "Yes") = tuple_3{
+    println!("模式确实匹配");
+}
+else {
+    println!("模式不匹配");
+}
+
+

匹配表达式

+ +
let day_of_week = 2;
+  match day_of_week {
+    1 => {
+      println!("兄弟们今天是星期一");
+    },
+    2 => {
+      println!("兄弟们今天是星期二");
+    },
+    3 => {
+      println!("兄弟们今天是星期三");
+    },
+    4 => {
+      println!("兄弟们今天是星期四");
+    },
+    5 => {
+      println!("兄弟们今天是星期五");
+    },
+    6 => {
+      println!("兄弟们今天是星期六");
+    },
+    7 => {
+      println!("兄弟们今天是星期天");
+    },
+    _ => {
+      println!("默认!")
+    }
+  };
+}
+
+

嵌套...If 表达式

+
let nested_conditions = 89;
+if nested_conditions == 89 {
+    let just_a_value = 98;
+    if just_a_value >= 97 {
+        println!("大于 97");
+    }
+}
+
+

For 循环

+
for mut i in 0..15 {
+  i-=1;
+  println!("i 的值为：{i}");
+}
+
+

While 循环

+
let mut check =  0;
+while check < 11{
+  println!("check 是：{check}");
+  check+=1;
+  println!("递增后：{check}");
+  if check == 10{
+    break; // 停止 while
+  }
+}
+
+

Loop 关键字

+
loop {
+  println!("你好，世界永远！");
+}
+
+

无限循环表示

+

Break 中断语句

+
let mut i = 1;
+loop {
+  println!("i 是 {i}");
+  if i > 100 {
+    break;
+  }
+  i *= 2;
+}
+
+

Continue 继续声明

+
for (v, c) in (0..10+1).enumerate(){
+  println!("{c} 数字循环");
+  if v == 9{
+    println!("我们继续？");
+    continue;
+  }
+  println!{"v 的值为：{v}"};
+}
+
+

Rust 函数

+

基本函数

+
fn print_message(){
+  println!("Hello, Quick Reference!");
+}
+fn main(){
+  // 在 Rust 中调用函数
+  print_message();
+}
+
+

按值传递

+
fn main()
+{
+  let x:u32 = 10;
+  let y:u32 = 20;
+  
+  // => 200
+  println!("计算: {}", cal_rect(x, y));
+}
+fn cal_rect(x:u32, y:u32) -> u32
+{
+  x * y
+}
+
+

通过引用传递

+
fn main(){
+  let mut by_ref = 3;      // => 3
+  power_of_three(&mut by_ref);
+  println!("{by_ref}");  // => 9
+}
+fn power_of_three(by_ref: &mut i32){
+  // 取消引用很重要
+  *by_ref = *by_ref * *by_ref;
+  println!("{by_ref}");  // => 9
+}
+
+

返回

+
fn main(){
+  let (mut radius, mut pi) = (3.0, 3.14);
+  let(area, _perimeter) = calculate (
+      &mut radius,
+      &mut pi
+  );
+  println!("圆的面积和周长为：{area} & {_perimeter}");
+}
+fn calculate(radius : &mut f64, pi: &mut f64) -> (f64, f64){
+  let perimeter = 2.0 * *pi * *radius;
+  let area = *pi * *radius * *radius;
+  return (area, perimeter);
+}
+
+ +

数组作为参数

+
fn main(){
+  let mut array: [i32 ; 5] = [1,2,3,4,6];
+  print_arrays(array);
+  println!("元素：{array:?}");
+}
+fn print_arrays(mut array:[i32; 5]) {
+  array[0] = 89;
+  array[1] = 90;
+  array[2] = 91;
+  array[3] = 92;
+  array[4] = 93;
+  println!("元素：{array:?}");
+}
+
+

返回数组

+
fn main(){
+  let mut arr:[i32; 5] = [2,4,6,8,10];
+  multiply(arr);
+  println!("数组是：{:?}", multiply(arr));
+}
+fn multiply (mut arr: [i32 ; 5]) -> [i32 ; 5]{
+  arr[2] = 90;
+  for mut i in 0..5 {
+      arr[i] = arr[i] * arr[2];
+  }
+  return arr;
+}
+
+ +

杂项

+

类型断言 type-casting

+
let a_int = 90; // int
+// int 到 float
+let mut type_cast = (a_int as f64);
+
+
+
let orginal: char = 'I';
+// char 到 int => 73
+let type_casted: i64 = orginal as i64;
+
+

要在 Rust 中执行类型转换，必须使用 as 关键字

+

借用

+
let mut foo = 4;
+let mut borrowed_foo = &foo;
+println!("{borrowed_foo}");
+
+
+
let mut bar = 3;
+let mut mutable_borrowed_bar = &mut bar;
+println!("{mutable_borrowed_bar}");
+
+

这里借用的值使用 & 运算符从值一中借用值

+

取消引用

+
let mut borrow = 10;
+let deref = &mut borrow;
+println!("{}", *deref);
+
+

可以使用 * 操作符在 rust 中取消引用

+

变量范围

+
{
+  // 范围仅限于此大括号
+  let a_number = 1;
+}
+println!("{a_number}");
+
+

这将产生错误，因为变量 a_number 的范围在大括号处结束

+

另见

+ +
+ diff --git a/index.html b/index.html index d44211fc..2ed72a95 100644 --- a/index.html +++ b/index.html @@ -95,6 +95,10 @@ Python + + + +Rust Swift