Rust之函数、单元测试

1、函数

        类似于C++函数。

1.1、普通函数

        在Rust中，函数的定义使用fn关键字，后跟函数名、参数列表、返回类型和函数体。函数体由一系列语句组成，用于执行特定的操作和计算。

函数定义：

        使用fn关键字定义函数，函数由函数签名和函数体组成。

        函数签名由函数名、参数、返回值类型组成。函数体包含于{}内，是函数要执行的具体代码。

函数体：

        函数体由一系列语句和一个可选的结尾表达式构成。

        结尾表达式没有分号，代表这是一个表达式而非语句，将会自动返回表达式的值；

        结尾表示式的结尾如果加上分号，就变成了语句，语句没有返回值。

函数参数：

        是函数签名的一部分。

        函数参数必须明确指定数据类型，但不能指定默认值。

        函数参数可以分为可变和不可变参数，默认不可变参数，需要可变操作时，需要加上mut关键字。

返回值：

        如果函数需要返回值给调用者，在函数定义时需要明确返回值类型。使用 -> 数据类型来定义。

        函数只能有一个返回值，需要返回多个值时，可以使用元组类型。

        Rust中每个函数都有返回值，即使没有显示返回值的函数，也会隐式地返回一个单元值()。

        一般，函数隐式地返回函数体最后一个表达式的值，可以使用return 语句来显示返回。

代码：

// 文件名: a-1/src/main.rs

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

fn main() {
    let result = add(3, 5);
    println!("Result: {}", result);
}

结果：

[root@local_tmp]# 
[root@local_tmp]# cargo run
   Compiling a-1 v0.1.0 (/home/test/rust/a-1)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/a-1`
Result: 8
[root@local_tmp]# 
[root@local_tmp]# 

1.2、函数作为参数和返回值

        在Rust中，函数可以作为参数传递给其他函数，也可以作为函数的返回值。

// 文件名：a-1/src/main.rs

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

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

fn calculate(op: fn(i32, i32) -> i32, a: i32, b: i32) -> i32 {
    op(a, b)
}

fn main() {
    let result1 = calculate(add, 3, 5);
    let result2 = calculate(subtract, 8, 4);

    println!("Result 1: {}", result1);
    println!("Result 2: {}", result2);
}

结果：

[root@local_tmp]# 
[root@local_tmp]# Cargo run
   Compiling a-1 v0.1.0 (/home/work/test/rust/a-1)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/a-1`
Result 1: 8
Result 2: 4
[root@local_tmp]# 
[root@local_tmp]# 

        在上述示例中，定义了两个简单的函数add和subtract，分别用于相加和相减操作。然后，定义了一个名为calculate的函数，它接收一个函数参数op，类型为fn(i32, i32) -> i32，表示接收两个i32类型参数并返回i32类型结果的函数。在函数体中，我们调用了op函数，并传递了a和b作为参数。

        在main函数中，我们分别使用add和subtract作为calculate函数的参数，并打印出计算结果。

1.3、函数重载

        在 Rust 中，严格来说，并没有传统意义上的函数重载。传统的函数重载通常指的是在同一作用域内定义多个同名函数，但参数个数或类型不同。然而，在 Rust 中，函数名字是唯一的，无法直接定义同名函数。不过，Rust提供了更为灵活的方式来处理类似的情况。

// 文件名：a-1/src/main.rs

trait Add {
    type Output;
    fn add(self, other: Self) -> Self::Output;
}

impl Add for i32 {
    type Output = i32;
    fn add(self, other: Self) -> Self::Output {
        self + other
    }
}

impl Add for f64 {
    type Output = f64;
    fn add(self, other: Self) -> Self::Output {
        self + other
    }
}

fn main() {
    let a = 3;
    let b = 5;
    let c = 2.5;
    let d = 4.8;

    let result1 = a.add(b);
    let result2 = c.add(d);

    println!("Result 1: {}", result1);
    println!("Result 2: {}", result2);
}

结果：

[root@local_tmp]# 
[root@local_tmp]# Cargo run
   Compiling a-1 v0.1.0 (/home/work/test/rust/a-1)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/a-1`
Result 1: 8
Result 2: 7.3
[root@local_tmp]# 
[root@local_tmp]# 

1.3、参数个数不确定函数

1.4、泛型函数

        在 Rust 中，函数模板通常被称为【泛型函数】。是同时可以处理多种类型的函数，而不需要为每种类型编写一个单独的函数。这样可以减少代码重复，并提高代码的可读性和可维护性。

        在Rust中，泛型通常使用<T>表示，当然，不一定要是T，它也可以是A、B、C、D、E、F、G等。

2、单元测试

        在Rust中，可以使用cargo test完成对单元测试代码的测试。

// 文件名：a-1/src/main.rs

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

#[cfg(test)]
mod tests_1 {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
        assert_eq!(add(-2, 3), 1);
        assert_eq!(add(0, 0), 0);
    }
}

fn main() {
    println!(" 10 + 3 = {}", add(10, 3));
}


// 测试struct
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

#[cfg(test)]
mod tests_2 {
    use super::*;

    #[test]
    fn test_rectangle_area() {
        let rect = Rectangle { width: 10, height: 20 };
        assert_eq!(rect.area(), 200);
    }
}


/*
说明:
(1) 在源代码文件的顶部使用 #[test] 属性来标记一个函数作为测试函数;
    上文中 test_add() 是测试函数;
(2) #[cfg(test)] 是一个条件编译属性，它允许编写只在测试构建中编译的代码。
    这对于定义只在测试时需要的辅助函数、类型或模块特别有用，从而避免在生产代码中引入不必要的开销或依赖。
    即只在执行 cargo test 的时候才编译、运行。
*/

/*
(1) use super::* 是一种模块系统的特性，它允许你在当前模块中引入父模块中定义的所有公共项。
    这在编写单元测试时非常有用，可以在测试模块中引入要测试的模块（也就是正在编写的那个模块）中的所有公共函数。
*/

结果：

[root@local_tmp]# 
[root@local_tmp]# cargo run
   Compiling a-1 v0.1.0 (/home/test/rust/a-1)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.14s
     Running `target/debug/a-1`
 10 + 3 = 13
[root@local_tmp]# 
[root@local_tmp]# 
[root@local_tmp]# cargo test
   Compiling a-1 v0.1.0 (/home/test/rust/a-1)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.21s
     Running unittests src/main.rs (target/debug/deps/a_1-17ff21ae49a735eb)

running 2 tests
test tests_1::test_add ... ok
test tests_2::test_rectangle_area ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[root@local_tmp]# 
[root@local_tmp]# 

断言：

关键字	说明
assert!	检查给定的布尔表达式是否为真。如果为假，则测试失败。
assert_eq!	检查两个表达式是否相等。如果不等，则测试失败。
assert_ne!	检查两个表达式是否不相等。如果相等，则测试失败。
Assert_debug_snapshot!	用于比较当前代码的调试输出是否与先前存储的快照匹配，这有助于在重构代码时确保其行为未改变 (依赖 insta ）。