Rust基础语法

以下是 Rust 语言基础语法的核心要点，结合与 JavaScript 的对比，帮助前端开发者快速掌握核心概念：

---

一、变量与常量

1. 变量声明

• Rust：变量默认不可变，需用 mut 显式声明可变性。

  let x = 5;          // 不可变变量
  let mut y = 10;     // 可变变量
  y += 1;             // 允许修改
  

• JavaScript 对比：

  const x = 5;        // 不可变常量
  let y = 10;         // 可变变量
  

2. 常量

• Rust：必须显式标注类型，命名风格全大写。

  const MAX_POINTS: u32 = 100_000;  // 使用下划线提高可读性
  

• JavaScript：

  const MAX_POINTS = 100000;
  

---

二、数据类型

1. 标量类型（Scalar Types）

类型	Rust 示例	JavaScript 对比
整数	i32, u64	number（统一类型）
浮点数	f64	number
布尔	bool	boolean
字符	char（如 'A'，4字节）	string（如 'A'）

2. 复合类型（Compound Types）

• 元组（Tuple）

  let tup: (i32, f64, &str) = (500, 6.4, "hello");
  let (x, y, z) = tup;  // 解构
  println!("{}", tup.0); // 访问元素：500
  

  JavaScript 对比：无直接等价，近似数组解构：

  const tup = [500, 6.4, "hello"];
  const [x, y, z] = tup;
  

• 数组（Array）

  let arr = [1, 2, 3];           // 类型推断为 [i32; 3]
  let arr2: [i32; 5] = [0; 5];    // 初始化为 [0, 0, 0, 0, 0]
  println!("{}", arr[0]);         // 访问元素：1
  

  JavaScript 对比：

  const arr = [1, 2, 3];
  

---

三、字符串

1. 两种字符串类型

• String：堆分配，可变字符串。

  let mut s = String::from("hello");
  s.push_str(", world!");  // 修改字符串
  

• &str：字符串切片（不可变引用），通常用于函数参数。

  let s = "hello";  // 类型为 &str
  

2. 与 JavaScript 的差异

• JavaScript 只有动态字符串类型（类似 String），无栈上切片概念。
• Rust 字符串是 UTF-8 编码，而 JavaScript 使用 UTF-16。

---

四、函数

1. 基本语法

// 函数定义（带返回值类型标注）
fn add(x: i32, y: i32) -> i32 {
    x + y  // 无分号，隐式返回
}

// 调用函数
let result = add(5, 3);

2. 与 JavaScript 对比

function add(x, y) {
    return x + y;
}
const result = add(5, 3);

3. 特殊语法

• 表达式 vs 语句：
  Rust 中代码块（{}）是表达式，可返回值：

  let y = {
      let x = 3;
      x + 1  // 无分号，返回 4
  };
  

---

五、控制流

1. 条件语句

let num = 6;
if num % 2 == 0 {
    println!("偶数");
} else {
    println!("奇数");
}

// if 是表达式，可赋值
let result = if num > 5 { "大" } else { "小" };

2. 循环

• loop：无限循环

  loop {
      println!("无限循环");
      break;  // 手动退出
  }
  

• while

  let mut count = 0;
  while count < 5 {
      println!("count = {}", count);
      count += 1;
  }
  

• for

  let arr = [10, 20, 30];
  for element in arr.iter() {
      println!("值: {}", element);
  }
  

3. 与 JavaScript 对比

• JavaScript 的 for...of 类似 Rust 的 for 遍历迭代器：

  const arr = [10, 20, 30];
  for (const element of arr) {
      console.log(`值: ${element}`);
  }
  

---

六、结构体（Struct）

1. 定义与使用

// 定义结构体
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
}

// 创建实例
let user1 = User {
    email: String::from("[email protected]"),
    username: String::from("user1"),
    sign_in_count: 1,
};

// 修改可变实例
let mut user2 = User { /* ... */ };
user2.email = String::from("[email protected]");

2. 与 JavaScript 对比

• JavaScript 使用对象字面量：

  const user1 = {
      email: "[email protected]",
      username: "user1",
      sign_in_count: 1
  };
  

---

七、枚举（Enum）与模式匹配

1. 枚举定义

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

2. 模式匹配（match）

let msg = Message::Write(String::from("hello"));
match msg {
    Message::Quit => println!("退出"),
    Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
    Message::Write(text) => println!("消息: {}", text),
    Message::ChangeColor(r, g, b) => println!("颜色: RGB({}, {}, {})", r, g, b),
}

3. 与 JavaScript 对比

• JavaScript 无原生枚举，常用对象模拟：

  const Message = {
      Quit: Symbol("Quit"),
      Move: (x, y) => ({ type: "Move", x, y }),
      Write: (text) => ({ type: "Write", text }),
  };
  

---

八、错误处理

1. Result 类型

fn read_file(path: &str) -> Result<String, std::io::Error> {
    std::fs::read_to_string(path)
}

// 使用 match 处理
match read_file("hello.txt") {
    Ok(content) => println!("内容: {}", content),
    Err(e) => println!("错误: {}", e),
}

// 使用 ? 运算符简化（需在返回 Result 的函数内）
fn process_file() -> Result<(), std::io::Error> {
    let content = read_file("hello.txt")?;
    println!("内容: {}", content);
    Ok(())
}

2. 与 JavaScript 对比

• JavaScript 使用 try/catch：

  try {
      const content = fs.readFileSync("hello.txt", "utf8");
      console.log(`内容: ${content}`);
  } catch (e) {
      console.error(`错误: ${e}`);
  }
  

---

九、所有权与借用（核心概念）

1. 所有权规则

• 每个值有唯一所有者。
• 所有者离开作用域时，值被自动释放。
• 赋值、传参可能转移所有权（针对堆数据）。

2. 借用（引用）

let s1 = String::from("hello");
let len = calculate_length(&s1);  // 不可变借用

fn calculate_length(s: &String) -> usize {
    s.len()
}

---

十、练习建议

1. Rustlings：通过小型练习巩固语法（GitHub 仓库）。
2. 编写 CLI 工具：如文件内容统计、Markdown 转换器等。
3. 对比实现：用 Rust 重写 JavaScript 中的简单函数（如数组排序、字符串处理）。

---

通过掌握这些基础语法，前端开发者可逐步适应 Rust 的静态类型系统和内存安全模型，为进一步学习高级特性（如异步编程、生命周期）打下坚实基础。