Rust 一门赋予每个人构建可靠且高效软件能力的语言

Rust

一门赋予每个人构建可靠且高效软件能力的语言

Rust 程序设计语言 一门赋予每个人构建可靠且高效软件能力的语言。https://www.rust-lang.org/zh-CN/

安装

官方下载网址：

安装 Rust - Rust 程序设计语言 一门赋予每个人构建可靠且高效软件能力的语言。https://www.rust-lang.org/zh-CN/tools/install安装 Rust 需要C++生成工具的支持，Visual Studio2017+版本以上都可以。

尝试

Rust Playground 官方在线编译器A browser interface to the Rust compiler to experiment with the languagehttps://play.rust-lang.org/?version=stable&mode=debug&edition=2021

hello, world

fn main() {
    println!("hello, world");
}

创建一个后缀为 .rs 的源码文本文件 hello.rs，然后用Rust编译成一个可执行文件；也可以把源码直接粘贴到官方提供的在线编译器内执行。

为什么学习众多编程语言的第一个程序都是 hello, world ?

hello world 的起源

追溯到1972年，贝尔实验室著名研究员Brian Kernighan在撰写“B语言教程与指导(Tutorial Introduction to the Language B)”时初次使用（程序），这是目前已知最早的在计算机著作中将hello和world一起使用的记录。之后，在1978年，他在他和Dennis Ritchie合作撰写的C语言圣经“The C Programming Language”中，延用了“hello,world”句式，作为开篇第一个程序。在这个程序里，输出的”hello,world”全部是小写，没有感叹号，逗号后有一空格。虽然之后几乎没能流传下来这个最初的格式，但从此用hello world向世界打招呼成为惯例。几乎每一个程序设计语言的教材中的第一个范例都是hello world程序，因此在学习一门新语言的时候用hello world作为起步已经成为计算机程序界的一个传统。

编译

在cmd窗口下，把源码文件 hello.rs 编译，然后执行。

D:\Rust\hello>rustc hello.rs

D:\Rust\hello>hello
hello, world

链接出错

当编译发生以下报错时，说明生成工具没有安装成功

D:\Rust\hello\src>rustc main.rs
error: linker `link.exe` not found
  |
  = note: program not found

note: the msvc targets depend on the msvc linker but `link.exe` was not found

note: please ensure that Visual Studio 2017 or later, or Build Tools for Visual
Studio were installed with the Visual C++ option.

note: VS Code is a different product, and is not sufficient.

error: aborting due to previous error

执行以下2条命令进行修复

D:\Rust\hello>rustup toolchain install stable-x86_64-pc-windows-gnu

D:\Rust\hello>rustup default stable-x86_64-pc-windows-gnu

开启 Rust 之旅

官方教程

官方网站网提供了2本基础教程以及众多文档，入门零成本，基本用不上买纸质书，省钱。

《Rust 程序设计语言》

被亲切地称为“圣经”。本书从基础出发，给出了 Rust 语言的概览。您将在阅读本书的过程中构建几个项目，读完本书后，您就能扎实地掌握 Rust 语言。

https://doc.rust-lang.org/book/

《通过例子学 Rust》

如果您不喜欢阅读大量的文档来学习语言，那么此书就能涵盖您要学的知识。虽然本书花了很多篇幅来解释代码，但它展示的代码很丰富，并且尽量减少了文字解释。它还包括很多练习！

https://doc.rust-lang.org/rust-by-example/

核心文档

以下所有文档都可以用 rustup doc 命令在本地阅读，它会在您的浏览器中离线打开这些资源！

标准库

详尽的 Rust 标准库 API 手册。

版本指南

Rust 版本指南。

CARGO 手册

Rust 的包管理器和构建系统。

RUSTDOC 手册

学习如何为您的 crate 编写完美的文档。

RUSTC 手册

熟悉 Rust 编译器中可用的选项。

编译错误索引表

深入解释了您可能会遇到的编译错误。

非官方翻译教程

Rust 程序设计语言 简体中文版

