Rust 编程小技巧摘选(7)

淩亂°似流年 2023-10-14 15:32 18阅读 0赞

![eb88291a18a94ba4ace118fb4e46ef23.png][]

**目录**

Rust 编程小技巧(7)

1. 交换变量

2. 翻转数组

3. for\_each() 用法

4. 结构体 Display trait

5. HashMap 和 BTreeMap

6. 遍历输出哈希表

7. 分离奇数和偶数

8. 判断素数（质数）

--------------------

## Rust 编程小技巧(7) ##

### 1. 交换变量 ###

与python, go等语言用法类似，不同的是rust不能省掉元组的括号 () 。

fn main() {
        let a = 3;
        let b = 23;
        println!("a: {}, b: {}", a, b);
        let (a, b) = (b, a);
        println!("a: {}, b: {}", a, b);
    }

输出：

a: 3, b: 23  
a: 23, b: 3

### 2. 翻转数组 ###

fn main() {
        let x = vec!["Hello", "World"];
        let y: Vec<_> = x.iter().rev().collect();
        println!("{:?}\n{:?}", x, y);
    
        let mut z = vec![1,2,3];
        println!("{:?}", z);
        z.reverse();
        println!("{:?}", z);
    }

输出：

\["Hello", "World"\]  
\["World", "Hello"\]  
\[1, 2, 3\]  
\[3, 2, 1\]

### 3. 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\]

### 4. 结构体 Display trait ###

结构体的两种形式，对应的成员取法不同；

前者用 self.成员变量名 self.x, self.y；后者用 self.成员索引号 self.0, self.1, self.2, ......

use std::fmt::Display;
    use std::fmt::Result;
    use std::fmt::Formatter;
    
    struct Point {
        x: f64,
        y: f64,
    }
    
    struct Point2(f64, f64);
    
    impl Display for Point {
        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
            write!(f, "({}, {})", self.x, self.y)
        }
    }
    
    impl Display for Point2 {
        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
            write!(f, "({}, {})", self.0, self.1)
        }
    }
    
    fn main() {
        let p = Point { x: 2.0, y: -3.5 };
        println!("{}", p);
    
        let p = Point2(2.0, -3.5);
        println!("{}", p);
    }

输出：

(2, -3.5)  
(2, -3.5)

### 5. HashMap 和 BTreeMap ###

两者都是 Rust 中的哈希表数据结构，它们的相同点：

都支持使用 Vec 或 String 作为键，也支持使用标准库中的其他结构体作为键。  
都支持使用 Option 类型作为键值对中的值。  
都支持使用 HashMap 类型的成员函数来进行基本的操作，例如插入、删除、查找、更新等。

不同点：

HashMap 使用哈希表（HashMap）算法来存储键值对，而 BTreeMap 使用 B-TREE（B 树）算法来存储键值对。因此，BTreeMap 在查找、插入、删除等操作上的性能比 HashMap 更好。

如果需要使用哈希表（HashMap）数据结构，但不需要按照键值对的顺序来访问，而且对查找、插入、删除等操作的性能要求不高，那么可以使用 HashMap。如果需要使用哈希表（HashMap）数据结构，而且对查找、插入、删除等操作的性能要求较高，而且需要按照键值对的顺序来访问，那么可以使用 BTreeMap。

示例：

use std::collections::BTreeMap;
    use std::collections::HashMap;
    
    fn main() {
        let mut x = BTreeMap::new();
        x.insert("one", 1);
        x.insert("two", 2);
        
        println!("{:?}", x);
    
        let x: HashMap<&str, i32> = [
            ("one", 1),
            ("two", 2),
        ].iter().cloned().collect();
        
        println!("{:?}", x);
    }

输出：

\{"one": 1, "two": 2\}  
\{"one": 1, "two": 2\}

### 6. 遍历输出哈希表 ###

在for...in...循环结构中使用元组(k, v)读取对应键值对：

use std::collections::BTreeMap;
    use std::collections::HashMap;
     
    fn main() {
        let mut x = BTreeMap::new();
        x.insert("one", 1);
        x.insert("two", 2);
        x.insert("three", 3);
        x.insert("four", 4);
        for (k, v) in &x {
            println!("Key={}, Value={}", k, v);
        }
        println!();
        let x: HashMap<&str, i32> = [
            ("one", 1),
            ("two", 2),
            ("three", 3),
            ("four", 4),
        ].iter().cloned().collect();
        
        for (k, v) in &x {
            println!("Key={key}, Value={val}", key = k, val = v);
        }
    }

输出：

Key=four, Value=4  
Key=one, Value=1  
Key=three, Value=3  
Key=two, Value=2

Key=three, Value=3  
Key=two, Value=2  
Key=one, Value=1  
Key=four, Value=4

### 7. 分离奇数和偶数 ###

.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

### 8. 判断素数（质数） ###

.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

--------------------