基本语法

入口函数

fn main(){
    // 代码
}

声明变量

n main() {
    // 编译器会默认根据a的值为a推断类型：i32，有符号32位整数
    let a = 10;

    // 手动指定类型
    let b: i32 = 20;

    // 可在数值后带上类型
    let b1 = 30i32;

    // mut 表示可变的，缩写自 mutable
    let mut c = 30i32;

    // 数值与类型可添加下划线，增加可读性
    let d = 30_i32;

    // 以返回值作为变量的值，（返回值也可做为参数）
    let e = add(add(a, b), add(c, d));
}

fn add(i: i32, j: i32) -> i32 {
    i + j
}

变量可变性

变量默认不可变

可变变量：

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

print 宏 println!()

Rust 中 print 用宏实现

// !代表宏调用，区别于函数它返回的是宏定义的代码块
// {} 是占位符，相当于python中的 %s %d ，自动推导类型
println!("result is {}", a);

未使用的变量 警告

变量未使用会有警告，如果要忽略警告，加上 _ 在开头

let _x = 5;

变量解构

从一个相对复杂的变量中，匹配出该变量的一部分内容：

let (a, mut b): (bool,bool) = (true, false); // 定义
println!("a = {:?}, b = {:?}", a, b); // 解构使用
b = true; // 更改值
assert_eq!(a, b); // 更改后变为相等

解构式赋值（Rust 1.59 版本后），可以在赋值语句的左式中使用元组、切片和结构体模式：

struct Struct {
    e: i32
}

fn main() {
    let (a, b, c, d, e);

    (a, b) = (1, 2);
    // _ 代表匹配一个值，但是我们不关心具体的值是什么，因此没有使用一个变量名而是使用了 _
    [c, .., d, _] = [1, 2, 3, 4, 5];
    Struct { e, .. } = Struct { e: 5 };

    assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
}

常量

const 定义

// 数值使用 下划线 提高可读性
const MAX_POINTS: u32 = 100_000;

常量可以在任意作用域内声明，包括全局作用域

变量遮蔽(shadowing)

后面声明的变量会遮蔽掉前面声明

// 字符串类型
let spaces = "   ";
// usize数值类型
let spaces = spaces.len();

语句和表达式

语句（statement）和表达式（expression）

表达式没有分号结尾，表达式总要返回值

表达式如果不返回任何值，会隐式地返回一个 ()

let 是语句，所以 let b = (let a = 8); 是错的，但是 let 作为表达式已经是试验功能了，在将来或许能够这样使用

序列Range

1..5
1..=5

切片

引用集合中部分连续的元素序列

let s = String::from("hello world");

let hello = &s[0..5];
let world = &s[6..11];

[开始索引..终止索引] 左闭右开区间

字符串切片：

let s = String::from("hello");

// 从零开始
let slice = &s[0..2];
let slice = &s[..2];

// 截取至末尾
let len = s.len();
let slice = &s[4..len];
let slice = &s[4..];

// 截取全段
let slice = &s[0..len];
let slice = &s[..];

数组切片：

let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);