Rust 初体验
安装
打开官网，下载 rustup-init.exe， 选择缺省模式（1）安装。
国内源设置
在 .Cargo 目录下新建 config 文件，添加如下内容：
[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
# 指定镜像
replace-with = 'tuna'
# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"
[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"
[net]
git-fetch-with-cli = true
第一个程序
使用任意代码编辑器，编写如下代码，保存为后缀是.rs的源文件，如 hello.rs。
fn main()
{
println!("Hello World!");
}
了解C语言的同学，会发现这个程序和C语言的hello.c非常相似。不同之处在于，fn 表示函数，main 表示程序的入口，println! 表示输出。! 表示宏，即 println 是个宏，而不是函数。
在源文件文件夹里，运行 rustc hello.rs 进行编译，生成 hello.exe。
运行 hello.exe，输出：
Hello World!
使用 Cargo 管理
cargo new project_name 创建一个新项目
cd project_name 进入项目
cargo build 编译生成Debug版本
cargo build --release 编译并生成可执行文件
cargo run 运行
cargo check 检查错误(不编译)
cargo 常用命令
build, b Compile the current package
check, c Analyze the current package and report errors, but don't build object files
clean Remove the target directory
doc, d Build this package's and its dependencies' documentation
new Create a new cargo package
init Create a new cargo package in an existing directory
add Add dependencies to a manifest file
remove Remove dependencies from a manifest file
run, r Run a binary or example of the local package
test, t Run the tests
bench Run the benchmarks
update Update dependencies listed in Cargo.lock
search Search registry for crates
publish Package and upload this package to the registry
install Install a Rust binary. Default location is $HOME/.cargo/bin
uninstall Uninstall a Rust binary
变量
Rust 是强类型语言，使用关键字 let 声明变量后，具有自动判断变量类型的能力，如：
let a = 123; 则默认 a 为整型数字，且精度不允许变化，即 a 的值不可改变，可以理解为“只读”。
这与 C 语言中的 const 修饰符起到的效果一样。在 C 语言中 int const a = 10; a 的值也不允许改变。
Rust 中如果要让变量可变，需要用 mut 关键词：
let mut a = 123;
a = 456;
指定数据类型
let a: u64 = 123; // 后面跟数据类型u64，表示无符号64位整型变量。
let y: f32 = 3.0; // 后面跟数据类型f32，表示32位浮点型变量。
Shadowing（影射）
变量名可以被重新使用，如：
let x = 5;
let x = x + 1;
let x = x * 2;
最终 x 的值为12。从语法上说， 变量 x 可以作为右值。
注释
可以使用 C/C++, Java 注释。
另外，可用 /// 表示文档开头注释
函数
定义函数，如需要参数，必须声明参数名称、类型。
fn another_function(x: i32, y: i32) { }
可在{}包括的块里，编写较为复杂的表达式，即所谓的函数体表达式。注：函数体表达式，并不能等同于函数体，不能使用 return 关键字。
let y = {
let x = 3;
x + 1
};
返回值类型声明
在参数声明之后用->来声明函数返回值的类型。 注：Rust 不支持自动返回值类型判断。
fn add(a: i32, b: i32) -> i32 {
return a + b;
}
条件语句
if a > 0 {
b = 1;
}
else if a < 0 {
b = -1;
}
else {
b = 0;
}
println!("b is {}", b);
if 后面不需要小括号，{} 必用。右括号 } 后不加 ；。
条件表达式必须是 bool 类型，不同于 C/C++ 的非 0 即真。
可以使用 if-else 结构实现类似于三元条件运算表达式 (A ? B : C) 。如：
let number = if a > 0 { 1 } else { -1 };
注：此处编译报错，检测出来其中 0 为 i32，代码未指定数据类型。故将0改为&0：
let number = if a > &0 { 1 } else { -1 };
for 循环
最常用的循环结构。
let a = [10, 20, 30, 40, 50];
for i in a.iter() {
println!("值为 : {}", i);
}
a.iter() 代表 a 的迭代器（iterator）
也可以通过下标来访问数组。如：
let a = [10, 20, 30, 40, 50];
for i in 0..5 {
println!("a[{}] = {}", i, a[i]);
}
以上代码会报错。正确写法是：
const a: [i32; 5] = [10, 20, 30, 40, 50];
for i in 0..5 {
println!("a[{}] = {}", i, a[i]);
}
可见，代码检查更严格。
while 循环
let mut number = 1; // mut 表示number 在循环体内可以改变。
while number != 4 {
println!("{}", number);
number += 1;
}
无限循环结构 loop
可以通过 break 关键字，起到类似 return 一样的作用，使整个循环退出并给予外部一个返回值。
let mut i = 0;
let location = loop {
let ch = s[i];
if ch == '*' {
break i;
}
i += 1;
};
以上代码会报错，可以改为：
fn main() {
let s = "hello world";
let mut i = 0;
let location = loop {
let ch = s.chars().nth(i).unwrap();
if ch == ' ' {
break i;
}
i += 1;
};
println!("{}", location);
}
变量与数据交互
方式有移动（Move）和克隆（Clone）两种，前者不保存移动前的变量，后者继续保留移动前的变量。
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1); // 错误！s1 已经失效
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2); //ok
引用（Reference）
& 运算符可以取变量的"引用"。当一个变量的值被引用时，变量本身不会被认定无效。注：C++中的概念。
引用不会获得值的所有权。引用只能租借（Borrow）值的所有权。
引用本身也是一个类型并具有一个值，这个值记录的是别的值所在的位置，但引用不具有所指值的所有权。
&mut 修饰可变的引用类型。
可变引用不允许多重引用，但不可变引用可以。
以上机制设计，主要出于对并发状态下发生数据访问碰撞的考虑，使得编译阶段就避免发生。
垂悬引用（Dangling References）
Rust 语言里不允许出现，如果有，编译器会发现它。
更多内容参看: https://www.runoob.com/rust/rust-ownership.html
字符串切片（String Slice）
let s = String::from("broadcast");
let part1 = &s[0..5];
let part2 = &s[5..9];
println!("{}={}+{}", s, part1, part2);
在 Rust 中有两种常用的字符串类型：str 和 String。
str 是 Rust 核心语言类型，凡用双引号包括的字符串常量整体的类型性质都是 &str。
String 类型是 Rust 标准公共库提供的一种数据类型，其功能更完善。String 和 str 都支持切片，切片的结果是 &str 类型的数据。
注：切片结果必须是引用类型，但开发者必须明示:
let slice = &s[0..3];
除了字符串，其他一些线性数据结构也支持切片操作，如：
let arr = [1, 3, 5, 7, 9];
let part = &arr[0..3];
for i in part.iter() {
println!("{}", i);
}
结构体
定义结构体：
struct Site {
domain: String,
name: String,
nation: String,
found: u32
}
注：Rust 里 struct 语句仅用来定义，不能声明实例，结尾不需要; 符号，且每个字段定义之后用 , 分隔。
Rust 很多地方受 JavaScript 影响，在实例化结构体的时候用 JSON 对象的 key: value 语法来实现定义：
let runoob = Site {
domain: String::from("www.runoob.com"),
name: String::from("RUNOOB"),
nation: String::from("China"),
found: 2013
};
如果正在实例化的结构体，有字段名称与现存变量名称一样，可以简化书写。
let domain = String::from("www.runoob.com");
let name = String::from("RUNOOB");
let runoob = Site {
domain, // 等同于 domain : domain,
name, // 等同于 name : name,
nation: String::from("China"),
traffic: 2013
};
新建一个结构体实例，如果其中大部分属性需要被设置成与现存的一个结构体属性一样，仅需更改其中一两个字段的值，可以使用结构体更新语法：
let site = Site {
domain: String::from("www.runoob.com"),
name: String::from("RUNOOB"),
..runoob
};
注：…runoob 后面不可以有逗号。这种语法不允许一成不变的复制另一个结构体实例，至少重新设定一个字段的值才能引用其他实例的值。
元组结构体
struct Color(u8, u8, u8);
struct Point(f64, f64);
let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);
元组结构体对象的使用方式和元组一样，通过 . 和下标来进行访问：
struct Color(u8, u8, u8);
struct Point(f64, f64);
let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);
println!("black = ({}, {}, {})", black.0, black.1, lack.2);
println!("origin = ({}, {})", origin.0, origin.1);
结构体必须掌握字段值所有权，因为结构体失效的时候会释放所有字段。
结构体输出
导入调试库 #[derive(Debug)]
在 println 和 print 宏中可以用 {:?} 占位符输出一整个结构体；结构体如果属性较多，可使用另一个占位符 {:#?} 。
结构体方法
结构体方法的第一个参数必须是 &self，不需声明类型。
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect1 = Rectangle { width: 30, height: 50 };
println!("rect1's area is {}", rect1.area());
}
这里与Python中的Class方法有神似。
结构体关联函数
不依赖实例，使用时需要声明是在哪个 impl 块中的。String::from函数就是一个"关联函数"。
# [derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn create(width: u32, height: u32) -> Rectangle {
Rectangle { width, height }
}
}
fn main() {
let rect = Rectangle::create(30, 50);
println!("{:?}", rect);
}
这里的Rectangle中的create函数，即是结构体关联函数。这个概念与 C++语言里面的类成员函数有些相似。不同之处在于， C++ 类成员函数是在类的内部定义，并且使用 this 指针来访问类的实例。
单元结构体
结构体可以只作为一种象征而无需任何成员：
struct UnitStruct;
枚举类
# [derive(Debug)]
enum Book {
Papery, Electronic
}
fn main() {
let book = Book::Papery;
println!("{:?}", book);
}
为枚举类成员添加元组属性描述
enum Book {
Papery(u32),
Electronic(String),
}
let book = Book::Papery(1001);
let ebook = Book::Electronic(String::from("url://..."));
为属性命名，可以用结构体语法：
enum Book {
Papery { index: u32 },
Electronic { url: String },
}
let book = Book::Papery{index: 1001};
match 语法
枚举的目的是对某一类事物的分类，分类的目的是为了对不同的情况进行描述。Rust 通过 match 语句来实现分支结构。
fn main() {
enum Book {
Papery {index: u32},
Electronic {url: String},
}
let book = Book::Papery{index: 1001};
let ebook = Book::Electronic{url: String::from("url...")};
match book {
Book::Papery { index } => {
println!("Papery book {}", index);
},
Book::Electronic { url } => {
println!("E-book {}", url);
}
}
}
注意其中的，号与；号。
match 枚举类实例 {
分类1 => 返回值表达式,
分类2 => 返回值表达式,
...
}
对非枚举类进行分支选择时必须注意处理例外情况，即使在例外情况下没有任何要做的事 . 例外情况用下划线 _ 表示：
fn main() {
let t = "abc";
match t {
"abc" => println!("Yes"),
_ => {},
}
}
Option 枚举类
Rust 标准库中的枚举类，用于填补 Rust 不支持 null 引用的空白。Rust 在语言层面彻底不允许空值 null 的存在，但null 可以高效地解决少量的问题，所以 Rust 引入了 Option 枚举类：
enum Option<T> {
Some(T),
None,
}
如果想定义一个可以为空值的类，可以这样：
let opt = Option::Some("Hello");
如果想针对 opt 执行某些操作，必须先判断它是否是 Option::None：
fn main() {
let opt = Option::Some("Hello");
match opt {
Option::Some(something) => {
println!("{}", something);
},
Option::None => {
println!("opt is nothing");
}
}
}
初始值为空的 Option 必须明确类型：
fn main() {
let opt: Option<&str> = Option::None;
match opt {
Option::Some(something) => {
println!("{}", something);
},
Option::None => {
println!("opt is nothing");
}
}
}
这种设计会让空值编程变得不容易，但这正是构建一个稳定高效的系统所需要的。由于 Option 是 Rust 编译器默认引入的，在使用时可以省略 Option:: 直接写 None 或者 Some()。
fn main() {
let t = Some(64);
match t {
Some(64) => println!("Yes"),
_ => println!("No"),
}
}
又：
let i = 0;
match i {
0 => println!("zero"),
_ => {},
}
用 if let 语法缩短这段代码：
let i = 0;
if let 0 = i {
println!("zero");
}
如：
fn main() {
enum Book {
Papery(u32),
Electronic(String)
}
let book = Book::Electronic(String::from("url"));
if let Book::Papery(index) = book {
println!("Papery {}", index);
} else {
println!("Not papery book");
}
}
注意其中 if 语句后的 = 号。
组织管理
Rust 中有三个重要的组织概念：箱、包、模块。
箱（Crate）
"箱"是二进制程序文件或者库文件，存在于"包"中。树状结构，树根是编译器开始运行时编译的源文件所编译的程序。
注意：“二进制程序文件"不一定是"二进制可执行文件”，只能确定是是包含目标机器语言的文件，文件格式随编译环境的不同而不同。
包（Package）
当使用 Cargo 执行 new 命令创建 Rust 工程时，工程目录下会建立一个 Cargo.toml 文件。工程的实质就是一个包，包必须由一个 Cargo.toml 文件来管理，该文件描述了包的基本信息以及依赖项。
一个包最多包含一个库"箱"，可以包含任意数量的二进制"箱"，但是至少包含一个"箱"（不管是库还是二进制"箱"）。
当使用 cargo new 命令创建完包之后，src 目录下会生成一个 main.rs 源文件，Cargo 默认这个文件为二进制箱的根，编译之后的二进制箱将与包名相同。
模块（Module）
对于一个软件工程来说，往往按照所使用的编程语言的组织规范来进行组织，组织模块的主要结构往往是树。Java 组织功能模块的主要单位是类，而 JavaScript 组织模块的主要方式是 function。Rust 中的组织单位是模块（Module）。
这些先进的语言的组织单位可以层层包含，就像文件系统的目录结构一样。Rust 中的组织单位是模块（Module）。
路径分为绝对路径和相对路径。绝对路径从 crate 关键字开始描述。相对路径从 self 或 super 关键字或一个标识符开始描述。Rust 中的路径分隔符是 ::。如：
crate::nation::government::govern();
是描述 govern 函数的绝对路径，相对路径可以表示为：
nation::government::govern();
访问权限
Rust 中有两种简单的访问权：公共（public）和私有（private）。
默认情况下，如果不加修饰符，模块中的成员访问权将是私有的。
如果想使用公共权限，需要使用 pub 关键字。
对于私有的模块，只有在与其平级的位置或下级的位置才能访问，不能从其外部访问。
mod nation {
pub mod government {
pub fn govern() {}
}
mod congress {
pub fn legislate() {}
}
mod court {
fn judicial() {
super::congress::legislate();
}
}
}
fn main() {
nation::government::govern();
}
这段程序是能通过编译的。请注意观察 court 模块中 super 的访问方法。更多的信息请参考：
https://www.runoob.com/rust/rust-project-management.html
use 关键字能够将模块标识符引入当前作用域
mod nation {
pub mod government {
pub fn govern() {}
}
}
use crate::nation::government::govern; // 解决局部模块路径过长的问题。
fn main() {
govern();
}
重命名
mod nation {
pub mod government {
pub fn govern() {}
}
pub fn govern() {}
}
use crate::nation::government::govern;
use crate::nation::govern as nation_govern; // 解决重名问题
fn main() {
nation_govern();
govern();
}
还可以与 pub 关键字配合使用：
mod nation {
pub mod government {
pub fn govern() {}
}
pub use government::govern;
}
fn main() {
nation::govern();
}
所有系统库模块都是被默认导入的，所以在使用的时候只需要使用 use 关键字简化路径即可使用。
在 Rust 中没有 Exception。对可恢复错误用 Result<T, E> 类来处理，对不可恢复错误使用 panic! 宏来处理。
不可恢复错误
fn main() {
panic!("error occured"); // 程序将在此处中断，不执行后续语句
println!("Hello, Rust");
}
回溯是不可恢复错误的另一种处理方式，它会展开运行的栈并输出所有的信息，然后程序依然会退出。上面的省略号省略了大量的输出信息，我们可以找到我们编写的 panic! 宏触发的错误。
可恢复的错误
Rust 通过 Result<T, E> 枚举类作返回值来进行异常表达。
use std::fs::File;
fn main() {
let f = File::open("hello.txt");
match f {
Ok(file) => {
println!("File opened successfully.");
},
Err(err) => {
println!("Failed to open the file.");
}
}
}
可用 if let 语法对简化 match 语法块：
use std::fs::File;
fn main() {
let f = File::open("hello.txt");
if let Ok(file) = f {
println!("File opened successfully.");
} else {
println!("Failed to open the file.");
}
}
Rust 中可以在 Result 对象后添加 ? 操作符将同类的 Err 直接传递出去.
fn f(i: i32) -> Result<i32, bool> {
if i >= 0 { Ok(i) }
else { Err(false) }
}
fn g(i: i32) -> Result<i32, bool> {
let t = f(i)?;
Ok(t) // 因为确定 t 不是 Err, t 在这里已经是 i32 类型
}
fn main() {
let r = g(10000);
if let Ok(v) = r {
println!("Ok: g(10000) = {}", v);
} else {
println!("Err");
}
}
? 符的实际作用是将 Result 类非异常的值直接取出，如果有异常就将异常 Result 返回出去。所以，? 符仅用于返回值类型为 Result<T, E> 的函数，其中 E 类型必须和 ? 所处理的 Result 的 E 类型一致。
判断 Result 的 Err 类型，用函数 kind()。
use std::io;
use std::io::Read;
use std::fs::File;
fn read_text_from_file(path: &str) -> Result<String, io::Error> {
let mut f = File::open(path)?;
let mut s = String::new();
f.read_to_string(&mut s)?;
Ok(s)
}
fn main() {
let str_file = read_text_from_file("hello.txt");
match str_file {
Ok(s) => println!("{}", s),
Err(e) => {
match e.kind() {
io::ErrorKind::NotFound => {
println!("No such file");
},
_ => {
println!("Cannot read the file");
}
}
}
}
}
427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
