Back
Featured image of post Rust 学习笔记02 - 基本语法
Programming

Rust 学习笔记02 - 基本语法

导航页

变量声明

Rust 使用 let 关键字声明变量，和其他新兴语言一样，默认情况下是 Immutable 的。需要使用 mut 关键字使其可变。

fn main() {  let x = 5;  println!("The value of x: {}", x);  let mut y = 5;  println!("The value of y: {}", y); }

请注意，这里虽然没有写类型，但不代表 Rust 是动态的。这是类型推断，相当于编译器自动帮你写成了 let x: i32 = 5;。

基本类型和 &str（字符串自变量） 可以被声明为编译时常量：

const MAX_POINTS: u32 = 100_000; // compile-time constant  fn main() {  const STRING: &str = "123123";  println!("The value of MAX_POINTS: {}", MAX_POINTS); }

常量必须显式写明类型。同时 top-level 或局部声明都是可以的。

Shadow

虽然不允许修改变量，但 Rust 允许 Shadow 一个变量的名称。比如：

let a = 1; let a = 100;

然而，我不建议这种做法，很多语言也不建议这种做法。建议读者自行斟酌。

注释

// 单行注释  /*  * 多行注释  * /*  * * 可以嵌套  * */  */  /// /// 文档注释 ///

基本类型

基本类型（primitives），也叫原生类型、原语。是组成所有数据结构的基本元素。

整数类型

长度Signed / 有符号Unsigned / 无符号
8 位i8u8
16 位i16u16
32 位i32u32
64 位i64u64
128 位i128u128
架构特定isizeusize

Rust 的基本类型关键字非常简洁易懂，直接就是类型缩写 + 所占空间，不必纠结 int long long long long int short 的意义。

同时少有的支持 128 位数据类型。

isize 和 usize 即根据平台使用不同的长度，如 32 位架构上，就占 32 位 ，最常用来存数组下标。

Rust 也支持不同进制的整数字面量：

字面量示例
十进制98_222
十六进制0xFF
八进制0o77
二进制0b1111_000
字节（仅 u8）b'A'

可以使用 _ 分隔数字，便于阅读。

浮点类型

Rust 的浮点数遵循 IEEE 754 标准。具有 f32 和 f64 两种长度可选。默认为 f64。

浮点数可以省略小数部分，如 0.，但不可省略点号和整数部分。

字符

关键词为 char，字面量使用单引号包围，可存任意 Unicode 定义的字符，占 4 字节。

let a = 'a' let alpha = 'α' let emoji = '😄' // 大多数 emoji 都可以存为字符

布尔

关键词为 bool，字面量 true 或 false，占 1 字节。

Unit 类型

空元组：()。尽管是元组，但它是一种特殊的类型，而不是复合类型，因为不包含多个值。

复合类型

  • 数组：[1, 2, 3]

    • Rust 的数组索引和多数 C-like 语言一样，从 0 开始
    • 数组的长度是固定的，所以类型注解应写成 let arr: [i32; 5] = [1,2,3,4,5]
    • 多个同样的值可以使用 [0; 5] 这种语法，相当于 [0, 0, 0, 0, 0,]
    • 在编译时，Rust 能够检测部分数组越界。如 let a = [1,2,3]; a[10]; 会直接不过编译。
    • 在运行时，若数组越界了，将会直接 panic 退出程序，而不是继续执行。

  • 元组：(1, true)

    • 类型注解类似这样：(i32, bool)

    • 当元素多于 3 个时，建议使用结构体定义。

    • 可以直接访问对应的类型： x.0 x.1

    • 解构声明：let (x, y, z) = (500, 6.4, 1);

数组和元组的区别在于：数组只能存一种类型；而元组能存多种类型。

字面量后缀

可以使用对应关键字当作类型后缀。例如：

let a = 100i64; let b = 100i32; let c = 100i8;  let d = 10.123f32; let f = 10.112312312f64;

操作符

