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

2023-12-31 22:32:42

语句（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