Rust Cheatsheet

变量常量

let x = "你好世界"; // 申明不可变量
let mut x; // Shadow x 可声明为不同的类型
x = 1; // 赋值 并推断类型为 i64
const Y: bool = true & false; // 常量 Y 在整个作用域可见
{
  let x = x; 
  // x = 2; // 错误, frozen x 为不可变量
}
x = 3; // 正确, x 解封了

数据类型

标量

// 1. 自然数
let x: i128 = 98_222;
let x: u128 = 0xff;
let x: isize = 0o77;
let x: usize = 0b1111_0000;
let x: u8 = b'A';
// 2. 有理数
let x: f64 = 2.0; 
let y: f32 = 3.0;
// 3. 布尔
let t = true;
let f: bool = false;
// 4. 字符
let c = 'z';
let z = 'ℤ';
let heart_eyed_cat: char = '😻';

矢量

// Tuple
let tup: (i32, f64, u8) = (500, 6.4, 1);
let tup = (500, 6.4, 1);
let (x, y, z) = tup;
let five_hundred = x.0;
// 数组
let a: [i32; 5] = [1, 2, 3, 4, 5];
let a = [3; 5];
let first = a[0];

函数

fn main() {
  let x = plus_one(5);
  println!("The value of x is: {}", x);
} 
fn plus_one(x: i32) -> i32 {
  x + 1 // 没有分号，为非语句表达式，意即返回值
}

控制结构

// if 表达式
let number = 3;
if number < 5 {
  println!("condition was true");
} else if number < 8 {
  println!("condition was false");
} else {
  //
}
let condition = true;
 // if 表达式，每个分支返回的类型必须相容
let number = if condition { 5 } else { 6 };
// loop 表达式
let mut counter = 0;
let result = loop {
  counter += 1;
  if counter == 10 {
    break counter * 2; // 返回值
  }
};
// while
let mut number = 3;
while number != 0 {
  println!("{}!", number); 
  number -= 1;
}
// for 
let a = [10, 20, 30, 40, 50];
for element in a.iter() {
  println!("the value is: {}", element);
}
// range
for number in (1..4).rev() {
  println!("{}!", number);
}

所有权

String

let s = String::from("hello");
let mut s = String::from("hello");
s.push_str(", world!");

所有权

let x = 5;
let y = x;
// x, y 同时存在并有相同的值
let s1 = String::from("hello");
let s2 = s1; // Heap数据 所有权转移，s1不再存在
let s3 = s2.clone(); // 克隆 Heap 数据

引用与借用

fn main() {
  let s1 = String::from("hello");
  let len = calculate_length(&s1);
  println!("The length of '{}' is {}.", s1, len);

  let mut s1 = String::from("hello");
  change(&mut s1);
  let len = calculate_length(&s1);
  println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
  s.len()
}
fn change(some_string: &mut String) {
  some_string.push_str(", world");
}

1. 常引用可以有多个 但可变引用只能有1个
2. 常引用与可变引用不能同时存在

// Hack 多个可变引用
let mut s = String::from("hello"); 
{ 
  let r1 = &mut s;
} // r1 已不再在作用域
let r2 = &mut s;

// 引用的作用域为 introduced -> lastused
let mut s = String::from("hello"); 
let r1 = &s; // no problem let r2 = &s; // no problem 
println!("{} and {}", r1, r2); // r1 和 r2 被消费掉 
let r3 = &mut s; // no problem println!("{}", r3);

悬垂指针

fn main() {
  let reference_to_nothing = dangle();
} 
fn dangle() -> &String {
  let s = String::from("hello"); 
  &s
  // 函数结束时 s 被释放 返回的引用不在合法
}