Rust 编程小技巧(6)

1. 打印字符串

fn main() {
    println!("Hello, world");
    let s = "Rust";
    print!("{}", s);
    println!();
}

Rust 打印主要用宏 print!()、println!()，打印宏的占位符使用 {}。

2. 重复打印字串

有多种方法，比如使用：循环、string.repeat()、vector.join()等等。

fn main() {
    for _ in 0..8 {
        print!("rust");
    }

    println!("\n{}", "rust".repeat(8));

    let s = vec!["rust"; 8];
    println!("{:?}", s);
    println!("{}", s.join(""));
    println!("{}", s.join("."));
}

输出：

rustrustrustrustrustrustrustrust
rustrustrustrustrustrustrustrust
["rust", "rust", "rust", "rust", "rust", "rust", "rust", "rust"]
rustrustrustrustrustrustrustrust
rust.rust.rust.rust.rust.rust.rust.rust

3. 自定义函数

比如，一个整数的平方、绝对值

fn square(x: i32) -> i32 {
    x * x
}

fn abs(x: i32) -> i32 {
    if x < 0 {
        return -x;
    }
    x
}

fn main() {
    let n = square(9);
    println!("{}", n);
    println!("{}", abs(-10));
}

rust 函数的返回关键字 return，在最后的出口可以省略，只需一个表达式（不用分号结尾）。

4. 遍历动态数组

.into_iter() 转迭代器

fn main() {
    let items = vec![11, 22, 33];

    for x in items.clone().into_iter() {
        do_something(x);
    }

    items.clone().into_iter().for_each(|x| do_something(x));

    println!("{:?}", items);
}

fn do_something(n: i64) {
    println!("Number {}", n)
}

输出：

Number 11
Number 22
Number 33
Number 11
Number 22
Number 33
[11, 22, 33]

5. 遍历二维数组

.iter() 创建迭代器

fn main() {
    let vec = vec![vec![1, 2], vec![3, 4], vec![5, 6]];  
    for outer_iter in vec.iter() {  
        for inner_iter in outer_iter.iter() {  
            print!("{} ", inner_iter);  
        }  
    }
    println!();

    vec.iter().for_each(|x| x.iter().for_each(|y| print!("{} ", y)));
    println!();
}

6. 同时遍历索引和值

.enumerate() 枚举

fn main() {
    test1();
    test2();
}

fn test1() {
    let items = ["a", "b", "c"];
    for (i, x) in items.iter().enumerate() {
        println!("Item {} = {}", i, x);
    }
}

fn test2() {
    let items = ["a", "b", "c"];
    items.iter().enumerate().for_each(|(i, x)| {
        println!("Item {} = {}", i, x);
    });
}

7. 迭代器方法的区别

.into_iter() 和 .iter() 两个方法都用于创建迭代器，它们的区别在于：

1.所有权转移：.into_iter() 方法会消耗当前的集合，并将所有权转移给迭代器。这意味着在迭代完成后，原集合将不再可用。而 .iter() 方法不会消耗集合，它只是创建一个新的迭代器，你可以在迭代完成后继续使用原集合。

2.消耗和产生元素：.into_iter() 会消耗集合中的元素，并将它们放入迭代器中。这意味着每次调用迭代器的 next() 方法都会消耗集合中的一个元素。而 .iter() 只是产生元素的引用，并不会消耗集合中的元素。

3.用途：当你需要遍历集合中的元素并获取它们的所有权时，应该使用 .into_iter()。当你只需要读取集合中的元素而不消耗它们时，应该使用 .iter()。

8. for_each() 用法

fn main() {
    // 迭代一个 vec 并打印每个元素  
    let vec = vec![1, 2, 3, 4, 5];  
    vec.iter().for_each(|x| print!("{} ", x));
    println!();

    // 迭代一个字符串并打印每个字符  
    let s = "hello";  
    s.chars().for_each(|c| print!("{} ", c));
    println!();

    // 迭代一个 vec 并将其元素加倍  
    let mut v1 = vec![1, 2, 3, 4, 5];
    let mut v2 = vec![];
    v1.iter().for_each(|x| v2.push(x * 2));  
    println!("{:?}", v2);

    v1.clone().iter().for_each(|x| v1.push(x * 2));  
    println!("{:?}", v1);
}

输出：

1 2 3 4 5
h e l l o
[2, 4, 6, 8, 10]
[1, 2, 3, 4, 5, 2, 4, 6, 8, 10]

9. 分离奇数和偶数

.filter() 方法是一个在标准库中的std::iter::Iterator trait的默认方法。这个方法会创建一个新的迭代器，包含所有满足给定条件的元素。

示例：分离一个数组中的奇数和偶数

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];  
    vec.clone().iter().for_each(|x| vec.push(x + 5));  
    println!("{:?}", vec);

    fn is_even(x: &i32) -> bool { *x % 2 == 0 }
    fn print_x(x: &i32) { print!("{} ", x) }

    vec.iter().filter(|x| !is_even(x)).for_each(|x| print_x(x));
    println!();
    vec.iter().filter(|x| is_even(x)).for_each(|x| print_x(x));
    println!();
}

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1 3 5 7 9
2 4 6 8 10

10. 判断素数（质数）

.any() 方法是一个在标准库中的std::iter::Iterator trait的默认方法。这个方法会检查迭代器中是否有元素满足给定的条件，如果有元素满足条件，它就会返回true，否则返回false。

示例：求30以内的质数

fn is_prime(n: u64) -> bool {
    match n {
        0..=1 => false,
        _ => !(2..n).any(|d| n % d == 0),
    }
}

fn main() {
    for i in 1..=30 {
        if is_prime(i) {
            print!("{} ", i);
        }
    }
    println!();
}

输出：

2 3 5 7 11 13 17 19 23 29

Rust 编程小技巧摘选(6)