Rust基础语法介绍

Rust 基本语法介绍

Rust 是什么

Rust 是一门偏系统级的现代编程语言，特点：

・ 性能接近 C/C++

・ 内存安全（不容易出现空指针、内存泄漏）

・ 并发安全

・ 编译速度比 C++ 友好

・ 适合：

・ 后端

・ 操作系统

・ WebAssembly

・ AI基础设施

・ 区块链

・ 高性能服务

Rust 语法有点像：

・ Python + C++

・ JavaScript + 强类型

・ Go + 生命周期系统

---

1. 变量赋值

不可变变量（默认）

fn main() {
    let x = 10;
    println!("{}", x);
}

Rust 默认变量不可修改。

---

可变变量

fn main() {
    let mut x = 10;

    x = 20;

    println!("{}", x);
}

mut 表示 mutable（可变）。

---

常量

const PI: f64 = 3.14159;

特点：

・ 必须指定类型

・ 名字通常全大写

---

2. 基本数据类型

---

数字

整数

let a: i32 = 10;
let b: u32 = 20;

常见：

类型	含义
i8	有符号8位
i32	有符号32位
i64	有符号64位
u32	无符号32位

---

浮点数

let pi: f64 = 3.14;

Rust 默认浮点：

f64

---

布尔

let flag: bool = true;

---

字符

let c: char = 'A';

Rust 字符使用单引号。

---

字符串

不可变字符串切片

let s = "hello";

类型：

&str

---

可增长字符串

let mut s = String::from("hello");

s.push_str(" world");

---

3. 算数运算

let a = 10;
let b = 3;

println!("{}", a + b); // 加
println!("{}", a - b); // 减
println!("{}", a * b); // 乘
println!("{}", a / b); // 除
println!("{}", a % b); // 取余

---

4. 逻辑运算

let a = true;
let b = false;

println!("{}", a && b); // 与
println!("{}", a || b); // 或
println!("{}", !a);     // 非

---

5. 列表（Vec）

Rust 没有传统 ArrayList。

最常用：

Vec<T>

---

创建列表

let nums = vec![1, 2, 3];

---

可变列表

let mut nums = vec![1, 2, 3];

nums.push(4);

---

遍历

for n in &nums {
    println!("{}", n);
}

---

6. 集合（HashSet）

需要导入：

use std::collections::HashSet;

---

创建集合

use std::collections::HashSet;

fn main() {
    let mut set = HashSet::new();

    set.insert(1);
    set.insert(2);

    println!("{:?}", set);
}

特点：

・ 自动去重

・ 无序

---

7. Map（HashMap）

Rust 的 map：

HashMap<K, V>

---

创建 Map

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();

    map.insert("name", "Tom");
    map.insert("age", "18");

    println!("{:?}", map);
}

---

获取值

println!("{}", map["name"]);

更安全写法：

if let Some(v) = map.get("name") {
    println!("{}", v);
}

---

8. if 判断

let age = 20;

if age >= 18 {
    println!("adult");
} else {
    println!("child");
}

---

if 是表达式

这是 Rust 很特别的地方。

let age = 20;

let result = if age >= 18 {
    "adult"
} else {
    "child"
};

println!("{}", result);

---

9. while 循环

let mut i = 0;

while i < 5 {
    println!("{}", i);

    i += 1;
}

---

10. for 循环

---

遍历范围

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

结果：

0 1 2 3 4

---

包含结束值

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

结果：

0 1 2 3 4 5

---

遍历数组

let nums = vec![1, 2, 3];

for n in nums {
    println!("{}", n);
}

---

11. 函数

---

基本函数

fn add(a: i32, b: i32) -> i32 {
    a + b
}

调用：

let result = add(1, 2);

---

Rust 特点：最后一行自动返回

fn add(a: i32, b: i32) -> i32 {
    a + b
}

等价于：

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

但第一种更常见。

---

12. 类（Struct）

Rust 没有传统 OOP 类。

使用：

struct

---

定义结构体

struct User {
    name: String,
    age: i32,
}

---

创建对象

let user = User {
    name: String::from("Tom"),
    age: 18,
};

---

实现方法

struct User {
    name: String,
    age: i32,
}

impl User {
    fn say(&self) {
        println!("hello {}", self.name);
    }
}

调用：

user.say();

---

13. Rust 特有核心语法（重点）

这部分才是真正的 Rust 灵魂。