1. 简介
2. 1. 入门指南
3. 1. 1.1. 安装2. 1.2. Hello, World!3. 1.3. Hello, Cargo!
4. 1. 写个猜数字游戏
5. 1. 常见编程概念
6. 1. 3.1. 变量与可变性2. 3.2. 数据类型3. 3.3. 函数4. 3.4. 注释5. 3.5. 控制流
7. 1. 认识所有权
8. 1. 4.1. 什么是所有权？2. 4.2. 引用与借用3. 4.3. Slice 类型
9. 1. 使用结构体组织相关联的数据
10. 1. 5.1. 结构体的定义和实例化2. 5.2. 结构体示例程序3. 5.3. 方法语法
11. 1. 枚举和模式匹配
12. 1. 6.1. 枚举的定义2. 6.2. match 控制流结构3. 6.3. if let 简洁控制流
13. 1. 使用包、Crate 和模块管理不断增长的项目
14. 1. 7.1. 包和 Crate2. 7.2. 定义模块来控制作用域与私有性3. 7.3. 引用模块项目的路径4. 7.4. 使用 use 关键字将路径引入作用域5. 7.5. 将模块拆分成多个文件
15. 1. 常见集合
16. 1. 8.1. 使用 Vector 储存列表2. 8.2. 使用字符串储存 UTF-8 编码的文本3. 8.3. 使用 Hash Map 储存键值对
17. 1. 错误处理
18. 1. 9.1. 用 panic! 处理不可恢复的错误2. 9.2. 用 Result 处理可恢复的错误3. 9.3. 要不要 panic!
19. 1. 泛型、Trait 和生命周期
20. 1. 10.1. 泛型数据类型2. 10.2. Trait：定义共同行为3. 10.3. 生命周期确保引用有效
21. 1. 编写自动化测试
22. 1. 11.1. 如何编写测试2. 11.2. 控制测试如何运行3. 11.3. 测试的组织结构
23. 1. 一个 I/O 项目：构建命令行程序
24. 1. 12.1. 接受命令行参数2. 12.2. 读取文件3. 12.3. 重构以改进模块化与错误处理4. 12.4. 采用测试驱动开发完善库的功能5. 12.5. 处理环境变量6. 12.6. 将错误信息输出到标准错误而不是标准输出
25. 1. Rust 中的函数式语言功能：迭代器与闭包
26. 1. 13.1. 闭包：可以捕获其环境的匿名函数2. 13.2. 使用迭代器处理元素序列3. 13.3. 改进之前的 I/O 项目4. 13.4. 性能比较：循环对迭代器
27. 1. 更多关于 Cargo 和 Crates.io 的内容
28. 1. 14.1. 采用发布配置自定义构建2. 14.2. 将 crate 发布到 Crates.io3. 14.3. Cargo 工作空间4. 14.4. 使用 cargo install 安装二进制文件5. 14.5. Cargo 自定义扩展命令
29. 1. 智能指针
30. 1. 15.1. 使用Box 指向堆上数据2. 15.2. 使用Deref Trait 将智能指针当作常规引用处理3. 15.3. 使用Drop Trait 运行清理代码4. 15.4. Rc 引用计数智能指针5. 15.5. RefCell 与内部可变性模式6. 15.6. 引用循环会导致内存泄漏
31. 1. 无畏并发
32. 1. 16.1. 使用线程同时地运行代码2. 16.2. 使用消息传递在线程间通信3. 16.3. 共享状态并发4. 16.4. 使用Sync 与 Send Traits 的可扩展并发
33. 1. Rust 的面向对象编程特性
34. 1. 17.1. 面向对象语言的特点2. 17.2. 为使用不同类型的值而设计的 trait 对象3. 17.3. 面向对象设计模式的实现
35. 1. 模式与模式匹配
36. 1. 18.1. 所有可能会用到模式的位置2. 18.2. Refutability（可反驳性）: 模式是否会匹配失效3. 18.3. 模式语法
37. 1. 高级特征
38. 1. 19.1. 不安全的 Rust2. 19.2. 高级 trait3. 19.3. 高级类型4. 19.4. 高级函数与闭包5. 19.5. 宏
39. 1. 最后的项目：构建多线程 web server
40. 1. 20.1. 建立单线程 web server2. 20.2. 将单线程 server 变为多线程 server3. 20.3. 优雅停机与清理
41. 1. 附录
42. 1. 21.1. A - 关键字2. 21.2. B - 运算符与符号3. 21.3. C - 可派生的 trait4. 21.4. D - 实用开发工具5. 21.5. E - 版本6. 21.6. F - 本书译本7. 21.7. G - Rust 是如何开发的与 “Nightly Rust”

