当前位置：网站首页>Rust从入门到精通05-语句和表达式

Rust从入门到精通05-语句和表达式

2022-08-10 23:16:00 【51CTO】

1、语句和表达式

语句和表达式是 Rust 语言实现逻辑控制的基本单元。 在 Rust 程序里面，语句（Statement）是执行一些操作但不返回的指令，表达式（Expressions）计算并产生一个值。表达式可以是语句的一部分，反过来，语句也可以是表达式的一部分。

1.1 语句不返回值

      
      

       
       fn main() {
       
       
     let x = (let y = 6);
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    •

这里面​​let y = 6​​ 是一个语句，不能把 ​​let​​ 语句赋值给另一个变量，否则编译器会报错。

Rust从入门到精通05-语句和表达式 _编译报错

1.2 表达式返回值

      
      

       
       fn main() {
       
       
     let y = {
       
       
         let x = 3;
       
       
         x + 1
       
       
     };
       
       
     println!("The value of y is: {}", y);
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    • 
       
       
  • 7.
    •

​​{}​​，也是一个表达式，表达式的结果是最后一行代码，​​x + 1​​后面没有分号，表示的是表达式，如果在表达式后面加上“;”，则表示语句，语句没有返回值，则上面代码会报错。

1.3 总结

①、一个表达式总会产生一个值，因此它必然有类型。 ②、语句不产生值，它的类型永远是 (); ③、如果把一个表达式加上分号，那么它就变成了一个语句； ④、如果把一个语句放到一个语句块中包起来，那么它就可以当成一个表达式使用。

Rust is primarily an expression language

翻译过来：Rust 基本上就是一个表达式语言。

Rust 除了 let / static / const / fn 等少数语句外，Rust 绝大多数代码都是表达式（expression）。所以 if / while / for / loop 都会返回一个值，函数最后一个表达式就是函数的返回值，这和函数式编程语言一致。

语句就是计算结果为()的特殊表达式。Rust 编译器，在解析代码的时候，如果碰到分号，就会继续往后执行。如果遇到语句，就执行语句；如果遇到表达式，则会对表达式求值；如果分号后面什么都没有，就补上()。

2、算术表达式

2.1、算术运算符：+ - * / %

分别是加、减、乘、除、取余。

      
      

       
       //加、减、乘、除、取余
       
       
 fn arithmetic_operation_test1(){
       
       
     let x = 100;
       
       
     let y = 10;
       
       
     println!("x={},y={},x+y={},x-y={},x*y={},x/y={},x%y={}",x,y,x+y,x-y,x*y,x/y,x%y);
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    •

2.2、比较运算符

注意： ①、比较运算符两边必须是同类型的，并且满足 PartialEq 约束； ②、比较表达式的类型是 bool; ③、Rust 禁止连续比较；

      
      

       
       fn compare_test(a:bool,b:bool,c:bool) -> bool{
       
       
     a==b==c
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    •

编译报错：

Rust从入门到精通05-语句和表达式 _赋值_02

2.3、赋值表达式

一个左值表达式、赋值运算符（=）、一个右值表达式可以构成一个赋值表达式。 ①、赋值号左右两边表达式的类型必须一致，否则编译报错。 ②、赋值表达式也有对应的类型和值，类型为 unit。即空的 tuple();

      
      

       
       //赋值表达式也有对应的类型和值，类型为 unit
       
       
 fn arithmetic_operation_test2(){
       
       
     let x = 1;
       
       
     let mut y = 2;
       
       
 
       
       
     let z = (y=x);
       
       
     //打印结果为()
       
       
     println!("{:?}",z);
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    • 
       
       
  • 7.
    • 
       
       
  • 8.
    • 
       
       
  • 9.
    •

这样能防止连续赋值，假设定义了三个 i32 类型的变量， x:i32,y:i32以及z:i32, 那么表达式 x=y=z就会发生编译错误，因为z变量是i32类型，却赋值()，编译器是不允许的。

2.4、语句块表达式

在Rust 中，语句块也可以是表达式的一部分。

语句和表达式的区分方式是后面带不带分号，如果带了分号，意味着这是一条语句，它的类型是()；

如果没有带分号，它的类型就是表达式的类型。

      
      

       
       //语句和表达式的区分方式是后面带不带分号，如果带了分号，意味着这是一条语句，它的类型是()；
       
       
 //如果没有带分号，它的类型就是表达式的类型。
       
       
 fn arithmetic_operation_test3(){
       
       
     //语句带分号，类型是 ()
       
       
     let x:() = {println!("helloworld");};
       
       
     //Rust 将按照顺序执行语句块内的语句，并将最后的一个表达式类型返回，所以 y 最终类型是 i32
       
       
     let y = {println!("helloworld"); 5};
       
       
     println!("x={:?}",x);
       
       
     println!("y={}",y);
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    • 
       
       
  • 7.
    • 
       
       
  • 8.
    • 
       
       
  • 9.
    • 
       
       
  • 10.
    •

打印结果为：

Rust从入门到精通05-语句和表达式 _赋值_03

2.5、if-else

①、条件表达式的类型必须是bool ②、条件表达式并未强制要求用小括号（）括起来，如果括起来，编译器反而会告警，认为是多余的括号； ③、后面的结果语句块一定要用大括号括起来；

      
      

       
       //if-else
       
       
 fn if_else_test()->i32{
       
       
     if (1>2) {
       
       
         //没有加分号，返回值就是1
       
       
         1
       
       
     }else{
       
       
         2
       
       
     }
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    • 
       
       
  • 7.
    • 
       
       
  • 8.
    • 
       
       
  • 9.
    •

使用 if-else 作为表达式，一定要注意 if 和 else 分支的类型必须一致，否则就不能构成一个合法的表达式，会出现编译错误。

最常见的一种情况是 if 分支有数据返回，但是省略了 else 分支：

      
      

       
       fn if_test() -> i32{
       
       
     if true {
       
       
         1
       
       
     }
       
       
     return 1;
       
       
 }
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    •

编译报错：

这是因为 else 分支如果省略了，默认类型是 ’()‘ ，与 if 分支不匹配。

Rust从入门到精通05-语句和表达式 _赋值_04

2.6、loop

在Rust中，loop表示无限死循环。

      
      

       
       //loop
       
       
fn loop_test(){
       
       
    let mut i = 0;
       
       
    loop{
       
       
        i += 1;
       
       
        if(i == 3){
       
       
            println!("three");
       
       
            //不在继续执行后面的代码，直接跳转到loop开头继续循环
       
       
            continue;
       
       
        }
       
       
        println!("{}",i);
       
       
        if(i == 5){
       
       
            println!("that's is OK");
       
       
            //跳出循环
       
       
            break;
       
       
        }
       
       
    }
       
       
}
      
      

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

continue 表示本次循环内，不在执行后面的语句，直接进入下一轮循环； break 表示跳出循环，不在执行。

注意：在Rust中，我们可以在 loop、while、for循环前面加上“生命周期标识”，在内部循环中，可以通过break、continue选择跳转到哪个循环标识。

2.7、while

带条件判断的循环语句。

      
      

       
       //while循环
       
       
fn while_test(){
       
       
    let mut n = 1;
       
       
    while(n < 100){
       
       
        if(n%2==0){
       
       
            println!("偶数:{}",n)
       
       
        }else{
       
       
            println!("奇数:{}",n)
       
       
        }
       
       
        n+=1;
       
       
    }
       
       
}
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    • 
       
       
  • 7.
    • 
       
       
  • 8.
    • 
       
       
  • 9.
    • 
       
       
  • 10.
    • 
       
       
  • 11.
    • 
       
       
  • 12.
    •

2.8、loop{} 和 while(true){}

从语法上理解，loop{} 和 while(true){} 这两种是没有任何区别的。 但相比于其他很多语言，Rust 语言要做更多的静态分析，loop 和 while true 语句在运行时没有任何区别，他们主要会影响编译器内部的静态分析结果。 比如：

      
      

       
       let x;
       
       
loop{
       
       
    x = 1;
       
       
    break;
       
       
}
       
       
println!("{}",x);
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    •

上面语句在Rust中完全合理，因为编译器可以通过流程分析推理出x=1,必然在println！之前执行过，所以打印x的值是完全合理的。 再比如对于while true 语句：

      
      

       
       let x;
       
       
while(true){
       
       
    x = 1;
       
       
    break;
       
       
}
       
       
println!("{}",x);
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    •

报错如下：

Rust从入门到精通05-语句和表达式 _编译器_05

因为编译器会觉得while 语句的执行和条件表达式在运行阶段的值有关（有可能while false，导致没有运行 while 里面的语句，从而 x 没有初始化）,于是编译器直接抛出一个未初始化异常。

2.9、for

Rust 中的for循环类似其他语言中的 for-each 循环。 for循环的主要用处是利用迭代器对包含同样类型的多个元素的容器进行遍历，如数组、链表、HashMap、HashSet等。

      
      

       
       fn for_test(){
       
       
    let array = &[1,2,3,4,5];
       
       
    for i in array {
       
       
        println!("The Numer is {}",i);
       
       
    }
       
       
}
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    •

3、常见错误

3.1 连续赋值报错

      
      

       
       fn f(a:bool,b:bool,c:bool) -> bool{
       
       
    a == b == c
       
       
}
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    •

报错如下：

Rust从入门到精通05-语句和表达式 _编译报错_06

3.2 漏掉 else 分支报错

如果 else 分支省略掉了，编译器会认为 else 分支的类型默认为（），但是 if 分支返回的是 i32 数据类型。

我们知道，使用 if-else 作为表达式，一定要注意 if 和 else 分支的类型必须一致，否则就不能构成一个合法的表达式，会出现编译错误。

      
      

       
       fn if_test() -> i32{
       
       
    if true {
       
       
        0
       
       
    }
       
       
    return 1;
       
       
}
      
      

      
      
    
       
       
  • 1.
    • 
       
       
  • 2.
    • 
       
       
  • 3.
    • 
       
       
  • 4.
    • 
       
       
  • 5.
    • 
       
       
  • 6.
    •

编译报错：

Rust从入门到精通05-语句和表达式 _编译器_07


原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://blog.51cto.com/u_12749768/5565492

边栏推荐

猜你喜欢

随机推荐