【零基础学Rust | 基础系列 | 基础语法】变量，数据类型，运算符，控制流

---

文章目录

• 简介：
• 一，变量
• • 1，变量的定义
  • 2，变量的可变性
  • 3，变量的隐藏
• 二、数据类型
• • 1，标量类型
  • 2，复合类型
• 三，运算符
• • 1，算术运算符
  • 2，比较运算符
  • 3，逻辑运算符
  • 4，位运算符
  • 5，赋值运算符
• 四、控制流
• • 1，条件语句
  • 2，循环语句
• 总结

---

简介：

本章节将详细介绍Rust的基础语法，包括变量，数据类型，运算符，以及控制流。每个部分都将提供详细的解释和代码示例，以便于理解和学习。

---

一，变量

在编程语言中，变量是一种基本的概念，它们是用来存储数据的。在Rust中，变量的特性和其他语言有所不同。

1，变量的定义

在Rust中，变量的定义使用let关键字。定义变量的基本格式是let 变量名 = 变量值;。例如，定义一个整数变量x，并赋值为5，可以写成let x = 5;。

let x = 5;

在这个例子中，x就是变量名，5就是变量值。注意，Rust是一种静态类型语言，这意味着在编译时就必须知道所有变量的类型。但是，Rust有一个强大的类型推断系统，它可以根据变量的值推断出变量的类型。在这个例子中，编译器会自动推断出x的类型是i32。

2，变量的可变性

在Rust中，变量默认是不可变的。这是一种保障数据安全的方式。如果试图改变一个不可变变量的值，编译器会报错。

let x = 5;
x = 6; // 编译错误：不能赋值给不可变变量

如果需要改变变量的值，需要在定义变量时使用mut关键字，表示这个变量是可变的。

let mut x = 5;
x = 6; // 这是合法的

在这个例子中，x是一个可变变量，可以改变它的值。

3，变量的隐藏

在Rust中，可以定义一个新的变量来隐藏旧的变量。这被称为变量的隐藏。

let x = 5;
let x = x + 1; // 隐藏旧的x，定义一个新的x

在这个例子中，第二个let语句定义了一个新的变量x，并隐藏了旧的变量x。新的变量x的值是旧的变量x的值加1。

---

二、数据类型

Rust是一种静态类型语言，这意味着在编译时就必须知道所有变量的类型。Rust的数据类型主要分为两大类：标量（Scalar）和复合（Compound）。

1，标量类型

标量类型代表一个单一的值，Rust有四种基本的标量类型：整型，浮点型，布尔型，和字符型。

1. 整型
   整型是一种数字类型，可以是有符号的（i8, i16, i32, i64, i128 和 isize）或无符号的（u8, u16, u32, u64, u128 和 usize）。每一个变量后面的数字代表该变量占用的位数。例如，i32类型的整数占用32位，i64占用64位。isize和usize类型依赖运行程序的计算机架构：64位架构上它们是64位的， 32位架构上它们是32位的。

let x: i32 = 5; // 有符号整型
let y: u32 = 5; // 无符号整型

2. 浮点型
   Rust的浮点数类型是f32 和 f64，分别占32位和64位。默认类型是f64，因为在现代CPU中，它几乎与f32一样快，但精度更高。

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

3. 布尔型
   布尔类型有两个可能的值：true 和 false。Rust中布尔类型的大小为一位。

let t = true;
let f: bool = false; // 显式指定类型

4. 字符型
   Rust的char类型代表了一个Unicode标量值，这意味着它可以比ASCII表表示更多的内容。char类型的大小为四个字节，并且用单引号指定。

let c = 'z';
let z = 'ℤ';
let heart_eyed_cat = '😻';

2，复合类型

复合类型可以将多个值组合成一个类型。Rust有两个原生的复合类型：元组（tuple）和数组（array）。

1. 元组类型
   元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不能增大或缩小。

let tup: (i32, f64, u8) = (500, 6.4, 1);

2. 数组类型
   对于每个元素类型相同的情况，Rust提供了数组类型。与元组不同，数组的长度在编译时就必须是固定的，不能动态改变。

let a = [1, 2, 3, 4, 5];
let months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];

---

三，运算符

Rust语言提供了一系列的运算符，包括算术运算符，比较运算符，逻辑运算符，位运算符，赋值运算符等。这些运算符在编程中起着至关重要的作用，用于执行各种计算和逻辑操作。下面将对这些运算符进行详细的介绍，并提供相应的代码示例。

1，算术运算符

Rust支持基本的算术运算符，包括加法(+), 减法(-), 乘法(*), 除法(/), 取余(%):

let a = 10;
let b = 3;

let sum = a + b; // 加法
println!("Sum: {}", sum); // 输出：13

let difference = a - b; // 减法
println!("Difference: {}", difference); // 输出：7

let product = a * b; // 乘法
println!("Product: {}", product); // 输出：30