通过例子学 Rust 中文版

1. 1. Hello World
2. 1. 1.1. 注释2. 1.2. 格式化输出3. 1. 1.2.1. 调试（debug）2. 1.2.2. 显示（display）3. 1.2.3. 测试实例：List4. 1.2.4. 格式化
3. 1. 原生类型
4. 1. 2.1. 字面量和运算符2. 2.2. 元组3. 2.3. 数组和切片
5. 1. 自定义类型
6. 1. 3.1. 结构体2. 3.2. 枚举3. 1. 3.2.1. 使用 use2. 3.2.2. C 风格用法3. 3.2.3. 测试实例：链表4. 3.3. 常量
7. 1. 变量绑定
8. 1. 4.1. 可变变量2. 4.2. 作用域和遮蔽3. 4.3. 变量先声明4. 4.4. 冻结
9. 1. 类型系统
10. 1. 5.1. 类型转换2. 5.2. 字面量3. 5.3. 类型推断4. 5.4. 别名
11. 1. 类型转换
12. 1. 6.1. From 和 Into2. 6.2. TryFrom 和 TryInto3. 6.3. ToString 和 FromStr
13. 1. 表达式
14. 1. 流程控制
15. 1. 8.1. if/else2. 8.2. loop 循环3. 1. 8.2.1. 嵌套循环和标签2. 8.2.2. 从 loop 循环返回4. 8.3. while 循环5. 8.4. for 循环和区间6. 8.5. match 匹配7. 1. 8.5.1. 解构2. 1. 8.5.1.1. 元组2. 8.5.1.2. 枚举3. 8.5.1.3. 指针和引用4. 8.5.1.4. 结构体3. 8.5.2. 卫语句4. 8.5.3. 绑定8. 8.6. if let9. 8.7. while let
16. 1. 函数
17. 1. 9.1. 方法2. 9.2. 闭包3. 1. 9.2.1. 捕获2. 9.2.2. 作为输入参数3. 9.2.3. 类型匿名4. 9.2.4. 输入函数5. 9.2.5. 作为输出参数6. 9.2.6. std 中的例子7. 1. 9.2.6.1. Iterator::any2. 9.2.6.2. Iterator::find4. 9.3. 高阶函数5. 9.4. 发散函数
18. 1. 模块
19. 1. 10.1. 可见性2. 10.2. 结构体的可见性3. 10.3. use 声明4. 10.4. super 和 self5. 10.5. 文件分层
20. 1. crate
21. 1. 11.1. 库2. 11.2. 使用库
22. 1. cargo
23. 1. 12.1. 依赖2. 12.2. 约定规范3. 12.3. 测试4. 12.4. 构建脚本
24. 1. 属性
25. 1. 13.1. 死代码 dead_code2. 13.2. crate3. 13.3. cfg4. 1. 13.3.1. 自定义条件
26. 1. 泛型
27. 1. 14.1. 函数2. 14.2. 实现3. 14.3. trait4. 14.4. 约束5. 1. 14.4.1. 测试实例：空约束6. 14.5. 多重约束7. 14.6. where 子句8. 14.7. newtype 惯用法9. 14.8. 关联项10. 1. 14.8.1. 存在问题2. 14.8.2. 关联类型11. 14.9. 虚类型参数12. 1. 14.9.1. 测试实例：单位检查
28. 1. 作用域规则
29. 1. 15.1. RAII2. 15.2. 所有权和移动3. 1. 15.2.1. 可变性2. 15.2.2. 部分移动4. 15.3. 借用5. 1. 15.3.1. 可变性2. 15.3.2. 别名使用3. 15.3.3. ref 模式6. 15.4. 生命周期7. 1. 15.4.1. 显式标注2. 15.4.2. 函数3. 15.4.3. 方法4. 15.4.4. 结构体5. 15.4.5. trait6. 15.4.6. 约束7. 15.4.7. 强制转换8. 15.4.8. static9. 15.4.9. 省略
30. 1. 特质 trait
31. 1. 16.1. 派生2. 16.2. 使用 dyn 返回 trait3. 16.3. 运算符重载4. 16.4. Drop5. 16.5. Iterator6. 16.6. impl Trait7. 16.7. Clone8. 16.8. 父 trait9. 16.9. 消除重叠 trait
32. 1. 使用 macro_rules! 来创建宏
33. 1. 17.1. 语法2. 1. 17.1.1. 指示符2. 17.1.2. 重载3. 17.1.3. 重复3. 17.2. DRY (不写重复代码)4. 17.3. DSL (领域专用语言)5. 17.4. 可变参数接口
34. 1. 错误处理
35. 1. 18.1. panic2. 18.2. Option 和 unwrap3. 1. 18.2.1. 使用 ? 解开 Option2. 18.2.2. 组合算子：map3. 18.2.3. 组合算子：and_then4. 18.3. 结果 Result5. 1. 18.3.1. Result 的 map2. 18.3.2. 给 Result 取别名3. 18.3.3. 提前返回4. 18.3.4. 引入 ?6. 18.4. 处理多种错误类型7. 1. 18.4.1. 从 Option 中取出 Result2. 18.4.2. 定义一种错误类型3. 18.4.3. 把错误 “装箱”4. 18.4.4. ? 的其他用法5. 18.4.5. 包裹错误8. 18.5. 遍历 Result
36. 1. 标准库类型
37. 1. 19.1. 箱子、栈和堆2. 19.2. 动态数组 vector3. 19.3. 字符串 String4. 19.4. 选项 Option5. 19.5. 结果 Result6. 1. 19.5.1. ? 用法7. 19.6. panic!8. 19.7. 散列表 HashMap9. 1. 19.7.1. 更改或自定义关键字类型2. 19.7.2. 散列集 HashSet10. 19.8. 引用计数 Rc11. 19.9. 共享引用计数 Arc
38. 1. 标准库更多介绍
39. 1. 20.1. 线程2. 1. 20.1.1. 测试实例：map-reduce3. 20.2. 通道4. 20.3. 路径5. 20.4. 文件输入输出（I/O）6. 1. 20.4.1. 打开文件 open2. 20.4.2. 创建文件 create3. 20.4.3. 读取行 read lines7. 20.5. 子进程8. 1. 20.5.1. 管道2. 20.5.2. 等待9. 20.6. 文件系统操作10. 20.7. 程序参数11. 1. 20.7.1. 参数解析12. 20.8. 外部语言函数接口
40. 1. 测试
41. 1. 21.1. 单元测试2. 21.2. 文档测试3. 21.3. 集成测试4. 21.4. 开发依赖
42. 1. 不安全操作
43. 1. 兼容性
44. 1. 23.1. 原始标志符
45. 1. 补充
46. 1. 24.1. 文档2. 24.2. Playpen

