2866 字
14 分钟
Rust学习笔记 1 - Basic Concepts
WARNING

不要把这个blog当作教程来看,这个blog对我来说只是一个方便回顾的quick reference,里面不会包含完整的代码。

如果要教程或源码的话去官方Rust Book网站获取:The Rust Programming Language

Installation#

本人环境Arch Linux:sudo pacman -S rustup

这个机器上已经有rust了,rust和rustup包冲突,选择rustup

安装完rustup之后,使用rustup安装rust最新版:

Terminal window
$ RUSTUP_DIST_SERVER=https://mirrors.tuna.tsinghua.edu.cn/rustup rustup install stable # 使用tuna镜像

编辑shell配置文件.zshrc,以便日后使用tuna镜像更新rust:

Terminal window
# Rust Mirror
# https://mirrors.tuna.tsinghua.edu.cn/help/rustup/
export RUSTUP_UPDATE_ROOT=https://mirrors.tuna.tsinghua.edu.cn/rustup/rustup
export RUSTUP_DIST_SERVER=https://mirrors.tuna.tsinghua.edu.cn/rustup

编辑~/.cargo/config.toml,配置镜像:

[source.crates-io]
replace-with = 'mirror'
[source.mirror]
registry = "sparse+https://mirrors.tuna.tsinghua.edu.cn/crates.io-index/"
[registries.mirror]
index = "sparse+https://mirrors.tuna.tsinghua.edu.cn/crates.io-index/"

下载EPUB版中文Rust Book:

Terminal window
$ git clone git@github.com:KaiserY/trpl-zh-cn.git
$ cd trpl-zh-cn
$ cargo run --release --manifest-path epub-builder/Cargo.toml

这样我一般学习的话就看生成的rust_programming_language.epub来学习,遇到一些术语之类的单词再回头去翻英文原版。

如果为了完全离线使用这本书,建议下载这本书所需的一些依赖:

Terminal window
$ cargo new get-dependencies
$ cd get-dependencies
$ cargo add rand@0.8.5 trpl@0.2.0

建一个空项目,并缓存这些包,日后要在其他项目中使用的时候就不需要重复下载了。

Hello Rust#

我新建了一个叫learn-rust的目录,专门存放学习rust时产生的各种文件:mkdir ~/Documents/learn-rust

Hello World#

在learn-rust目录中:

Terminal window
$ mkdir hello_world
$ cd hello_world

rust文件一般用snake_case命名。

新建源码文件:

Terminal window
$ vim main.rs

输入代码:

main.rs
fn main() {
println!("Hello, world!");
}

保存文件后,编译并运行程序:

Terminal window
$ rustc main.rs
$ ./main
Hello, world!

  • rust代码中的表达式用;分割(绝大多情况下用;结尾)
  • rust代码的入口在main()函数中

Hello Cargo#

Cargo是rust官方推的出、所谓的“一站式”管理器,可以用来构建系统和管理依赖。

确认是否安装Cargo:cargo --version

回到learn-rust目录:

Terminal window
$ cargo new hello_cargo
$ cd hello_cargo

在hello_cargo项目中:

.
├── Cargo.lock # 用来储存依赖状态
├── Cargo.toml # 用于储存项目配置
├── src/ # 存放源码的
└── target/ # 用于存放cargo生成的一些文件

Cargo默认将代码放在src目录中,并且以main.rs作为入口文件。

使用Cargo编译可执行文件:在项目根目录下执行cargo build

或者说可以直接使用cargo run来运行编译后的文件(如果没有最新版的编译文件的话则会先进行编译),一般情况下用cargo run能覆盖绝大多数情况了。

如果要检查语法而不是编译文件的话,可以使用cargo check。这个命令个人认为也很常用。

当要发布文件时,请使用cargo build --release来编译文件。--release选项会在编译时优化程序,让最后生成的程序在运行时效率更高,但代价是更长的编译时间。

Quick Glance into Rust: Guessing Game Demo#

新建项目:

Terminal window
$ cargo new guessing_game
$ cd guessing_game

编辑Cargo.toml,添加依赖:

[package]
name = "guessing_game"
version = "0.1.0"
edition = "2024"
[dependencies]
rand = "0.9.3" # 用于生成随机数

编辑src/main.rs中的代码:

引入external libraries:

use std::cmp::Ordering; // 用于比较数字大小
use std::io; // use standard io library,用于处理标准输入
use rand::Rng; // 用于生成随机数

生成随机数,并储存进变量中:

