Rust个人学习笔记2

一定要牢记Rust是基于表达式的语言，除了声明语句和表达式语句外，其他的都是表达式。所以if也是表达式，它可以被用作右值。

条件控制

if-else。cpp和python得结合。

fn main() {
    let number = 34;
    if number < 0 {
        println!("number < 0");
    } else if number == 0 {
        println!("number = 0");
    } else {
        println!("number > 0");
    }
}
1
2
3
4
5
6
7
8
9
10

fn main() {
    let cond = true; // 语句和表达式
    let number = if cond {1} else {4};
    println!("{}",number);
}
1
2
3
4
5

循环控制

for

像python

for i in range(1,100): # python的
	pass
1
2

// Rust
// [l, r)
for i in 1..10 { // l..r 默认为 [l, r)
	println!("{}",i);
}

// [l, r]
for i in 1..=10 { // 加一个等号表示 左闭 右闭
    println!("{}",i);
}
1
2
3
4
5
6
7
8
9
10

遍历数组：

fn main() {
    let a = [1,2,3,4,5];
    for i in a.iter() {
        println!("{}",i);
    }
}

// c风格
fn main() {
    let a = [1,2,3,4,5];
    let n = a.len();
    for i in 0..n {
        println!("{}",a[i]);
    }
}

fn main() {
    let a = [1,2,4];
    // 切片
    for i in a[..].iter() {
        pass
    }
   	// 遍历字符串
    let str = "str";
    for ch i str.chars() {
        pass
    }
    // 遍历动态数组vector
    let c = vec![1,2,4];
    for i in c.iter() {
        pass
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

需要注意的是，使用迭代器遍历，得到的不是值本身，而是对值的引用，类似cpp中的：

vector<int> a;
for(auto it = a.begin(); it != a.end(); ++it) {
	pass;
}
1
2
3
4

需要加上&it。

fn main() {
    let a = [1,2,4];
    // 切片
    for i in a[..].iter() {
    	if *i == 3 {
    		pass
    	}
        pass
    }
   	// 遍历字符串
    let str = "str";
    for ch i str.chars() {
        pass
    }
    // 遍历动态数组vector
    let c = vec![1,2,4];
    for i in c.iter() {
    	if *i == 3 {
    		pass
    	}
        pass
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn main() {
    let a = [1,2,3,4,5];
    for i in a[..].iter() {
        if *i == 1 {
            print!("YES");
        }
    }
}
1
2
3
4
5
6
7
8

fn main() {
    let str = "abcdefg";
    // 字符串不用 *，chars不是迭代器类型
    for ch in str.chars() {
        println!("{}",ch);
        if ch == 'a' {
            println!("YES");
        }
    }
}
1
2
3
4
5
6
7
8
9
10

python中的enumerate。

fn main() {
    let str = "abcdefg";
    for (i,ch) in str.chars().enumerate() {
        println!("{} {}",i,ch);
        if ch == 'a' {
            println!("YES");
        }
    }
}
1
2
3
4
5
6
7
8
9

while

while与python的类似。

# python
n = 3
while n > 0:
	print(n)
	n -= 1
1
2
3
4
5

Rust中的

let mut number = 3;
while number > 0 {
	println!("{}",number);
	number -= 1; // 与python一样，没有 -- ++这些操作符
}
1
2
3
4
5

loop

loop相当于while true {}，它没有结束的条件，只要没有break就一直循环下去。

fn main() {
    let mut number:i32 = 3;
    loop {
        println!("{}",number);
        number -= 1;
        if number == 0 {
            break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10

break和continue

与其他编程语言一样的作用。

作为右值

还是那句话，Rust是基于表达式的语言，这赋予了Rust很多新的特性。像前面提到的if是表达式一样，loop和break都是表达式，同样可以作为右值：

fn main() {
    let mut number:i32 = 3;
    let a = loop {
        println!("{}",number);
        number -= 1;
        if number == 0 {
            break 3;
        }
    };
    println!("{}", a);
}
1
2
3
4
5
6
7
8
9
10
11

模式匹配

C/C++中有switch，可以控制多个流程分支。Rust把switch进行了升级，提供了match关键字，这是一个非常强大的控制流运算符，被称为模式匹配。

这种用法与C/C++中switch的用法类似，只是每个分支不需要加break。

在Rust中，match后面跟一个表达式，然后是分支。每个分支又分成两个部分，=>前面的部分叫模式，=>后面是执行体。
match执行时，先计算表达式的值，然后用该值与模式逐一进行匹配，当匹配成功时，执行该模式对应的执行体。若多个模式都匹配，也只执行第一个匹配成功的执行体。模式必须能覆盖所有的可能性，可以使用“_”，匹配其他的情况，类似于C/C++的default。

e.g.假设有1到5元的硬币，找到每个硬币类型出现了几次。

fn main() {
    let a = [1, 5, 2, 1, 2, 5, 3, 2, 2, 2, 4, 4];
    let (mut num1, mut num2, mut num3, mut num4, mut num5) = (0,0,0,0,0);
    for v in a[..].iter() {
        let val = *v;
        match val {
            1 => num1 += 1,
            2 => num2 += 1,
            3 => num3 += 1,
            4 => num4 += 1,
            5 => num5 += 1,
            _ => break
        }
    }
    println!("一元硬币有{}， 两元有{} 三元有{} 四元有{} 五元有{}",num1, num2, num3, num4, num5);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16