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") 
}

  

posted @ 2020-06-12 17:30  独角兕大王  阅读(324)  评论(0编辑  收藏  举报