fn main () {
// ...
let secret_number = rand::rng().random_range(1..=100);
// ...
}

在rust中,变量默认不可变,而rust中也有常量这一个改变,这区别在于:

  • 常量:在编译时可以确定具体的值是什么,例如一个数字或一个字符串字面量
  • 不可变变量:在变量创建之后不可以更改里面的值

获取用户输入:

println!("Please input your guess:");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");

let mut guess = String::new();会创建一个可变的guess变量,由于现在只能知道这个变量的类型是String,具体是什么值并不清楚,作用使用String::new()新建一个空的String对象。

这两句是等价的(目前看来):

let mut guess = String::new();
let mut guess = String::from("");

读取用户输入并存进guess变量中:

io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");

在Rust中经常使用chain call来实现逻辑,这样比使用一堆相互嵌套的functions要简洁得多。&mut guess将guess这个可变变量的内存地址传给read_line(),read_line()会把用户的输入存进这个地址中(也就是存进这个变量),expect()则是用来处理错误时的报错信息。

尝试将用户的输入转换成u32类型(占4个byte的无符号int):

let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};

guess.trim()会移除收尾的空格,parse()会接着尝试将处理完空格的字符串转换成u32格式。

  • 如果转换成功,则返回Ok(num),num是处理后的数字
  • 当发生错误时返回Err(),里面的是发生的错误的报错信息。通配符_会匹配所有类型的信息,由于以上这段代码在一个loop中运行,所以continue相当于跳过这次输入,直接进入下一个iteration的开始。

比较数字:

match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}

调用cmp()比较数字,传入secret_number的内存地址(也就是&secrete_number),返回一个Ordering(enum对象)的值。并用match语句处理这些结果。

Common Programming Concepts#

定义并使用常量:

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
println!("3 hours = {THREE_HOURS_IN_SECONDS} seconds");

定义和使用变量:

let mut x = 5;
println!("The vaule of x is {x}");
{
let x = x * 2; // Declare x again in inner scope, it will not affect the outer scope
println!("The value of x in inner scope is {x}");
}
x = x + 1;
println!("The vaule of x is {x}");

在上面{}中定义的x不会影响到外部x的值,内部x的scope只在{}内。

重复定义一个变量被称为shadowing,shadowing允许用同一个变量名处理同系列不同类型的数据。

let spaces = " ";
let spaces = spaces.len();
println!("There are {spaces} spaces");

Numbers#

Integer的类型:

lengthhas symbolno symbol
8-biti8u8
16-biti16u16
32-biti32u32
64-biti64u64
128-biti128u128
arch-depisizeusize

Symboled integer uses two’s complement to represent

数字字面值例子
Decimal(十进制)98_222
Hex(十六进制)0xff
Octal(八进制)0o77
Binary(二进制)0b1111_0000
Byte(字节字面值,仅限 u8)b'A'
println!("Different representations of ints: {} {} {} {} {}",
98_222, 0xff, 0o77, 0b1111_0000, b'A'
);

Float类型:f32和f64,所有float类型都是带符号的。

let x = 2.0; // 无特殊说明时默认64位(f64)
let y: f32 = 3.0; // f32

数字运算:

println!("sum: {}", 5 + 10);
println!("difference: {}", 95.5 - 4.3);
println!("product: {}", 4 * 30);
println!("quotient: {}", 56.7 / 32.2);
println!("quotient 2: {}", -5.0 / 3.0);
println!("truncated: {}", -5 / 3);
println!("remainder: {}", 43 % 5);

5.0 / 3.0和-5 / 3的区别在于:

  • 带.0的-5.0 / 3.0本质是float类型,所以计算出的结果包含小数点
  • 不带.0的-5 / 3本质上是int类型,所以计算出的结果会被“截断”,只取整数部分

Boolean and Character#

// Boolean
let t = true;
let f: bool = false;
println!("t: {t} f: {f}");
// Character
let c = 'z'; // char uses single quotation mark
let z: char = 'Z';
let heart_eyed_hachimi = '😻'; // char costs 4 bytes in default
println!("{c} {z} {heart_eyed_hachimi}");

Boolean没什么值得多说的。

单引号'表示char类型,一个char默认默认使用4 Bytes,为了储存Unicode字符(Unicode Scalar Value)。

Compound Types#

这个复合类型组要包括的是tuple和array。

let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;
println!("The value of y is {y}");
println!("First element in tup: {}", tup.0);

一个tuple中每个element的类型不要求一样。

let (x, y, z) = tup;可以把一个tuple中的值重新解析到多个变量上。

