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 版本中没有使用，但它们可能在将来被采用，因此不能作为标识符使用：
abstractbecomeboxdofinalmacrooverrideprivtrytypeofunsizedvirtualyield