Rust函数

首先我们对之前了解到的Rust的所有权进行回顾哈：

fn main() {
    // 程序入口
    println!("Hello, world!");

    let y = "xxxx".to_string(); // let y1 = String::from("xxxx")
    another_function(y); // 这里传入y后，将所有权给了函数，函数并没有返回值，所以之后不能使用y
                         // println!("The y: {:?}", y); // 所有权转移，无法再使用y

    let y = String::from("xxx2x");
    other_function(&y); // 引用借用了所有权，y还可以使用
    println!("y: {}", y);

    let y1 = 2; // 对于一些标量和变量基础自带类型，整型、布尔等无论是否传入函数或者是否返回，都可以使用，因为是在栈中，只有这个函数消失/执行完了，才销毁
    int_function(y1);
    println!("y1: {}", y1); // 可以

    let array = [2; 3];
    array_function(array);
    println!("array: {:?}", array); // 可以
}

fn another_function(x: String) {
    // 函数必须对形参有类型约束
    println!("The x: {}", x);
}

fn other_function(x: &String) {
    println!("The y2: {}", x);
}

fn int_function(x: i32) {
    println!("The int : {}", x);
}

fn array_function(y: [i32; 3]) {
    println!("array: {:?}", y);
}

　　函数的基础概念比较简单，就是需要注意，每个函数的形参要有数据类型指定，使用多个时需要使用，分割。

 

包含语句和表达式的函数体

　　函数体由一系列的语句和一个可选的结尾表达式构成，语句（statements）是一个执行一些操作但不返回值的指令，表达式（expressions）计算并产生一个值。使用let关键字创建变量并绑定一个值是一个语句，如：let y = 6; 但是由于语句不能包含返回值，所有let 语句不能赋值给另一个变量：let x = (let y = 6);

fn main() {
    // 程序入口
    println!("Hello, world!");
    let x = 5;
    let y = {
        let x = 5;
        x +1  // 不写；表示默认是他返回
    };

    println!("y: {}",y);
}

　　由于在定义y的时候，那个{}的代码块最后没有添加;,这使得它整体变成了表达式，如果加了；则表示是个语句。（表达式没有；）

 

具有返回值的函数

　　函数可以通过->来声明要返回的数据类型，在Rust中，函数的返回值等同于函数体最后一个表达式的值，使用return关键字和指定值，可从函数中提前返回；但大部分函数隐式的返回最后的表达式。

fn main() {
    // 程序入口
    let x = five();
    println!("The value of x: {}", x);

    let y = plus_one(6);
    println!("The value of y: {}", y);
}

fn five() -> i32 {
    5
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

　　

控制流程

if表达式允许根据条件执行不同的代码分支。需要注意的是，Rust中只支持bool的if判断，其他语言中如果非空则为真，但是Rust只认为true/false。

fn main() {
    // 程序入口
    let number = 3;

    if number < 5 {
        println!("coundition was true");
    } else {
        println!("condition was false");
    }
}

　　多重条件判断

　　可以使用else if 表达式与if 和 else 组合来实现多重条件，例如：

fn main() {
    // 程序入口
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else {
        println!("number is divisible no ");
    }
}

　　let语句和if结合

　　因为if是表达式，我们可以在let语句的右侧使用它，例如：

fn main() {
    // 程序入口
    let condition = true;

    let number = if condition { 5 } else { 6 };  // 注意这个5，6必须是同一类型，如果一个是5，一个是“six”是报错的

    println!("The value of number is:{}", number);
}

　　

循环

　Rust有三种循环：loop、while和for，首先我们先试试loop。loop关键字告诉Rust一遍又一遍地执行一段代码。

fn main() {
    let mut counter = 0; // 如果使用 let counter = 0,不使用mut的话，会陷入一个死循环

    loop {
        counter += 1;
        if counter == 10 {
            break;
        }

        // 下面的的方式是错误的
        // let counter = counter + 1;
        println!("The counter: {}", counter);
    }
}

　从循环中返回，loop的一个用例是重试可能会失败的操作，比如检测线程是否完成了任务，然而你可能需要将操作结果传递出去，这时候就需要break表达式了。

fn main() {
    let mut counter = 0; // 如果使用 let counter = 0,不使用mut的话，会陷入一个死循环

    let ret = loop {
        counter += 1;
        if counter == 10 {
            break counter;
        }
    };
    println!("The counter: {}", ret);   //10
}

　　

while循环

　　Rust语言中可以通过组合loop、if、else和break，实现不同的程序控制效果，下面我们来展示哈while循环相关的代码把。

fn main() {
    let mut number = 0;

    while number != 0 {
        println!("{}", number);
        number = number - 1;
    }

    println!("OUT");

    let a = [10, 20, 34, 56];
    let mut index = 0;
    while index < 4 {
        println!("the value is: {}", a[index]);
        index = index + 1;
    }
}

　　

for循环

　　for循环的安全性和简洁性使得它成为Rust中使用最多的循环结构。

fn main() {
    let a = [10, 20, 34, 56];
    for element in a.iter() {
        println!("the value is: {}", element);
    }
    // 上面代码的优势在于for循环，更加安全，因为消除了由于超出数组结构或便利长度带来的bug

    // 对元素元素倒序
    for number in (1..12).rev() {
        println!("number: {}", number);  // 11,10...,1
    }
    println!("Out") 
}