三、语言基础 (二)

1 条件语句

• if...else 语句

  • 扩展：if...else if ... 语句

  • 注意：if 的判断条件必须是 bool 类型

    • 这个条件语句和 C, Java 等编程语言类似
    • 这个条件语句和 Javascript 的条件语句有很大的区别

    fn main() {
        let a = 5;
        let mut b = 10;
    
        // if...else 语句
        if a < b {
            println!("a<b, a={}, b={}", a, b);
        } else if a == b {
            println!("a=b=", a);
        } else {
            println!("a>b, a={}, b={}", a, b);
        }
    }
    

• if let 语句

  • Rust 中相对 C, Java, Javascript 等编程语言特有的语法

    fn check_number(source: u8) -> bool {
        // 如果 source 为 0 就返回 false；如果 source 不为 0 就返回 true
        if let 0 = source {
            false
        } else {
            true
        }
    }
    
    fn check_number2(source: u8) -> bool {
        // 这里只是将 let 定义变量和 if 语句结合到了一起，放在这里和上面的语法做对比
        // 这样的写法，与 C, Java, Javascript 等语言中的三元运算符 :? 作用相同
        // 这是利用了 if...else 语句可以有返回值的特性
        let result = if 0 == source { false } else { true };
        result
    }
    

• match 语句

  • Rust 中没有 switch 语句

  • match 语句和 C, Java, Javascript 等编程语言中的 switch 语句作用类似

  • match 表达式可以有多个分支，所有分支合起来 必须 覆盖变量的所有情况

  • match 语句将返回匹配到的分支的返回值

    enum Gender {
        Boy,
        Girl,
    }
    
    fn get_gender(gender: &Gender) -> String {
        // 匹配枚举
        match gender {
            Gender::Boy => String::from("boy"),
            Gender::Girl => String::from("girl"),
        }
    }
    
    fn check_number(source: u8) -> bool {
        // 匹配数字
        match source {
            0 => false,
            // 匹配除了 0 之外的所有情况
            _ => true,
        }
    }
    

2 循环语句

• while 循环

  • 和 C, Java, Javascript 等编程语言的 while 循环功能相同

  • 注意：在 Rust 中没有 do...while 循环

  • 注意：在 Rust 中，不建议使用 white true 来创建无限循环

    fn main() {
        // while 循环语句
        let mut a = 10;
        while a >= 0 {
            print!("{}, ", a);
            a = a - 1;
        }
        print!("\n");
    }
    
    

• for...in 循环

  • 用于遍历迭代器或一个数字范围

  • 在 Rust 中，没有类似于 for(int i = 0; i++; i< 100) 这样的 for 循环

    fn main() {
        // 遍历线性数据结构的迭代器
        let arr = [1, 2, 3, 4, 5];
        for elem in arr.iter() {
            print!("{} ", elem);
        }
        print!("\n");
    
        // 遍历一个数字范围
        let max = 10;
        // 这里也可以直接把 max 换成 10
        // 这里的 0 也可以换成变量
        for index in 0..max {
            print!("{} ", index * 10);
        }
        print!("\n");
    }
    

• loop 循环

  • 用于创建一个无限循环

  • 可以通过 break 一个值来让 loop 循环返回这个值

    fn main() {
        let mut loop_count = 0;
        let max = 10;
        let count = loop {
            loop_count += 1;
            if loop_count > max {
                break loop_count; // 让这个无限循环返回一个值
            }
        }
        println!("loop 循环结束");
    }
    

3. 函数定义

• 定义形式

  fn <func_name> ( <arg1: type1>, <arg2: type2>, ... ) -> <ReturnType> {
  // function body
  }
  
  // 示例
  fn add(a: i32, b: i32) -> i32 {
      a + b
  }
  
  

• 定义位置：任意位置均可

• 命名风格：snake_case

  • 类似于 C 语言的命名风格

• 函数返回值

  • 从第一个示例可以看出 Rust 中指定函数返回值的方式比较特殊，实际上 Rust 支持两种风格指定返回值

    /// 1. 隐式返回
    /// 隐式返回必须满足两个条件：
    /// * 语句必须是一个与返回值类型相同的表达式
    /// * 语句结尾不能有分号
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    
    /// 2. 指定返回
    /// 此时的用法和其他编程语言，如 C, Java, Javascript 等相同
    fn add2(a: i32, b: i32) -> i32 {
        return a + b;
    }