跟其他高级语言一样，Rust 使用 unicode 字符集，这里过一下常见的编程概念在 Rust 中的使用。

注释

文档注释，沿用 C 语言风格的注释，可以使用双斜杠或斜杠星的格式进行注释，其中双斜杠是单行注释，斜杠星是多行注释，语法如下：

// 这里是代码注释
let x = 1;
/* 这里是代码注释 */
let y = 2

文档注释，使用三斜杠语法或斜杠叹的格式，三斜杠注释在其后面的下一个项，而斜杠叹注释在其后面的整个项，文档注释主要在发布 crate 时使用，语法如下：

/// 这里是文档注释
fn add() {}
//! 这里是文档注释
mod user {}

变量

使用 let name: type = value 语法声明变量，其中类型可以忽略交由编译器推断。变量听起来是可以改变的，但在 Rust 中默认是不可改变的，也就是说下面的写法是不行的：

let age = 5;
age = 6          // 报错

如果想让其变成真正的变量，需要使用 mut 标注为 mutable(可修改的)：

let mut age = 5
age = 6          // 正常

常量

使用 const name: type = value 语法声明常量，常量不允许改变，也就是不能使用 mut 关键字修饰，并且必须标明类型。不包含类型会报错，如下：

const MAN = 1;   // 报错

包含类型不会报错：

const MAN: i8 = 1;

简单类型

简单类型，指的是存在在栈结构上的简单值，这些值通常占用内存小且易于修改。 在 Rust 中，简单类型主要包含整形、浮点型、布尔型和字符型四种，不同的类型担任不同的职责，并可以集合构成数组、结构体等复杂类型。

字符型

字符型，指的是单个字符，使用 char 关键字声明。字符与字符串有所区别，字符串是多个字符的集合，字符使用单引号声明，字符串使用双引号声明。字符的声明语法如下：

let c = 'z';
let z: char = 'ℤ';

整形

以 i 开头的是有符号整数，表示值可以是正数也可以是负数，i 是 int 的缩写，以 u 开头的是无符号整数，表示值只能是正数，u 是 unsigned 的缩写。

let c: i8 = 1;  // 范围：-128 ~ 127
let d: u8 = 1;  // 范围：0 ~ 255

长度分为 8、16、32、64、128 和 size 六类，其中 size 取决于所在的计算机架构，在 32 位架构上是 32 位的，在 64 架构上是 64 位的，共有如下类型：

有符号	无符号
i8	u8
i16	u16
i32	u32
i64	u64
i128	u128
isize	usize

浮点型

包含 f32(单精度) 和 f64(双精度) 两种类型，均是有符号的，默认是 f64 类型。

let x = 2.0;        // f64
let y: f32 = 3.0;   // f32

布尔型

包含 true 和 false 两个值。

let t = true;
let f: bool = false;

复杂数据类型

复杂数据类型，包含元组和数组。

元组

元组，是一种长度固定，类型不同的线性结构，语法如下：

let tup: (i32, f64, u8) = (100, 1.0, 1);

取值时可以使用点索引访问，也可以使用模式匹配进行解构，如下：

let x = tup.0         // 使用索引
let (x, y, z) = tup;  // 使用解构

数组

数组，是一种长度固定，类型相同的线性解构，语法如下：

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

上面的 [i32; 5] 表示长度为 5，类型为 i32 的数组，可以用类似语法声明值相同的数组，如下：

let b = [3;5]  // 表示 [3, 3, 3, 3, 3]

访问时可以使用索引访问，不同于元组用 . 语法，数组使用 [] 语法，如下：

let c = b[0]

函数

函数不知道算不算复杂类型，但比较重要的一点是，如果有入参和出参需要标注好参数类型，语法如下：

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

上面的代码中：

• x, y 必须标注参数类型
• -> i32 标注返回值类型
• x+y 是一个表达式，在 Rust 中最后一个表达式将作为函数的返回值，也就是省略了 return 语句，但值得注意的是，不能加分号，否则就变成语句了。

控制结构

控制结构，可以控制某部分代码是否执行，重新执行多少次，以及在什么条件下执行等。

if 结构

if 根据条件值决定是否执行某段代码，值得注意的是，if 结构的条件不需要括号，如下：

let x = 1;
let y = 2;

if x > y {
  println!("大了");
} else if x == y {
  println!("相等");
} else {
  println!("小了");
}

loop 结构

loop 结构，是一种循环结构，没有执行条件默认一直执行，但可以通过 break 跳出循环并返回值 或 continue 跳到下一循环。

let mut counter = 0;

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

println!("数值为 {result}");

while 结构

while 结构是一种循环结构，根据条件重复运行或终止。

let mut number = 3;

while number != 0 {
  println!("{number}!");
  number -= 1;
}

println!("结束");

for 结构

for 结构是一种循环结构，通常用于执行有限的重复执行。好像只有 for in 这种结构，用于遍历集合中的元素，如下：

let a = [10, 20, 30, 40, 50];

for element in a {
  println!("the value is: {element}");
}

如果要实现计数循环，可以用以下语法：

for i in 1..5 {
  println!("{i}")
}

结语

总体而言，没有太突兀的地方，如果你有其他语言的经验还是很容易熟悉下来的。这里没有涉及操作符，但常用的就那些，有特殊的话可以等到后面慢慢学。