---

（1）所有权 Ownership

Rust 最大特点。

---

一个值只能有一个主人

let s1 = String::from("hello");

let s2 = s1;

此时：

s1 已失效

因为所有权转移给：

s2

---

为什么？

避免：

・ 重复释放内存

・ 野指针

・ 内存泄漏

---

（2）借用 Borrow

不转移所有权。

---

不可变借用

fn print_str(s: &String) {
    println!("{}", s);
}

---

可变借用

fn change(s: &mut String) {
    s.push_str(" world");
}

---

（3）引用规则

Rust 最核心规则：

同一时间：

・ 可以有多个不可变引用

・ 或一个可变引用

・ 不能同时存在

这就是：

"编译期线程安全"

---

（4）match 模式匹配

Rust 超强语法。

类似：

・ switch

・ Python match

・ 函数式语言模式匹配

---

基础写法

let num = 2;

match num {
    1 => println!("one"),
    2 => println!("two"),
    _ => println!("other"),
}

_ 表示默认情况。

---

（5）Option 类型（避免空指针）

Rust 没有 null。

使用：

Option<T>

---

示例

let x: Option<i32> = Some(5);

或者：

let x: Option<i32> = None;

---

使用 match

match x {
    Some(v) => println!("{}", v),
    None => println!("empty"),
}

---

（6）Result 错误处理

Rust 不喜欢异常。

使用：

Result<T, E>

---

示例

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("divide by zero"))
    } else {
        Ok(a / b)
    }
}

---

（7）Trait（类似接口 Interface）

trait Animal {
    fn speak(&self);
}

实现：

impl Animal for Dog {
    fn speak(&self) {
        println!("wang");
    }
}

类似：

・ Java interface

・ Go interface

但更强。

---

（8）生命周期 Lifetime

Rust 最难部分。

用于：

"引用活多久"。

---

写法

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

---

14. Rust 的整体特点总结

特性	Rust
内存安全	极强
GC垃圾回收	没有
性能	接近C++
并发安全	极强
学习难度	高
编译速度	中等
开发体验	越来越好

---

15. Rust 最适合的领域

Rust 现在大量用于：

・ AI基础设施

・ 高性能后端

・ 数据库

・ 区块链

・ 游戏引擎

・ WebAssembly

・ 云原生

・ 操作系统

・ 网络代理

・ 安全工具

很多新项目已经开始用 Rust 替代 C++。

典型代表：

・ Cloudflare

・ Discord

・ Microsoft

・ Amazon

都在大规模使用 Rust。

User:

借用的规则，我没搞明白，这个规则主要解决什么问题，请在深入解释一下rust的这个特点。展开收起

ChatGPT:

Rust 借用（Borrow）到底在解决什么问题

先给结论：

Rust 的借用系统，本质是在：

"不使用垃圾回收（GC）的情况下，解决内存安全和多线程安全问题。"

核心目标：

・ 防止空指针

・ 防止野指针

・ 防止数据竞争（Data Race）

・ 防止内存重复释放

・ 防止一个线程修改时另一个线程正在读取

而且：

这些问题是在：

编译阶段

直接阻止。

不是运行时崩溃。

---

一、先理解：为什么传统语言会出问题

---

1. C/C++ 的问题：野指针

看一个经典例子：

string* get_name() {
    string s = "Tom";

    return &s;
}

问题：

函数结束：

s 被销毁

但你返回了：

s 的地址

结果：

返回了一个已经失效的内存地址

这就是：

野指针

后果：

・ 崩溃

・ 数据错乱

・ 安全漏洞

这是 C/C++ 最经典问题之一。

---

Rust 如何解决？

Rust 编译器直接禁止：

fn get_name() -> &String {
    let s = String::from("Tom");

    &s
}

直接报错。

因为：

s 生命周期结束了

引用不能活得比原对象更久。

这就是：

借用检查器（Borrow Checker）

---

二、借用到底是什么

借用：

本质就是：

临时使用别人的数据

而不是获得所有权。

---

类比现实世界

比如：

你有一本书。

---

所有权

你把书送给别人

你自己没了。

---

借用

别人只是借去看

书还是你的。

---

Rust 的：

&s

就是：

借用

不是拥有。

---

三、Rust 最核心规则

这是整个 Rust 灵魂：

规则：

同一时刻：

要么：
    多个只读引用

要么：
    一个可写引用

