函数

  • 声明函数使用fn关键字
  • 按照惯例，针对函数和变量名，Rust使用snack case命名规范： 字母小写，下划线分开

参数

  • parameter 形参 arguments 实参 和js一样

语句与表达式

(这个概念还是有点重要的，和原本js思路不一样)

  • Rust是一个基于表达式的语言
  • 语句是执行一些动作的指令
  • 表达式会计算产生一个值
  • 语句不返回值
  2. fn main() {
  3.     // let y  = {
  4.     //     let x = 1;
  5.     //     x + 3;      // 这就是一个语句，这时候y是一个空的Tuple
  6.     // }
  7.     let y  = {
  8.         let x = 1;
  9.         x + 3  // 不带分号，这就是一个表达式，y会是这段代码中最后一个表达式的值
  10.     }
  11.     println!("y is {}",y)
  12. }

返回值

  • 定义函数时，在 -> 符号后面声明函数的返回值类型
  • 在Rust里面，返回值就是函数体里面的最后一个表达式的值
  • 若想提前返回，可以使用return关键字制定一个值 （在Rust中大多数函数都是默认使用最后一个表达式作为返回值的）
  1. fn plus_five(x:i32) -> i32{
  2.     x + 5  // 这里一定不能加分号，加分号就是一个语句了，现在是一个表达式
  3. }
  5. fn main() {
  6.     let y  = plus_five(6);
  7.     println!("y is {:#?}",y)
  8. }

控制流：if else

  • if 是一个表达式，后面跟的条件必须是一个bool类型（和js不一样，不会隐式类型转换）
    示例：
  1.     let number = 5;
  3.     if number < 6{
  4.         println!("true")
  5.     } else {
  6.         println!("false")
  7.     }
  • 可以用 else if 处理多重条件
  • 但如果用了多余一条else if 建议使用 match 重构
  • 因为 if 是一个表达式，所以if表达式可以放在let语句中等号右边，示例：
  1. fn main() {
  2.     let condition = true;
  4.     let number = if condition { 5 } else { 6 };
  6.     println!("The value of number is {}",number);
  7. }

控制流： 循环

  • loop循环： 反复执行一段代码，直到你喊停，loop也是一个表达式，示例
  1. fn main() {
  2.     let mut counter = 0;
  4.     let result = loop {
  5.         counter+=1;
  7.         if counter == 10 {
  8.             break counter * 2
  9.         };
  10.     }; 
  12.     println!("The result is {}",result);
  13. }
  • while循环，每次执行循环体事前都判断一次条件，示例：
  1. fn main() {
  2.     let mut counter = 3;
  4.     while counter != 0 {
  5.         println!("{}!",counter);
  6.         counter-=1;
  7.     };
  8. }

  • for 循环

    • 遍历集合，while或loop也可以遍历集合，但易错且低效

      1. fn main() {
      2. // 类似js中的 for in 
      3. let a = [1,2,3,4,5];
      4. for elem in a.iter() {
      5.    println!("element is {}",elem);
      6. }
      7. }

    • Range，标注库提供Range，可以指定一个开始数字和一个结束数字，Range可以生成他们之间的数字（不包含结束），且有rev方法可以反转Range

      1. fn main() {
      2. // 表现和刚刚的while循环完全一致
      3. for number in (1..4).rev(){
      4.    println!("{}!",number);
      5. }
      6. }