[Rust 入门]Rust 表达式

编程回响

已于 2024-04-19 11:15:22 修改

阅读量782

点赞数 13

分类专栏： Rust 入门文章标签： rust 开发语言后端

于 2024-04-19 11:07:49 首次发布

本文链接：https://blog.csdn.net/zcfanbslst/article/details/137957842

版权

Rust 入门专栏收录该内容

15 篇文章 1 订阅

订阅专栏

本文详细介绍了Rust编程语言中的表达式、语句，包括变量绑定、函数定义、运算符、复合与分支表达式、循环、匹配以及return和闭包的使用。同时提到了Rust版本1.77.2在MacOS下的应用和一些示例代码。

摘要由CSDN通过智能技术生成

本教程环境：
系统：MacOS
Rust 版本：1.77.2

Rust 中表达式是构成程序的基础块，能够计算值、执行操作并确定控制流程。

表达式和语句

表达式总是计算并返回一个值，可以将其结果赋值给一个变量，或用作其他变量的一部分。

示例：5+6、call_function()、{ a + b }

语句执行一些操作，但是不返回任何值。有两种基本的用法：

声明变量：let x = 5;
表达式语句：表达式跟分号，例如some_function();

在 Rust 中每个 {} 块都是一个表达式，可以包含多个语句，最后{}表达式为这个块返回值。{} 的最后一行没有 ;，就返回最后一行表达式的结果作为块的返回；否则，返回 ()。

常见表达式

#[allow(unused_variables)]
#[allow(dead_code)]
#[allow(unused_assignments)]
// #[alloc()]
fn main() {
    // 常用表达式示例
    // 一些字面量：可以直接表达一个特定的值
    let integer = 42;
    let character = 'a';
    let boolean = true;
    let unit = ();

    // 常量声明
    const MAX_POINTS: u32 = 100_000;

    // 变量绑定
    let x = 10;
    let mut y = 20;
    y += 5;
}

函数表达式

Rust 中函数使用 fn 关键字声明。例如程序的入口就是 main() 函数。
在 Rust 中函数和变量名使用 cnake_case 规范进行命令。例如 get_name()。
函数的定义：

// 无参，返回值为 ()
fn main() {}

// 有参数，返回值为 ()
fn print_name(name: &str) {
    println!("hello {}", name);
}

// i32 类型参数，返回值为 i32 类型
fn add_one(n: i32) -> i32 {
    n + 1
}

多个参数使用逗号分隔；
每个参数都要显示的指定类型；
-> 后声明返回值类型；
如果没有声明返回值，返回 ()；
函数最后一行使用表达式，那么函数的返回值就是这个表达式的值。

运算符

在 Rust 中运算符与其操作数一起构成了表达式。常用的运算符：

算术运算符：+ - * /(除) %(求模)
比较运算符：== != > >= < <=
逻辑运算符：&& || !
类型转换：as
位运算符：& ｜ ^(异或) ! << >>

复合表达式

符合表达式就是将多个操作语句组合成更复杂的逻辑。

块表达式

let y = {
    let x = 1;
    x + 1
};

分支表达式(if/else)

if condition1 {
	block1
} else if condition2 {
	block2
} else {
	block_n
}

在 Rust 中 if 可以作为表达式来返回值。

let number = 7;
let result = if number < 5 {
    "less"
} else {
    "more"
};

循环表达式 - loop、while、for

loop循环会无限重复执行循环体，直到显示的调用 break 退出循环。
while循环会在给定条件为真时执行循环体，并且每次执行前都会检查这个条件。
for循环是通过迭代器来便利集合中的元素。

// loop 循环
let mut num = 10;
// loop 可以返回值
let result = loop {
    num -= 1;
    if num == 0 {
        break "num == 0";
    }
};
// 多个loop循环嵌套，可添加标签
let mut count = 0;
'outer: loop {
    println!("外层循环: {}", count);
    count += 1;
    let mut inner_count = 0;
    'inner: loop {
        println!("内层循环: {}", inner_count);
        inner_count += 1;
        if inner_count == 3 {
            // break 'inner;
            continue 'outer;
        }
        if count == 2 {
            break 'outer;
        }
    }
}

// for 
for elem in [10, 20, 30].iter() {
   println!("{}", elem);
}

匹配表达式 - match

类似于其他语言的 switch，允许根据表达式的值进行多个模式的匹配。

let value = 'c';
let description = match value {
   'a'..='z' | 'A'..='Z' => "it's a letter",
   '0'..='9' => "it's a digit",
   _ => "something else",
};

return 表达式

return 表达式会退出当前函数，并返回一个值。
不带值的 return; 是 return (); 的简写。
函数不必有明确的 return 表达式，如果最后的表达式没有分号，那么它的值就是函数的返回值。这种方式是 rust 中函数返回值的首选方式。
与 break 表达式一样，return 可以放弃进行中的工作。例如：

let output = File::create(filename)?;

这是 match 表达式的简写：

let output = match File::create(filename) {
	Ok(f) => f,
	Err(err) => return Err(err)
};

此时如果 File::create() 返回的是一个错误，那么就会执行 return 语句，函数返回一个错误。

特殊类型 !

不能正常结束的表达式属于一个特殊类型 !，不受"类型必须匹配"这条规则的约束。

fn exit(code: i32) -> ! {
	loop {
		...
	}
}

! 表示 exit() 函数永远不会返回，它是一个发散函数。

函数与方法调用

let x = gcd(1302, 462); // 函数调用
let room = player.location(); // 方法调用
let mut numbers = Vec::new(); // 调用类型关联函数

Rust 在函数调用或方法调用中，泛型类型的常用语法 Vec<T> 是不起作用的，需要使用 ::<...> 比目鱼语法。

return Vec::<i32>with_capacity(1000);

let ramp = (0..n).collect::<Vec<i32>>();

引用运算符

&用来表示引用，* 运算符用来访问引用所指向的值。
例如 &u64 类型的变量 elem，那么 *elem 的类型为 u64。

闭包表达式

let is_even = |x| x % 2 == 0;

本教程代码仓库：https://github.com/zcfsmile/RustLearning/tree/main/expression

参考链接：

https://kaisery.github.io/trpl-zh-cn/ch03-03-how-functions-work.html
https://kaisery.github.io/trpl-zh-cn/ch03-05-control-flow.html
https://www.ituring.com.cn/book/2846

🌟🌟 🙏🙏感谢您的阅读，如果对你有帮助，欢迎关注、点赞 🌟🌟