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