Rust 基础语法与数据类型

本章节将介绍 Rust 的基础语法和数据类型。

基础语法

变量声明

在 Rust 中，使用 let 关键字声明变量：

fn main() {
    let x = 5;
    println!("x = {}", x);
}

默认情况下，变量是不可变的。要声明可变变量，需要使用 mut 关键字：

fn main() {
    let mut x = 5;
    x = 10;
    println!("x = {}", x);
}

常量

使用 const 关键字声明常量：

const MAX_VALUE: i32 = 100;

fn main() {
    println!("MAX_VALUE = {}", MAX_VALUE);
}

数据类型

Rust 是静态类型语言，每个变量都有确定的类型。

标量类型

1. 整数类型

   类型	大小	范围
   i8	1字节	-128 到 127
   i16	2字节	-32768 到 32767
   i32	4字节	-2^31 到 2^31-1
   i64	8字节	-2^63 到 2^63-1
   u8	1字节	0 到 255
   u16	2字节	0 到 65535
   u32	4字节	0 到 2^32-1
   u64	8字节	0 到 2^64-1

   let a: i32 = 42;
   let b: u8 = 255;

2. 浮点数类型

   • f32：32位浮点数
   • f64：64位浮点数（默认）

   let x: f32 = 3.14;
   let y = 2.718; // 默认是 f64

3. 布尔类型

   • bool：只能是 true 或 false

   let is_true = true;
   let is_false: bool = false;

4. 字符类型

   • char：表示单个 Unicode 字符

   let c: char = 'a';
   let emoji = '😀';

复合类型

1. 元组（Tuple）

   元组可以包含不同类型的值：

   let tup: (i32, f64, bool) = (42, 3.14, true);
   
   // 解构元组
   let (x, y, z) = tup;
   println!("x = {}, y = {}, z = {}", x, y, z);
   
   // 通过索引访问
   println!("第一个元素: {}", tup.0);

2. 数组（Array）

   数组包含相同类型的值，长度固定：

   let arr: [i32; 5] = [1, 2, 3, 4, 5];
   let arr2 = [0; 10]; // 初始化10个0
   
   // 通过索引访问
   println!("第一个元素: {}", arr[0]);

3. 切片（Slice）

   切片是对数组的引用，长度可变：

   let arr = [1, 2, 3, 4, 5];
   let slice = &arr[1..3]; // 从索引1到3（不包含3）
   println!("切片: {:?}", slice);

运算符

算术运算符

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取模

let a = 10;
let b = 3;
println!("a + b = {}", a + b);
println!("a - b = {}", a - b);
println!("a * b = {}", a * b);
println!("a / b = {}", a / b);
println!("a % b = {}", a % b);

比较运算符

• ==：等于
• !=：不等于
• <：小于
• >：大于
• <=：小于等于
• >=：大于等于

let a = 5;
let b = 10;
println!("a == b: {}", a == b);
println!("a < b: {}", a < b);

逻辑运算符

• &&：逻辑与
• ||：逻辑或
• !：逻辑非

let a = true;
let b = false;
println!("a && b: {}", a && b);
println!("a || b: {}", a || b);
println!("!a: {}", !a);

位运算符

• &：按位与
• |：按位或
• ^：按位异或
• !：按位取反
• <<：左移
• >>：右移

let a = 0b1010;
let b = 0b1100;
println!("a & b: {:b}", a & b);
println!("a | b: {:b}", a | b);

类型推导

Rust 具有类型推导能力，可以根据上下文自动推断变量类型：

let x = 5; // 推断为 i32
let y = 3.14; // 推断为 f64
let z = true; // 推断为 bool

总结

• Rust 使用 let 声明变量，默认不可变
• 使用 mut 关键字声明可变变量
• 使用 const 声明常量
• Rust 有丰富的数据类型，包括标量类型和复合类型
• 支持各种运算符，包括算术、比较、逻辑和位运算符
• Rust 具有类型推导能力

通过本章节的学习，你应该已经掌握了 Rust 的基础语法和数据类型，可以开始编写简单的 Rust 程序了。