通过tuple.index(e,g, tup.0)的方式可以通过index获取一个tuple element的值。

let array = [1, 2, 3, 4, 5];
let index = 3;
let element = array[index];
println!("The value of the element at index {index} is {element}");
let array: [i32; 5] = array;
let array = [3; 5];
println!("First element in array: {}", array[0]);

访问array中element的语法是array[index],和其他的语言没什么区别。

明确指出一个array的类型和长度:let array: [i32; 5] = [1, 2, 3, 4, 5];

快速生成一个包含重复元素的array:let array = [init_val; length];,例如[3; 5]等同于[3, 3, 3, 3, 3]

通过读取用户输入的index值来访问array:

let array = [1, 2, 3, 4, 5];
println!("Please enter an array index:");
let mut index = String::new();
io::stdin()
.read_line(&mut index)
.expect("Failed to readline");
let index: usize = index
.trim()
.parse()
.expect("Index entered was not a number");
let element = array[index];
println!("The value of the element at index {index} is {element}");

如果用户输入的index超出了array的范围,rust会产生一个runtime error,并立即退出,防止程序像c语言那样访问到不该访问的内存信息。

Functions#

调用函数:

fn main() {
another_function();
print_labeled_measurement(5, 'h');
let mut x = five();
x = plus_one(x);
println!("The value of x is {x}");
}
fn another_function() { println!("Another Function"); }
fn print_labeled_measurement(val: i32, unit: char) {
println!("The measurement is: {val}{unit}");
}
fn five() -> i32 { 5 }
fn plus_one(x: i32) -> i32 { x + 1 }

这部分没什么特殊的内容。

Rust是一个“基于表达式”(expression-based)的语言,所以可以为一个变量赋予一组表达式:

let y = {
let x = 3;
x + 1 // must not use `;`
};

{}中的x + 1是一个表达式,这个表达式在{}的末尾,这个表达式的值会以类似于“返回值”之类的方式,重新赋予到调用这个表达式的变量上。

WARNING

如果使用x + 1;那么这就变成一个语句了。

关于语句statement和表达式expression之间的区别,类似于procedure和function之间的区别(是否产生返回值):

  • 语句(Statements)是执行一些操作但不返回值的指令。
  • 表达式(Expressions)计算并产生一个值。

函数末尾的表达式会自动作为这个函数的返回值返回,同样也可以用return xxx的方式在函数中直接返回返回值。

WARNING

rust中赋值语句不会返回任何值,所以不能写x = y = 1这种“连锁”赋值。

Control Flow#

IF statement#

let number = 8;
if number < 5 {
println!("less than 5");
} else if number == 5 {
println!("equal to 5");
} else {
println!("greater than 5");
}
let condition = true;
let number = if condition { 5 } else { 10 };
println!("The value of number is {number}");

由于rust是expression-based的语言,所以if也可以直接所谓运算符使用,而不像python中专门需要value = "true" if condition else "false"。

rust中的value = if condition { "true" } else { "false" }更符合直觉,扩展性也更强。

LOOP#

WHILE循环:

// 生成第 n 个斐波那契数
let mut counter = 1;
let n = 7;
let mut pre = 0;
let mut result = 1;
while counter < n {
if counter == n {
break;
}
let tmp = result;
result += pre;
pre = tmp;
counter += 1;
};
println!("The result is {result}");

loop语句:

let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2;
}
};

loop循环相当于python中的while True:用法。

break语句在loop中相当于函数中return的用法。

Loop labeling

// loop labeling
let mut i = 0;
'loop_i: loop {
let mut j = 0;
'loop_j: loop {
println!("{i} {j}");
if i == 5 {
break 'loop_i;
};
if j == 3 {
break;
};
j += 1
};
i += 1;
};

使用loop labeling语法时,break可以选择从哪个loop退出。默认情况下loop是退出最内侧的循环。

FOR循环:

let a = [10, 20, 30, 40, 50];
for element in a {
println!("The value is {element}");
};
for number in (1..4).rev() { // (1..4) is [1, 2, 3]
println!("{number}!");
};

for循环可以直接作用在iterable的对象上,例如array。

(1..4)是range的语法,在数学上的表示方式则是[1,4)[1, 4),assert_eq!((1..4), [1, 2, 3]);

Rust学习笔记 1 - Basic Concepts
https://thyrius.top/posts/rust/learning-log-1/
作者
Thyrius
发布于
2026-09-18
许可协议
CC BY-NC-SA 4.0