Rust学习笔记003：语句和表达式+函数+控制语句：IF,MATCH,LOOP

语句（Statements）和表达式（Expressions）

1. 语句（Statements）：

语句是执行一些操作但不返回值的代码单元。例如，声明变量、赋值、函数调用、宏调用等都是语句。

// 声明变量的语句
let x = 5;

// 表达式语句（函数调用）
println!("Hello, World!");

// if 语句
if x > 0 {
    println!("x is positive");
} else {
    println!("x is non-positive");
}

// 函数定义语句
fn my_function() {
    // 函数体
}

在 Rust 中，语句末尾不需要分号，但如果在语句之间有多个表达式，需要用分号分隔。

2. 表达式（Expressions）：

表达式是计算并产生一个值的代码单元。表达式可以是一个常量、变量、运算、函数调用等。每个表达式都有一个类型，并产生一个值。

let y = {
    let x = 5;
    x + 1 // 这是一个表达式
};

println!("The value of y is: {}", y);

在上述例子中，y 的值是一个块（Block）的最后一个表达式的值，即 x + 1。

Rust 中的函数调用、宏调用、赋值等通常是表达式。例如，let x = 5; 本身就是一个表达式，它产生 ()（unit 类型的值）。

let x = {
    let y = 5;
    y * 2 // 这是一个表达式
};

在这个例子中，块 { ... } 作为一个表达式被赋值给变量 x。

• 下面的例子输出5
  

函数

函数与命名 fn name() {}

• 一些编程语言和框架强烈推荐或者约定使用 snake case 风格。例如，Rust、Python、Ruby 等都鼓励使用 snake case。Snake case 是一种命名规范风格，通常用于变量名、函数名和文件名等标识符。Snake case 的特点是将单词用下划线连接，并全部小写。这种风格使得标识符更易读，也更符合一些编程语言和工具的命名约定。

Snake case 示例：

• 变量名： my_variable
• 函数名： calculate_sum
• 文件名： main_module.rs

在Rust中，snake case 是一种常见的命名风格，符合 Rust 的命名规范。以下是一些 Rust 中使用 snake case 的示例：

fn calculate_sum(a: i32, b: i32) -> i32 {
    // 函数体
    a + b
}

const MAX_NUM: usize = 100;

struct MyStruct {
    field_one: i32,
    field_two: f64,
}

fn main() {
    let my_variable = 42;
    let another_variable = 3.14;
}

函数参数

• 基本类型约束： 需要在函数参数中使用特定的类型来约束参数的类型。例如：

  fn print_number(num: i32) {
      println!("Number: {}", num);
  }
  

  在上述例子中，num 参数的类型被限定为 i32。

• 使用泛型时： 使用泛型可以更灵活地约束参数的类型。例如：

  fn print_generic<T>(value: T) {
      println!("Value: {:?}", value);
  }
  

  在这里，T 是一个泛型参数，可以用于表示不同类型的参数。

函数返回值

• 在 Rust 中，函数的返回值可以通过 -> 符号指定。Rust 的函数可以返回各种类型，包括基本类型、复合类型、引用和自定义类型等。

返回基本类型：

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add(2, 3);
    println!("Result: {}", result); // 输出：Result: 5
}

在上述例子中，add 函数返回一个 i32 类型的整数。

返回复合类型：

struct Point {
    x: f64,
    y: f64,
}

fn create_point(x: f64, y: f64) -> Point {
    Point { x, y }
}

fn main() {
    let point = create_point(1.0, 2.0);
    println!("Point: ({}, {})", point.x, point.y); // 输出：Point: (1, 2)
}

在这里，create_point 函数返回一个自定义的 Point 结构体。

返回引用：

fn get_first_char(s: &str) -> Option<char> {
    s.chars().next()
}

fn main() {
    let result = get_first_char("hello");
    match result {
        Some(c) => println!("First character: {}", c),
        None => println!("String is empty"),
    }
}

在这个例子中，get_first_char 函数返回一个 Option<char> 类型，表示可能返回一个字符或者 None。

返回多个值：

Rust 中没有直接支持返回多个值的语法，但可以使用元组、结构体或者 Result 类型来返回多个值的组合。

fn calculate_values(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}

fn main() {
    let (sum, product) = calculate_values(3, 4);
    println!("Sum: {}, Product: {}", sum, product);
}

在这里，calculate_values 函数返回一个包含两个值的元组。

if表达式：

• 需要注意的一点：if后必须是一个布尔类型，像c++就会类型转换
  

let number = 5;

if number > 0 {
    println!("Number is positive");
} else if number == 0 {
    println!("Number is zero");
} else {
    println!("Number is negative");
}

// if 表达式的值可以被赋给一个变量
let result = if number > 0 { "positive" } else { "negative" };
println!("Result: {}", result);

if let

if let 结构用于简化 match 表达式中的单一模式匹配。

let favorite_color: Option<&str> = Some("blue");

if let Some(color) = favorite_color {
    println!("Favorite color: {}", color);
} else {
    println!("No favorite color");
}

match 表达式

• match 表达式用于模式匹配，可以更灵活地处理多种情况。

let fruit = "apple";

match fruit {
    "apple" => println!("It's an apple"),
    "orange" => println!("It's an orange"),
    _ => println!("Unknown fruit"),
}

loop 循环

• loop 关键字用于创建一个无限循环，可通过 break 语句跳出。

let mut counter = 0;

loop {
    println!("Counter: {}", counter);
    counter += 1;

    if counter == 5 {
        break;
    }
}

while 循环

• while 循环根据条件重复执行代码块。

let mut i = 0;

while i < 5 {
    println!("i: {}", i);
    i += 1;
}

while let

• 类似于 while 循环，但是用于简化 match 表达式的单一模式匹配。

let mut stack = Vec::new();

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

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

for循环

• for 循环用于迭代集合或者范围。

for number in 1..=5 {
    println!("Number: {}", number);
}

let fruits = ["apple", "orange", "banana"];

for fruit in fruits.iter() {
    println!("Fruit: {}", fruit);
}