语法

注释

// 这是第一种注释方式
/* 这是第二种注释方式 */
/*
 * 多行注释
 * 多行注释
 * 多行注释
 */
/// 文档注释
/// ```
/// let x = add(1, 2);
///
/// ```

变量

// 变量
let a = 123;
let mut a = 123;
const a: i32 = 123;
//重影 shadowing 指变量的名称可以被重新使用的机制
let x = 5;
let x = x + 1;
let x = x * 2; // x == 12

let mut s = "123";
s = s.len(); // 错误！不能给字符串变量赋整型值

数据类型

//数据类型
//整数 有符号 i8, i16, i32 等，无符号 u8, u16, u32等
//进制 十六进制 0x, 八进制 0o, 二进制 0b, 字节（u8）b'A'
//浮点数 f32, f64
//数学运算+-*/%
//布尔型 bool, true false
//字符型 char 'A'
//复合类型 元组 ()
let tup: (i32, f64, u8) = (500, 6.4, 1); // tup.0 等于 500, tup.1 等于 6.4, tup.2 等于 1
let (x, y, z) = tup; // y 等于 6.4
//复合类型 数组 []
let c: [i32; 5] = [1, 2, 3, 4, 5]; // c 是一个长度为 5 的 i32 数组
let d = [3; 5]; // 等同于 let d = [3, 3, 3, 3, 3];
let first = a[0]; // 数组访问
a[0] = 123; // 错误：数组 a 不可变
let mut a = [1, 2, 3];
a[0] = 4; // 正确

函数、表达式、条件、循环

//函数
fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

//表达式块
let x = 5;
let y = {
    let x = 3;
    x + 1  //<-注意这里没有分号，意味着是表达式而不是语句
};

//条件语句
let number = if a > 0 { 1 } else { -1 };
if a > 0 {
    b = 1;
}
else if a < 0 {
    b = -1;
}
else {
    b = 0;
}

//循环语句
let mut i = 0;
while i < 10 {
    // 循环体
    i += 1;
}
let a = [10, 20, 30, 40, 50];
for i in a.iter() {}
for i in 0..5 {}
loop {
    let ch = s[i];
    if ch == 'O' {
        break;
    }
    println!("\\'{}\\'", ch);
    i += 1;
}

所有权机制

变量与值的所有权

//变量与值的所有权
//1. 移动（移动的是对于值的所有权）
let s1 = String::from("hello");
let s2 = s1; 
println!("{}, world!", s1); // 错误！s1 已经失效
//2. 克隆
let s2 = s1.clone();

函数相关的所有权机制

//函数相关的所有权机制
//1. 函数参数的所有权
fn main() {
    let s = String::from("hello"); // s 被声明有效
    takes_ownership(s);
    // s 的值被当作参数传入函数，移动给some_string
    // 所以可以当作 s 已经被移动，从这里开始已经无效

    let x = 5; // x 被声明有效
    makes_copy(x);
    // x 的值被当作参数传入函数，但 x 是基本类型，依然有效
    // 在这里依然可以使用 x 却不能使用 s

} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放
fn takes_ownership(some_string: String) { // 一个 String 参数 some_string 传入，有效
    println!("{}", some_string);
} // 函数结束, 参数 some_string 在这里释放
fn makes_copy(some_integer: i32) { // 一个 i32 参数 some_integer 传入，有效
    println!("{}", some_integer);
} // 函数结束, 参数 some_integer 是基本类型, 无需释放
//2. 函数返回值的所有权
fn main() {
    let s1 = gives_ownership(); // gives_ownership 移动它的返回值到 s1
    let s2 = String::from("hello"); // s2 被声明有效
    let s3 = takes_and_gives_back(s2);
    // s2 被当作参数移动, s3 获得返回值所有权
} // s3 无效被释放, s2 被移动, s1 无效被释放.
fn gives_ownership() -> String {
    let some_string = String::from("hello"); // some_string 被声明有效
    return some_string; // some_string 被当作返回值移动出函数
}
fn takes_and_gives_back(a_string: String) -> String { 
    // a_string 被声明有效
    a_string  // a_string 被当作返回值移出函数
}