胖胖的枫叶

流水要争先，争的是滔滔不绝。

0%

Rust函数与控制流

发表于 更新于 分类于
本文字数： 4.1k 阅读时长 ≈ 4 分钟

函数

函数遍布于 Rust 代码中,Rust 代码中的函数和变量名使用 snake case 规范风格。在 snake case 中，所有字母都是小写并使用下划线分隔单词。

  • Rust 中的函数定义以 fn 开始并在函数名后跟一对圆括号。大括号告诉编译器哪里是函数体的开始和结尾。
  • 可以使用函数名后跟圆括号来调用我们定义过的任意函数。Rust 不关心函数定义于何处，只要定义了就行。

案例

1
2
3
4
5
6
7
8
fn main() {
    println!("Hello, world!");
    hello();
}

fn hello(){
    print!("hello function")
}
  • Console
1
2
Hello, world!
hello function

函数参数

函数也可以被定义为拥有 参数（parameters），参数是特殊变量，是函数签名的一部分。当函数拥有参数（形参）时，可以为这些参数提供具体的值（实参）。

  • 在函数签名中，必须 声明每个参数的类型。这是 Rust 设计中一个经过慎重考虑的决定：要求在函数定义中提供类型注解，意味着编译器不需要你在代码的其他地方注明类型来指出你的意图。
  • 多个参数时，使用逗号分隔。

案例

1
2
3
4
5
6
7
8
fn number(x:i8){
    print!("value {} ",x)
}

fn main() {
    println!("Hello, world!");
    number(1);
}
  • Console
1
2
Hello, world!
value 1
  • number函数声明一个x的参数，x的类型被指定为i8。

函数体

Rust 是一门基于表达式（expression-based）的语言,函数体由一系列的语句和一个可选的结尾表达式构成

  • 函数可以向调用它的代码返回值。不需要对返回值命令，但要在箭头（->）后声明它的类型。在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。使用 return 关键字和指定值，可从函数中提前返回。

案例一

1
2
3
4
5
6
7
8
9
10
fn main() {
    println!("Hello, world!");
    // number(1);
    let x = 5;
    let y = {
        let x = 3;
        x + 1
    };
    println!("x {} y {}", x,y);
}
  • Console
1
2
Hello, world!
x 5 y 4

案例二

1
2
3
4
5
6
7
8
fn i() -> i8{
    1
}

fn main(){
    let x = i();
    println!("value {}" , x);
}
  • Console
1
value 1

案例三

1
2
3
4
5
6
7
8
fn ii(x : i8)-> i8 {
    x + 1
}

fn main(){
    let x = ii(2);
    println!("value {}",x);
}
  • Console
1
value 3

函数与变量

在 Rust 下，函数是一等公民，可以作为参数或者返回值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

fn one(value: i32, f: fn(i32) -> i32) -> i32 {
    f(value)
}

fn two(value: i32) -> i32 {
    value * value
}

fn three(value: i32) -> i32 {
    value * value * value
}

fn main() {
    println!("apply square: {}", apply(2, square));
    println!("apply cube: {}", apply(2, cube));
}
  • Console
1
2
apply square: 4
apply cube: 8
  • fn(i32) -> i32 是 three函数第二个参数，它表示可以接受一个函数作为参数。这个传入的函数必须是：参数只有一个，且类型为 i32，返回值类型也是 i32。
  • Rust 函数参数的类型和返回值的类型都必须显式定义，如果没有返回值可以省略，返回 unit。函数内部如果提前返回，需要用 return 关键字

控制流

根据条件是否为真来决定是否执行某些代码

if

案例一

  • 注意不需要()
1
2
3
4
5
6
7
8
9
10
11
12
13
n ii(x : i8)-> i8 {
    x + 1
}

fn main(){
    let number = 5;
    let x = ii(2);
    if number > x{
        println!("value {}",x);
    }else{
        println!("value x {}",x);
    }
}
  • Console
1
value 3

案例二

在 let 语句中使用if

  • 将if 表达式中返回值赋给一个变量。这里需要注意返回类型需要一致。否则编译失败。
1
2
3
4
5
6
7
8
9
fn main() {
    let c = true;
    let number = if c {
        5
    } else {
        6
    };
    println!("The value of c is: {}", number);
}

loop

Rust 为此提供了多种 循环（loops）。一个循环执行循环体中的代码直到结尾并紧接着回到开头继续执行。

案例一

1
2
3
4
5
fn main() {
    loop {
        println!("hello!");
    }
}
  • Console，需要手动停止。
1
2
hello!
.....

案例二

使用break 关键字跳出循环。

1
2
3
4
5
6
7
8
9
10
fn main() {
    let mut number = 1;
    let result = loop {
        number += 1;
        if number == 10 {
            break number;
        }
    };
    println!("result {} value {}",result ,number);
}
  • Console
1
result 10 value 10

while

当条件为真，执行循环。当条件不再为真。调用 break 停止循环。

案例

1
2
3
4
5
6
7
8
9
fn main() {
    let mut number = 3;

    while number > 0 {
        println!("{}!", number);
        number = number - 1;
    }
    println!("done {} ",number);
}
  • Console
1
2
3
4
3!
2!
1!
done 0

for

遍历集合

案例一

1
2
3
4
5
6
7
8
9
10
11
12
fn main(){
	let arr = [1,2,3,4,5];
	let mut index = 0;
	while index < 3 {
		println!("value {}",arr[index]);
		index = index + 1;
	}
  
  for element in arr.iter() {
        println!("value is: {}", element);
  }
}
  • Console
1
2
3
4
5
6
7
8
value 1
value 2
value 3
value is: 1
value is: 2
value is: 3
value is: 4
value is: 5

案例二

使用 rev来反转range

1
2
3
4
5
6
7

fn main(){
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("done!!!");
}
  • Console
1
2
3
4
3!
2!
1!
done!!!

End