let quotient = a / b; // 除法
println!("Quotient: {}", quotient); // 输出：3

let remainder = a % b; // 取余
println!("Remainder: {}", remainder); // 输出：1

2，比较运算符

比较运算符用于比较两个值，包括等于(==), 不等于(!=), 大于(>), 小于(<), 大于等于(>=), 小于等于(<=):

let a = 10;
let b = 20;

println!("a == b: {}", a == b); // 输出：false
println!("a != b: {}", a != b); // 输出：true
println!("a > b: {}", a > b); // 输出：false
println!("a < b: {}", a < b); // 输出：true
println!("a >= b: {}", a >= b); // 输出：false
println!("a <= b: {}", a <= b); // 输出：true

3，逻辑运算符

逻辑运算符用于组合多个条件，包括逻辑与(&&), 逻辑或(||), 逻辑非(!):

let a = true;
let b = false;

println!("a && b: {}", a && b); // 输出：false
println!("a || b: {}", a || b); // 输出：true
println!("!a: {}", !a); // 输出：false

4，位运算符

位运算符用于操作整数的二进制位，包括位与(&), 位或(|), 位异或(^), 左移(<<), 右移(>>)：

let a = 0b_0011_1100; // 60
let b = 0b_0000_1101; // 13

println!("a & b: {}", a & b); // 输出：12
println!("a | b: {}", a | b); // 输出：61
println!("a ^ b: {}", a ^ b); // 输出：49
println!("a << 2: {}", a << 2); // 输出：240
println!("a >> 2: {}", a >> 2); // 输出：15

5，赋值运算符

赋值运算符用于给变量赋值，包括等号(=), 加等(+=), 减等(-=), 乘等(*=), 除等(/=), 取余等(%=), 位与等(&=), 位或等(|=), 位异或等(^=), 左移等(<<=), 右移等(>>=)：

let mut a = 10;

a += 5; // a = a + 5
println!("a: {}", a); // 输出：15

a -= 2; // a = a - 2
println!("a: {}", a); // 输出：13

a *= 3; // a = a * 3
println!("a: {}", a); // 输出：39

a /= 3; // a = a / 3
println!("a: {}", a); // 输出：13

a %= 5; // a = a % 5
println!("a: {}", a); // 输出：3

a &= 2; // a = a & 2
println!("a: {}", a); // 输出：2

a |= 1; // a = a | 1
println!("a: {}", a); // 输出：3

a ^= 1; // a = a ^ 1
println!("a: {}", a); // 输出：2

a <<= 2; // a = a << 2
println!("a: {}", a); // 输出：8

a >>= 1; // a = a >> 1
println!("a: {}", a); // 输出：4

---

四、控制流

控制流是编程中的基本概念，它决定了代码的执行顺序。在Rust中，控制流主要包括条件语句和循环语句。

1，条件语句

条件语句是根据特定条件来决定执行哪段代码。在Rust中，主要使用if和else关键字来创建条件语句。

1. if语句
   if语句用于测试某个条件是否满足，如果满足，则执行相应的代码块。以下是一个简单的例子：

let number = 7;

if number < 5 {
    println!("condition was true");
} else {
    println!("condition was false");
}

在这个例子中，number < 5是一个条件表达式，它的结果是一个布尔值。如果这个值为true，则执行if后面的代码块，否则执行else后面的代码块。

2. else if语句
   else if语句用于测试多个条件。如果if语句的条件不满足，那么就会测试else if语句的条件，如果else if语句的条件满足，就执行相应的代码块，否则继续测试下一个else if语句的条件，如果所有的else if语句的条件都不满足，就执行else后面的代码块。

let number = 6;

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

2，循环语句

循环语句用于重复执行某段代码，直到满足特定的条件。在Rust中，主要使用loop，while和for关键字来创建循环语句。

1. loop语句
   loop语句用于创建无限循环，也就是说，它会一直重复执行相应的代码块，直到显式地使用break关键字来退出循环。

let mut counter = 0;

loop {
    counter += 1;

    if counter == 10 {
        break;
    }
}

在这个例子中，loop语句会一直重复执行，直到counter的值等于10，然后使用break关键字退出循环。

2. while语句
   while语句用于创建条件循环，也就是说，它会一直重复执行相应的代码块，直到条件表达式的结果为false。

let mut number = 3;

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

    number -= 1;
}

println!("LIFTOFF!!!");

在这个例子中，while语句会一直重复执行，直到number的值等于0，然后退出循环。

3. for语句
   for语句用于遍历一个集合的所有元素。在Rust中，可以使用for语句和in关键字来遍历一个范围，一个迭代器，或者一个数组。

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

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

在这个例子中，for语句遍历数组a的所有元素，并打印每个元素的值。

---

总结

本章节详细介绍了Rust的基础语法，包括变量，数据类型，运算符，以及控制流。理解这些基础知识是学习Rust的重要步骤，希望这些内容能帮助理解和掌握Rust的基础语法。