Rust 速查表

查看: Rust 类型

// 打印输出
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);

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} 个成员");

查看: 字符串

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

1. 只读取数组中的元素

   let v = vec![1, 2, 3];
   for i in &v {
       println!("{}", i);
   }
   

2. 遍历的同时修改数组中的元素

   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]
];

use std::collections::HashMap;

fn main() {
  let mut map: HashMap<String, i32> = HashMap::new();
  map.insert(String::from("blue"), 100);
  // 查询Yellow对应的值，若不存在则插入默认值
  let v: &mut i32 =
    map.entry("Yellow".to_string()).or_insert(5);
  let v: &mut i32 =
    map.entry("Yellow".to_string()).or_insert(50); // 不会修改值
}

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score: Option<&i32> = scores.get(&team_name);

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

for (key, value) in &scores {
    println!("{}: {}", key, value);
}

let teams_list = vec![
    ("中国队".to_string(), 100),
    ("美国队".to_string(), 10),
    ("日本队".to_string(), 50),
];
let teams_map: HashMap<_,_> =
  teams_list.into_iter().collect();

let teams = vec![String::from("blue"),String::from("red")];
let intial_scores = vec![10,50];
let scores:HashMap<_,_> =
  teams.iter().zip(intial_scores.iter()).collect();

? 只能用于返回结果是 Result 或者 Option 的函数,或者实现了 Try 类型

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("hello.txt")?.read_to_string(&mut s)?;
    Ok(s)
}

fn first(arr: &[i32]) -> Option<&i32> {
   let v = arr.get(0)?;
   Some(v)
}

enum IpAddrKind {
  V4,
  V6,
}
struct IpAddr {
  kind: IpAddrKind,
  address: String,
}

fn main(){
    let ip = IpAddr{
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1")
    };
}

enum IpAddrKind {
  V4(u8, u8, u8, u8),
  V6(String),
}

fn main() {
  let home = IpAddrKind::V4(127, 0, 0, 1);
  let loopback = IpAddrKind::V6(String::from("::1"));
}

enum Message{
  Quit,
  Move {x:i32, y:i32},
  Write(String),
  ChangeColor(i32, i32, i32),
}
fn main(){
  let q = Message::Quit;
  let m = Message::Move {x:10, y:20};
  let w = Message:: Write(String::from("hello"));
  let c = Message::ChangeColor(10, 20, 30);
}

#[derive(Debug)]
enum Grade {
    A,
    B,
    C,
}
enum Subject {
    Math(Grade),
    English(Grade),
}

fn subject_grade(sub: Subject) {
  match sub {
    Subject::Math(grade) => println!("The Math is {:?}", grade),
    Subject::English(grade) => println!("The Math is {:?}", grade),
  }
}

fn main() {
    subject_grade(Subject::Math(Grade::A));
}

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

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

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 

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;

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

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

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

无限循环表示

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

break 可以单独使用，也可以带一个返回值

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

println!("{res}"); // 28

match 表达式需要匹配所有的枚举才能结束，但通常我们只需要匹配我们需要的值

let x = 3;
match Some(x) {
  Some(3) => println!("I guess that x is 3"),
  _ => ()
}

使用 if let

let x = 3;
if let Some(3) = Some(x) {
    println!("I guess that x is 3");
}

let mut stack = vec![];

stack.push(1);
stack.push(2);
stack.push(3);

while let Some(top) = stack.pop() {
    println!("{}", top);
}

fn add((x, y): (i32, i32)) -> i32 {
    x + y
}

fn main(){
  let sum = add(1, 2);
  println!("{sum}");
}

以下代码，只要给定的 x 是 Some 类型，但 Some 中的值不是 1，都会匹配到 y

let x = Some(10);
match x {
    Some(1) => println!("x = 1"),
    Some(y) => println!("y = {:?}", y),
    _ => println!("None"),
}// y = 10

let x = Some(2);
match x {
    Some(1) => println!("x = 1"),
    Some(y) if y == 2 => println!("y = {:?}", y),
    _ => println!("No match"),
}// y = 2

rust 的函数使用蛇形命名法（snake case）

fn print_message(){
  println!("Hello, Quick Reference!");
}

rust 需要为函数的参数标明确定的类型

fn another_fn(a:u8, b: &str){
    println!("我是 u8:{}", a);
    println!("我是 &str:{}", b);
}

fn main(){
    another_fn(10, "hello")
}

如果不指定返回值，rust 默认返回 () 类型

// 在 bin 中的入口函数默认返回 ()
fn main(){}

使用 -> 指定返回值，如果表达式在最后一行，无需使用 return

fn add(a:i32, b:i32) -> i32 {
    if a + b < 100 {
        return a - b;
    }
    a + b
}

fn dead_end() -> ! {
    panic!("panic!!!!!");
}

String::from("str");
"str".to_string();
"str".to_owned();

"str".as_bytes();

或者你也可以使用 b""

println!("{:?}", b"str");

"str".as_bytes().to_vec();
"str".as_bytes().to_owned();

let s = String::from("str");
let r = s.as_str();

let s = String::from("str");
let v = s.as_bytes();

let s = String::from("str");
let v = s.into_bytes();

let b = "str".as_bytes();
let str = std::str::from_utf8(b).unwrap();

let b = "str".as_bytes();
let str = String::from_utf8(b.to_vec()).unwrap();

let b = "str".as_bytes();
let str = b.to_vec();

let b = "str".as_bytes();
let str = b.to_owned();

let b = "str".as_bytes().to_vec();
let s = std::str::from_utf8(&b).unwrap();

let b = "str".as_bytes().to_vec();
let s = b.as_slice();

let b = "str".as_bytes().to_vec();
let s = String::from_utf8(b).unwrap();

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);

* 操作符用于解引用

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

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