这部分和大多数类 C 语言一样。就不列出全表了。

值得一提的是，Rust 类似很多新语言（如 Swift），没有 ++ 操作符，避免了各种魔怔写法。建议使用 value += 1 替代。

优先级不明晰的时候，建议括号包裹即可，不用背优先级。

函数

函数使用 fn 声明，函数名使用 snake_case 风格：

fn function() { // 隐式返回 Unit 类型 ()  println!("Hello Function!");  another_function(); }  fn another_function() {  println!("Another function."); }

参数可以这样写：

fn main() {  another_function(5, 'g'); }  fn another_function(x: i32, lable: char) {  println!("The value of x is: {}{}", x, lable); }

Rust 刻意不支持默认参数，也不支持函数重载。

Rust 允许将不写分号的语句直接返回，而不用写 return：

fn return_no_semicolon() -> i32 {  123123 }

然而我认为这无疑是一种垃圾设计，舍本逐末。为了这里一点的方便，让其他所有地方都要写分号。

况且为何不直接：

fn return_no_semicolon() -> i32 = 123123

控制流

条件

if-else

这里用到了 rand 库，编辑 Cargo.toml

[dependencies] rand = "0.8.0"
use rand::{thread_rng, Rng}; // 导包  fn main() {  // 这里的 ..= 是闭区间, 也就是说包括 1 和 100  // 与之对应的有 .. 是左闭右  let num = thread_rng().gen_range(1..=100);  let cmp_num = thread_rng().gen_range(1..=100);  if num < cmp_num {  println!("{num} is greater than {cmp_num}!")  } else {  println!("{num} is not greater than {cmp_num}!")  } }

和其他语言类似，Rust 可以省略包裹条件的括号，但不能省略大括号。

Rust 的条件必须是布尔类型，以下代码会报错：

if 1 {}

if-else-if

// 后面将会省略 main 函数和生成 num 的代码 if num % 3 == 0 {  println!("{num} is is divisible by 3!") } else if num % 4 == 0 {  println!("{num} is is divisible by 4!") } else if num % 5 == 0 {  println!("{num} is is divisible by 5!") } else {  println!("{num} is not divisible by 3, 4, 5.") }

match

match num {  1 => println!("1"),  2 => println!("2"),  _ => println!("Other number"), }

match 要求分支必须是穷尽的，常常用来处理枚举。后面讲到枚举的时候再详细介绍。

作为表达式

穷尽的 if 和 match 允许做看作表达式，用于赋值。

fn main() {  let condition = true;  let number = if condition { 5 } else { 6 };   println!("The value of number is: {}", number); }

循环

while

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

loop

死循环，类似于 while true {}，但对 loop 有着不同的语义。Rust 建议任何能用 while true {} 的地方都用 loop。

break & continue

break 用于跳出整个循环。continue 用于跳过本次循环。

fn main() {  let mut count = 0;   while count < 5 {  count += 1;  print!("{count} ");  if count == 1 {  continue;  }  if count == 3 {  break;  }  } }

label

如果存在嵌套循环，可以使用循环标签，跳过指定的循环，而不是最内层循环。

fn main() {  let mut count = 0;  'counting_up: loop {  println!("count = {}", count);  let mut remaining = 10;   loop {  println!("remaining = {}", remaining);  if remaining == 9 {  break;  }  if count == 2 {  break 'counting_up;  }  remaining -= 1;  }   count += 1;  }  println!("End count = {}", count); }  /* Output: count = 0 remaining = 10 remaining = 9 count = 1 remaining = 10 remaining = 9 count = 2 remaining = 10 End count = 2 */

for

for count in 1..=5 {  println!("Again! {count}"); }  // rev() 用于逆序, 此处会从 5 倒数到 1 for count in (1..=5).rev() {  println!("Again! {count}"); }

foreach

let a = [10, 20, 30, 40, 50]; for element in a.iter() {  println!("The value is {element}"); }
comments powered by Disqus