Rust关键字实例解析

Rust是一种注重安全性、并发性和性能的系统编程语言。在Rust中，关键字是保留的标识符，用于语言的特定语法结构。这些关键字不能用作普通的标识符，除非使用原始标识符（raw identifiers）。下面，我们将通过实例详细介绍Rust中当前使用的关键字及其功能。

当前使用的关键字及其实例

as

用于执行原始类型转换或消除trait中条目的歧义。

rust">let x: i32 = 5;
let y: f64 = x as f64; // 将i32类型的x转换为f64类型

async

返回一个Future而不是阻塞当前线程。

rust">async fn async_function() {// 异步代码
}

await

挂起执行直到Future的结果准备好。

rust">async fn get_data() -> String {async {"Data".to_string()}.await
}

break

立即退出循环。

rust">for i in 0..10 {if i == 5 {break; // 当i等于5时退出循环}
}

const

定义常量项。

rust">const MAX_POINTS: u32 = 100_000;

continue

继续到下一个循环迭代。

rust">for i in 0..10 {if i % 2 == 0 {continue; // 跳过偶数，继续下一次循环}println!("{}", i);
}

crate

在模块路径中，指的是crate根。

rust">mod my_crate {// 模块内容
}

dyn

动态派送到trait对象。

rust">trait Draw {fn draw(&self);
}struct Screen;
impl Draw for Screen {fn draw(&self) {println!("Drawing screen");}
}let screen: &dyn Draw = &Screen;
screen.draw();

else

if和if let控制流构造的备选方案。

rust">let condition = true;
if condition {println!("Condition is true");
} else {println!("Condition is false");
}

enum

定义一个枚举。

rust">enum Message {Quit,Move { x: i32, y: i32 },Write(String),
}

extern

链接一个外部函数或变量。

rust">extern crate rand;
use rand::Rng;let mut rng = rand::thread_rng();
let n: u32 = rng.gen();

false

布尔假字面量。

rust">let is_active: bool = false;

fn

定义一个函数。

rust">fn double(x: i32) -> i32 {x * 2
}

for

循环遍历迭代器中的项。

rust">for item in vec![1, 2, 3] {println!("{}", item);
}

if

根据条件表达式的结果进行分支。

rust">let condition = true;
if condition {println!("Condition is true");
}

impl

实现固有或trait功能。

rust">struct Rectangle {width: u32,height: u32,
}impl Rectangle {fn area(&self) -> u32 {self.width * self.height}
}

in

for循环语法的一部分。

rust">for i in 0..10 {println!("{}", i);
}

let

绑定一个变量。

rust">let number = 5;

loop

无条件循环。

rust">loop {println!("Infinite loop");break; // 需要显式break退出
}

match

将值匹配到模式。

rust">let num = Some(4);
match num {Some(x) => println!("Num is {}", x),None => println!("No num"),
}

mod

定义一个模块。

rust">mod math_functions {pub fn add(x: i32, y: i32) -> i32 {x + y}
}

move

使闭包取得其捕获的所有所有权。

rust">let text = "Hello".to_string();let move_text = move || {println!("{}", text);
};move_text();

mut

在引用、原始指针或模式绑定中表示可变性。

rust">let mut num = 5;
num += 1;

pub

在结构体字段、impl块或模块中表示公共可见性。

rust">pub struct Point {pub x: i32,pub y: i32,
}

ref

通过引用绑定。

rust">let x = 5;
let y: &i32 = &x;

return

从函数返回。

rust">fn double(x: i32) -> i32 {return x * 2;
}

Self

我们正在定义或实现的类型的类型别名。

rust">impl Rectangle {fn area(&self) -> u32 {self.width * self.height}
}

self

方法主体或当前模块。

rust">impl Rectangle {fn area(&self) -> u32 {self.width * self.height}
}

static

全局变量或整个程序执行期间持续的生命周期。

rust">static HELLO: &str = "Hello";

struct

定义一个结构体。

rust">struct Point {x: i32,y: i32,
}

super

当前模块的父模块。

rust">mod math {pub fn add(x: i32, y: i32) -> i32 {x + y}
}mod functions {use super::math;fn call_add() {println!("3 + 4 = {}", math::add(3, 4));}
}

trait

定义一个trait。

rust">trait Draw {fn draw(&self);
}

true

布尔真字面量。

rust">let is_active: bool = true;

type

定义一个类型别名或关联类型。

rust">type Result<T> = std::result::Result<T, std::io::Error>;

union

定义一个联合体。

rust">union U {x: i32,y: f32,
}

unsafe

表示不安全代码、函数、trait或实现。

rust">unsafe fn dangerous_fn() {// 不安全代码
}

use

将符号引入作用域。

rust">use std::io;

where

表示约束类型的子句。

rust">fn generic_function<T>(t: T) where T: Copy {// 使用T
}

while

根据表达式的结果有条件地循环。

rust">let mut number = 1;
while number < 10 {println!("{}", number);number += 1;
}

为将来保留的关键字

以下是Rust为潜在的未来使用而保留的关键字，它们目前还没有功能：

abstract
become
box
do
final
macro
override
priv
try
typeof
unsized
virtual
yield

原始标识符

原始标识符是允许你在通常不允许使用关键字的地方使用关键字的语法。你可以通过在关键字前加上r#来使用原始标识符。

例如，match是一个关键字。如果你尝试编译以下使用match作为其名称的函数：

rust">fn match(needle: &str, haystack: &str) -> bool {haystack.contains(needle)
}

你会得到这个错误：

error: expected identifier, found keyword `match`--> src/main.rs:4:4|
4 | fn match(needle: &str, haystack: &str) -> bool {|    ^^^^^ expected identifier, found keyword

错误显示你不能使用关键字match作为函数标识符。要使用match作为函数名称，你需要使用原始标识符语法，如下所示：

rust">fn r#match(needle: &str, haystack: &str) -> bool {haystack.contains(needle)
}fn main() {assert!(r#match("foo", "foobar"));
}

这段代码将无错误编译。注意在函数定义及其在main中被调用时函数名称上的r#前缀。

原始标识符允许你使用任何你选择的词作为标识符，即使这个词碰巧是一个保留的关键字。这为我们选择标识符名称提供了更多的自由，同时也让我们能够与用不同语言编写的程序集成。此外，原始标识符允许你使用