Rust 中的关键字及示例

1. 常见关键字

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

rust 复制代码

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

break: 用于提前退出循环。

rust 复制代码

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

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

rust 复制代码

const MAX_POINTS: u32 = 100_000;

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

false: 布尔值字面值。

rust 复制代码

let a = false;

fn: 定义一个函数。

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

struct MyStruct;

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

in: for 循环语法。

rust 复制代码

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

let: 绑定一个值到变量。

rust 复制代码

let x = 5;

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

let mut x = 5;
x = 6;

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

rust 复制代码

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

return: 从函数返回一个值。

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

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

rust 复制代码

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

struct: 定义一个结构体。

rust 复制代码

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

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

rust 复制代码

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: 定义一组方法的集合，类似于接口。

rust 复制代码

trait MyTrait {
    fn do_something(&self);
}

true: 布尔值字面值。

rust 复制代码

let bool = true;

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

rust 复制代码

use std::collections::HashMap;

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

rust 复制代码

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

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

rust 复制代码

while x < 10 {
    x += 1;
}

2. 特殊关键字

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

rust 复制代码

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

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

rust 复制代码

async fn my_async_function() {
    // asynchronous code
}

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

rust 复制代码

my_async_function().await;

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

rust 复制代码

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

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

rust 复制代码

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

type: 定义一个类型别名。

rust 复制代码

type Kilometers = i32;

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

rust 复制代码

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

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

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

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