有编程基础的大概浏览一遍，很快就能上手了

语法基础

变量和数据类型

在 Rust 中，变量可以通过

let

关键字进行声明和初始化。例如：

let x = 5;
let y: i32 = 10;

第一行代码定义了一个名为

x

的变量，其类型为 Rust 推断得到的整数类型。第二行代码定义了一个名为

y

的变量，并明确指定其类型为

i32

整数类型。

Rust 中的数据类型包括数字、字符、布尔值、字符串等。其中，数字类型包括整数和浮点数，可以用

i8

、

i16

、

i32

、

i64

、

u8

、

u16

、

u32

、

u64

、

f32

、

f64

等类型进行声明。而布尔值则用

bool

表示，取值为

true

或

false

。字符类型用

char

表示，由单引号包围，例如：

let c = 'C';

字符串类型用双引号包围，可以是非 ASCII 字符串，例如：

let s = "Hello, 世界!";

注意：**

let mut

** 变量赋值

let

和

let mut

声明变量时的区别在于后者声明的变量可变，而前者声明的变量为不可变。

let

声明的变量不能再次被赋值，而

let mut

声明的变量可以被修改赋值。

复合数据结构

元组 (Tuple)

元组是将多个不同类型的值组合在一起形成一个新的复合类型。元组使用圆括号

()

来定义，元素之间使用逗号

,

隔开。元组可以通过模式匹配来解构。例如：

let person: (String, usize, f64) = (String::from("Alice"), 30, 6.0);

println!("{} is {} years old and {} feet tall.", person.0, person.1, person.2);

数组 (Array)

数组是由同一类元素组成的数据集合。数组的长度在编译时就已经确定，不可改变。数组使用中括号

[]

来定义。例如：

