Rust 中的关键字以及示例

1. 常见关键字

• as: 用于类型转换，例如将一个值从一种类型转换为另一种类型。

let x: i32 = 42;
let y: u8 = x as u8;

• break: 用于提前退出循环。

for i in 0..10 {if i == 5 {break;}
}

• const: 定义一个常量，常量的值在编译时就确定，不会在运行时改变。

const MAX_POINTS: u32 = 100_000;

• continue: 跳过当前循环中的剩余部分，直接进入下一次循环迭代。

for i in 0..10 {if i % 2 == 0 {continue;}println!("{}", i);
}

• crate: 表示当前包或库的根模块，通常用于定义或引用其他模块。

pub fn my_function() {println!("This is a function in the crate root.");
}

• else: 与 if 搭配使用，表示条件不满足时执行的代码块。

if x > 5 {println!("Greater than 5");
} else {println!("Not greater than 5");
}

• enum: 定义一个枚举类型，它可以包含多个不同类型的变体（variants）。

enum Direction {Up,Down,Left,Right,
}

• extern: 用于外部函数或变量的声明，通常用于与 C 语言的交互。

extern "C" {fn printf(format: *const u8, ...) -> i32;
}

• false: 布尔值字面值。

let a = false;

• fn: 定义一个函数。

fn my_function() {println!("Hello, world!");
}

• for: 用于循环，通常与迭代器结合使用。

for i in 0..5 {println!("{}", i);
}

• if: 条件语句，根据表达式的真假选择执行的代码块。

if x > 5 {println!("Greater than 5");
}

• impl: 实现一个 trait 或为一个类型实现方法。

struct MyStruct;impl MyStruct {fn new() -> MyStruct {MyStruct}
}

• in: for 循环语法。

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

• let: 绑定一个值到变量。

let x = 5;

• loop: 定义一个无限循环，可以用 break 退出循环。

loop {println!("This will print forever!");break; // Exit the loop
}

• match: 模式匹配，类似于 switch/case 语句。

match x {1 => println!("One"),2 => println!("Two"),_ => println!("Something else"),
}

• mod: 定义一个模块，模块是代码的组织单位。

mod my_module {pub fn my_function() {println!("Hello from the module!");}
}

• move: 使闭包获取其捕获项的所有权，而不是借用。

let x = vec![1, 2, 3];
// 使用 move 将 x 的所有权移动到闭包中
let equal_to_x = move |z| z == x;
// 此时 x 已经被移动到闭包中，不能在此处再访问 x
// println!("{:?}", x); // 这行代码会报错

• mut: 标记一个变量是可变的。

let mut x = 5;
x = 6;

• pub: 公开一个模块、函数或变量，使其可以从其他模块访问。

pub fn public_function() {println!("This function is public!");
}

• return: 从函数返回一个值。

fn my_function() -> i32 {return 5;
}

• Self: 定义或实现 trait 的类型的类型别名。

impl Rectangle {fn new(width: u32, height: u32) -> Self {Self { width, height } // `Self` 指代 `Rectangle`}
}

• self: 表示方法本身或当前模块。

struct Rectangle {width: u32,height: u32,
}
impl Rectangle {fn area(&self) -> u32 {self.width * self.height // `self` 指代 `Rectangle` 的实例}
}

• static: 表示全局变量或在整个程序执行期间保持其生命周期。

static HELLO: &str = "Hello, world!";
let s: &'static str = "Hello, world!";

• struct: 定义一个结构体。

struct MyStruct {field1: i32,field2: f64,
}

• super: 表示当前模块的父模块。

mod parent {pub struct ParentStruct {pub name: String,}pub fn hello() {println!("Hello from parent module");}pub mod child {pub fn create_parent_struct(name: &str) -> super::ParentStruct {super::ParentStruct { name: name.to_string() } // 访问父模块中的结构体}pub fn hello_from_child() {super::hello(); // 使用 `super` 访问父模块中的 `hello` 函数}}
}fn main() {parent::child::hello_from_child();let parent_struct = parent::child::create_parent_struct("Rust");println!("Created ParentStruct with name: {}", parent_struct.name);
}

• trait: 定义一组方法的集合，类似于接口。

trait MyTrait {fn do_something(&self);
}

• true: 布尔值字面值。

let bool = true;

• use: 导入一个模块、类型或函数到当前作用域。

use std::collections::HashMap;

• where: 为泛型或类型约束指定条件。

fn my_function<T>(x: T) where T: std::fmt::Display {println!("{}", x);
}

• while: 定义一个循环，当条件为真时继续执行。

while x < 10 {x += 1;
}

2. 特殊关键字

• unsafe: 用于声明一个不安全的代码块，允许执行一些通常被禁止的操作，例如解引用裸指针。

let p: *const i32 = &10;
unsafe {println!("p points to: {}", *p);
}

• async: 用于定义一个异步函数，返回一个 Future。

async fn my_async_function() {// asynchronous code
}

• await: 等待一个异步操作完成。

my_async_function().await;

• dyn: 用于动态分发，实现类似于面向对象语言中的多态性。

fn my_function(p: &dyn MyTrait) {p.do_something();
}

• ref: 引用模式匹配中的值。

let tuple = (42, "hello");
let (x, ref y) = tuple;

• type: 定义一个类型别名。

type Kilometers = i32;

• union: 定义一个联合体，允许一个数据结构在同一位置存储不同类型的数据。

union MyUnion {i: i32,f: f32,
}

3. 保留但未使用的关键字

这些关键字在当前 Rust 版本中没有使用，但它们可能在将来被采用，因此不能作为标识符使用：

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