不能同时存在。

---

为什么？

为了防止：

数据竞争（Data Race）

---

四、什么是数据竞争

看一个危险情况。

---

情况：

一个人正在读数据：

name = "Tom"

同时另一个人：

修改 name

那么：

读取的人可能读到：

"T"

或者：

"To"

或者：

崩溃

因为：

内存可能正在变化。

---

这就是多线程最大问题之一

很多：

・ Java 崩溃

・ C++ 崩溃

・ Go 并发bug

本质都是：

多个地方同时修改同一块内存

---

Rust 的解决方案

Rust 编译器：

直接禁止这种情况。

---

五、看最核心例子

---

1. 多个不可变借用（允许）

fn main() {
    let s = String::from("hello");

    let r1 = &s;
    let r2 = &s;

    println!("{} {}", r1, r2);
}

为什么允许？

因为：

都是只读

没人修改数据。

安全。

---

2. 一个可变借用（允许）

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;

    r1.push_str(" world");
}

为什么允许？

因为：

只有一个人在修改

没有竞争。

---

3. 可变 + 不可变同时存在（禁止）

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &mut s;

    println!("{}", r1);
}

直接报错。

---

为什么禁止？

因为：

r1 正在读
r2 正在改

可能：

・ 数据突然变化

・ 内存重新分配

・ 引用失效

---

六、真正危险的地方：内存重分配

这个才是 Rust 最恐怖的问题来源。

---

看这个：

let mut s = String::from("hello");

字符串在堆内存。

---

假设：

内存容量：

5字节

---

现在：

s.push_str(" world");

长度不够。

Rust 会：

重新申请更大的内存

然后：

旧内存释放

---

问题来了：

如果此时：

let r1 = &s;

之前有人引用旧内存。

那：

r1 指向的内存已经失效

这就是：

悬垂引用（Dangling Reference）

---

Rust 怎么解决？

Rust：

直接禁止：

读的时候写

因此：

永远不会出现：

引用突然失效

---

七、借用规则其实是"锁"

你可以把 Rust 借用理解成：

编译期锁系统

---

不可变借用

相当于：

读锁

允许多个。

---

可变借用

相当于：

写锁

只能一个。

---

所以：

Rust 的借用：

本质是：

编译期读写锁

---

八、为什么 Rust 并发那么强

因为：

Rust 在编译阶段：

已经保证：

不会发生数据竞争

---

很多语言：

线程安全依赖：

・ 程序员自觉

・ mutex

・ synchronized

・ lock

但人会犯错。

---

Rust：

直接：

编译不通过

---

九、借用检查器（Borrow Checker）

Rust 编译器内部有个系统：

Borrow Checker

它会分析：

・ 谁拥有数据

・ 谁在借用

・ 借用活多久

・ 有没有同时读写

・ 有没有悬垂引用

---

十、生命周期为什么存在

因为：

Rust 必须知道：

引用什么时候失效

---

比如：

let r;

{
    let s = String::from("hello");

    r = &s;
}

println!("{}", r);

Rust 报错。

因为：

s 已经销毁

但：

r 还活着

危险。

---

十一、Rust 本质上的哲学

Rust 核心思想：

"谁拥有资源，谁负责释放资源"

同时：

"任何引用都必须绝对有效"

所以：

Rust 通过：

・ Ownership（所有权）

・ Borrow（借用）

・ Lifetime（生命周期）

构建了一整套：

编译期内存安全系统

---

十二、为什么很多人觉得 Rust 难

因为：

你第一次需要：

"主动思考内存"

在：

・ Python

・ Java

・ JS

里：

GC 帮你隐藏了这些问题。

---

Rust：

要求你明确理解：

・ 数据属于谁

・ 谁在用

・ 用多久

・ 能不能修改

・ 修改会不会影响别人

---

十三、Rust 最大价值

Rust 真正革命性的地方：

不是性能。

而是：

"把大量运行时 bug 变成编译错误"

这是软件工程巨大进步。

尤其：

・ 操作系统

・ 数据库

・ AI推理引擎

・ 浏览器

・ 网络代理

・ 区块链节点

这种：

高并发 + 高性能 + 高安全

领域。

---

十四、一句话理解 Rust 借用

可以这样记：

Rust 借用 = 编译期内存访问权限管理系统

规则：

读可以共享
写必须独占
引用不能失效

这就是 Rust 安全性的核心。