let numbers: [i32; 5] = [1, 2, 3, 4, 5];

println!("The third element is {}.", numbers[2]);

向量 (Vector)

向量是一种动态数组类型，可以在运行时动态地增加或减少其大小。Vector 可以存储任意类型的数据，并且支持快速随机访问元素、在末尾追加元素、在任意位置插入和删除元素等操作。Vector 使用 Vec 类型来创建，例如：

let mut numbers: Vec<i32> = vec![1, 2, 3, 4, 5];

// 访问某个元素
println!("The third element is {}.", numbers[2]);

// 在末尾追加元素
numbers.push(6);

// 插入元素到特定位置
numbers.insert(3, 10);

// 删除特定位置的元素
numbers.remove(2);

// 遍历所有元素
for num in &numbers {
    println!("{}", num);
}

集合 (Set)

集合类型存储一组唯一的、无序的元素。Set 具有高效地判定元素是否存在的功能，但是不支持对元素的随机访问和插入。Set 使用 HashSet 类型来创建，例如：

use std::collections::HashSet;

let mut colors = HashSet::new();

// 插入元素
colors.insert(String::from("red"));
colors.insert(String::from("green"));
colors.insert(String::from("blue"));

// 判断元素是否存在
if colors.contains("red") {
    println!("The set contains red.");
}

// 删除元素
colors.remove("green");

// 遍历所有元素
for color in &colors {
    println!("{}", color);
}

结构体 (Struct)

结构体是一种自定义类型，可以包含不同类型的字段。通过在结构体中定义多个字段，可以将它们组合成一个单独的数据类型。结构体使用

struct

关键字来定义，字段可以是不同的类型，并且也可以包含其他的结构体。例如：

struct Person {
    name: String,
    age: usize,
    height: f64,
}

let alice = Person {
    name: String::from("Alice"),
    age: 30,
    height: 6.0,
};

println!("{} is {} years old and {} feet tall.", alice.name, alice.age, alice.height);

关键字

as          const       else        enum        extern      
false       fn          for         if          impl        
in          let         loop        match       mod         
move        mut         pub         ref         return      
Self        self        static      struct      super       
trait       true        type        unsafe      use         
where       while       abstract    become      box         
do          final       macro       override    priv        
typeof      unsized     virtual     yield

这些关键字具有不同的含义和用法，例如：

• fn: 声明一个函数
• let: 声明一个变量
• if、else、for、while 等: 分别表示条件语句、循环语句
• match: 匹配表达式的值与模式
• mod、use: 分别表示模块声明与模块引用
• struct、enum、trait、impl 等: 分别表示结构体、枚举类型、特质、实现等

在 Rust 中，使用这些关键字需要注意避免与现有标识符冲突。如果需要使用与关键字同名的标识符，则可以使用反引号 将标识符括起来，例如：

let `match` = 3;
println!("the value of match is {}", `match`);

以上代码中，用反引号括起来的

match

可以作为变量名使用，但是不推荐这么做，因为会让代码不够清晰。

控制语句

Rust 支持常见的控制流语句，包括条件语句、循环语句和匹配语句等。

条件语句

用

if

和

else

关键字表示，例如：

let x = 10;
if x < 0 {
    println!("x is negative");
} else if x > 0 {
    println!("x is positive");
} else {
    println!("x is zero");
}

循环语句

用

loop

、

while

和

for

关键字表示，例如：

let mut x = 0;
loop {
    x += 1;
    if x == 10 {
        break;
    }
}
println!("x is {}", x);

let mut y = 0;
while y < 10 {
    y += 1;
}
println!("y is {}", y);

let a = [1, 2, 3, 4, 5];
for element in a.iter() {
    println!("element is {}", element);
}

匹配语句

用

match

关键字表示，可以根据不同的值匹配执行不同的代码块。例如：

let x = 5;
match x {
    1 => println!("x is one"),
    2 | 3 | 4 => println!("x is two or three or four"),
    // 匹配任何其他数字 
    _ => println!("x is {}", x),
}

函数

Rust 中的函数可以通过

fn

关键字进行定义，例如：

fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let a = add(1, 2);
    let b = add(2, 3);
    println!("{}\n{}", a, b);
}

该函数接受两个

i32

参数

x

和

y

，返回它们的和。

函数的最后一个表达式被视为返回值，这与其它大多数语言不同：可以省去 return 关键字。

Rust 支持函数的默认参数和可变参数，例如：

fn mul(x: i32, y: i32, z: i32) -> i32 {
    return x * y * z
}

fn div(x: f32, y: f32) -> f32 {
    if y == 0.0 {
        panic!("division by zero");
    }
    return x / y
}

fn print(words: &str, times: i32) {
    for _ in 0..times {
        println!("{}", words);
    }
}

fn main() {
    let a = mul(1, 2, 3);
    let b = div(10.0, 3.0);
    let c = "hello";
    println!("{}\n{}", a, b);
    print(c, 3);
}

Rust 也支持泛型类型参数，例如：

fn add<T: std::ops::Add<Output=T>>(x: T, y: T) -> T {
    x + y
}

fn foo<T>(x: T) -> T {
    x
}

fn main() {
    let a = add(1, 2);
    let b = add(2.0, 3.0);
    println!("{}\n{}\n", a, b);

    let a = foo(1); // a 为整数类型
    let b = foo("hello"); // b 是字符串类型
    let c = foo(vec![1, 2, 3]); // c 是一个整数向量类型
    println!("{}\n{}\n{:?}", a, b, c);
}

模块

模块是 Rust 中的一种隔离和组织代码的方式，其可以分为本地模块和外部模块。本地模块用

mod

关键字表示，用于组织和封装代码，例如：

mod math {
    fn add(x: i32, y: i32) -> i32 {
        x + y
    }

    pub fn sub(x: i32, y: i32) -> i32 {
        x - y
    }
}

该代码中，定义了一个

math

模块和其中的两个函数

add

和

sub

。其中，函数

add

是私有的，只能在模块内部使用，而函数

sub

是公有的，可以在其他模块中使用。

除了本地模块之外，Rust 还支持使用

extern crate

加载外部依赖库，并通过

use

关键字引用其模块、类型和函数等。例如：

extern crate rand;

use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    let n: i32 = rng.gen_range(1, 7);
    println!("the random number is: {}", n);
}

以上就是 Rust 语言的基础语法介绍，包括变量和数据类型、控制流、函数和模块等内容。Rust 相比于其他语言，具有更加严格的类型检查和所有权规则等特性，可以保证代码的内存安全和高效运行。

代码实例

1. 两数之和

use std::collections::HashMap;

fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    let mut map = HashMap::new();
    for (i, &num) in nums.iter().enumerate() {
        if let Some(&j) = map.get(&(target - num)) {
            return vec![j as i32, i as i32];
        }
        map.insert(num, i);
    }
    vec![]
}

fn main() {
    let nums = vec![2, 7, 11, 15];
    let target = 9;
    let result = two_sum(nums, target);
    println!("{:?}", result);  // 输出 [0, 1]
}

2. 最长子串

pub fn length_of_longest_substring(s: String) -> i32 {
    let mut chars = s.chars();
    let mut map = std::collections::HashMap::new();
    let mut max_length = 0;
    let mut start = 0;
    let mut end = 0;
    while let Some(c) = chars.next() {
        if let Some(index) = map.get(&c) {
            start = start.max(*index + 1);
        }
        end += 1;
        map.insert(c, end - 1);
        max_length = max_length.max(end - start);
    }
    max_length as i32
}

fn main() {
    let s = String::from("abcabcbb");
    let result = length_of_longest_substring(s);
    println!("{}", result);
    let s = String::from("bbbbb");
    let result = length_of_longest_substring(s);
    println!("{}", result);
    let s = String::from("pwwkew");
    let result = length_of_longest_substring(s);
    println!("{}", result);
}

3. 反转整数

pub fn reverse(x: i32) -> i32 {
    let mut x = x;
    let mut res = 0;
    while x != 0 {
        let pop = x % 10;
        x /= 10;
        if res > std::i32::MAX / 10 || (res == std::i32::MAX / 10 && pop > 7) {
            return 0;
        }
        if res < std::i32::MIN / 10 || (res == std::i32::MIN / 10 && pop < -8) {
            return 0;
        }
        res = res * 10 + pop;
    }
    res
}

fn main() {
    let x = 123;
    println!("{}", reverse(x));
    let x = -123;
    println!("{}", reverse(x));
    let x = 120;
    println!("{}", reverse(x));
}

2023.5.3