03. rust基本类型-primitive_type

Booleans (bool)

let is_morning = true;
    if is_morning {
        println!("Good morning!");
    }

Characters (char)

fn main() {
    let c1 = 'a'; // 字母
    let c2 = '中'; // 中文
    let c3 = '😊'; // 表情符号
    println!("c1: {}, c2: {}, c3: {}", c1, c2, c3);
}

Rust 中的 char

Rust 的 char 类型表示一个 Unicode 标量值，占用 4 字节（32 位）。它能够表示来自 Unicode 集合的任意字符（包括 ASCII 字符和非 ASCII 字符）。

• 范围：U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF。
• 特点：支持多语言字符（中文、阿拉伯文、表情符号等）。

char 的常用方法

Rust 的 char 类型提供了一些内置方法，用于检查字符的属性或进行转换。以下是主要方法的分类及其用法：

1. 检查字符属性

方法	功能	示例
.is_alphabetic()	判断是否为字母	'a'.is_alphabetic() -> true
.is_numeric()	判断是否为数字	'5'.is_numeric() -> true
.is_alphanumeric()	判断是否为字母或数字	'a'.is_alphanumeric() -> true
.is_ascii()	判断是否为 ASCII 字符	'A'.is_ascii() -> true
.is_ascii_digit()	判断是否为 ASCII 数字	'5'.is_ascii_digit() -> true
.is_ascii_alphabetic()	判断是否为 ASCII 字母	'z'.is_ascii_alphabetic() -> true
.is_ascii_uppercase()	判断是否为 ASCII 大写字母	'Z'.is_ascii_uppercase() -> true
.is_ascii_lowercase()	判断是否为 ASCII 小写字母	'a'.is_ascii_lowercase() -> true
.is_control()	判断是否为控制字符（如换行、回车）	'\n'.is_control() -> true
.is_whitespace()	判断是否为空白字符	' '.is_whitespace() -> true
.is_uppercase()	判断是否为大写字母	'A'.is_uppercase() -> true
.is_lowercase()	判断是否为小写字母	'a'.is_lowercase() -> true
.is_ascii_punctuation()	判断是否为 ASCII 标点符号	'.'.is_ascii_punctuation() -> true

---

2. 转换字符

方法	功能	示例
.to_ascii_uppercase()	转换为大写 ASCII 字符	'a'.to_ascii_uppercase() -> 'A'
.to_ascii_lowercase()	转换为小写 ASCII 字符	'A'.to_ascii_lowercase() -> 'a'
.to_uppercase()	转换为大写（支持 Unicode）	'ß'.to_uppercase().collect::<String>() -> "SS"
.to_lowercase()	转换为小写（支持 Unicode）	'A'.to_lowercase().collect::<String>() -> "a"

---

3. ASCII 检查

这些方法针对 ASCII 范围（0x00–0x7F）的字符：

fn main() {
    let c = '7';
    println!("Is ASCII? {}", c.is_ascii());
    println!("Is ASCII digit? {}", c.is_ascii_digit());
    println!("Is ASCII alphabetic? {}", c.is_ascii_alphabetic());
}

输出：

Is ASCII? true
Is ASCII digit? true
Is ASCII alphabetic? false

---

4. 转换为数字或 Unicode 值

方法	功能	示例
.to_digit(radix)	将字符转换为指定进制的数字	'A'.to_digit(16) -> Some(10)
as u32	获取字符的 Unicode 标量值	'A' as u32 -> 65

array

数组是 Rust 中一种固定大小的集合类型，存储相同类型的元素。数组的大小在编译时固定，元素类型和长度都是数组类型的一部分。

---

数组的声明与初始化

1. 声明数组

数组的类型为 [T; N]，其中：

• T 是数组中元素的类型。
• N 是数组的长度（必须是常量）。

fn main() {
    let array1: [i32; 4] = [1, 2, 3, 4]; // 明确类型与长度
    let array2 = [5, 6, 7, 8];          // 自动推断类型与长度
 
    println!("Array 1: {:?}", array1); //数组答应使用{:?}，而不是{}
    println!("Array 2: {:?}", array2);
}

2. 创建重复元素的数组

使用 [value; size] 语法创建一个包含重复元素的数组：

fn main() {
    let array = [0; 5]; // 创建一个长度为 5 的数组，每个元素都为 0
    println!("{:?}", array); // 输出: [0, 0, 0, 0, 0]
}

---

数组的访问与操作

1. 通过索引访问元素

索引从 0 开始：

fn main() {
    let arr = [10, 20, 30, 40, 50];
    println!("First element: {}", arr[0]);
    println!("Last element: {}", arr[4]);
}

2. 防止索引越界

Rust 会在运行时检查数组索引是否越界，若越界会导致程序 panic：

fn main() {
    let arr = [1, 2, 3];
    // println!("{}", arr[3]); // 运行时会报错: 索引越界
}

3. 数组长度

使用 .len() 获取数组的长度：

fn main() {
    let arr = [10, 20, 30];
    println!("Array length: {}", arr.len()); // 输出: 3
}

---

数组的特性

1. 数组是固定大小的

数组的长度在编译时必须确定，不能动态改变。

2. 数组是连续存储的

数组中的元素在内存中是连续排列的，这使得访问速度更快。

3. 复制与赋值

数组是栈分配的，赋值或传递数组时会复制整个数组：

fn main() {
    let arr1 = [1, 2, 3];
    let arr2 = arr1; // 复制整个数组
    println!("{:?}, {:?}", arr1, arr2);
}

---

数组的迭代

使用 for 循环或迭代器方法：

fn main() {
    let arr = [10, 20, 30];
 
    // 使用 for 循环
    for element in arr.iter() {
        println!("{}", element);
    }
 
    // 使用索引
    for i in 0..arr.len() {
        println!("arr[{}] = {}", i, arr[i]);
    }
}

---

多维数组

Rust 支持多维数组，例如二维数组：

fn main() {
    let matrix: [[i32; 3]; 2] = [
        [1, 2, 3], 
        [4, 5, 6]
    ];
 
    for row in &matrix {
        for &value in row {
            print!("{} ", value);
        }
        println!();
    }
}

输出：

1 2 3 
4 5 6

---

常用操作与方法

方法	描述	示例
.len()	返回数组长度	[1, 2, 3].len() -> 3
.is_empty()	判断数组是否为空	[1, 2].is_empty() -> false
.iter()	返回一个迭代器	[1, 2].iter() -> Iter
.get(idx)	安全获取指定索引的元素（返回 Option）	[1, 2].get(1) -> Some(2)
.first()	返回第一个元素（Option）	[1, 2].first() -> Some(1)
.last()	返回最后一个元素（Option）	[1, 2].last() -> Some(2)

示例：

fn main() {
    let arr = [10, 20, 30];
 
    println!("First: {:?}", arr.first()); // 输出: Some(10)
    println!("Last: {:?}", arr.last());   // 输出: Some(30)
    println!("Element at 1: {:?}", arr.get(1)); // 输出: Some(20)
    println!("Out of bounds: {:?}", arr.get(3)); // 输出: None
}

---

数组和切片

数组可以隐式转换为切片（&[T]），切片用于动态数组的操作：

fn main() {
    let arr = [1, 2, 3, 4, 5];
 
    let slice = &arr[1..4]; // 切片，包含索引 1 到 3 的元素
    println!("{:?}", slice); // 输出: [2, 3, 4]
}

---

数组和动态数组（Vec）的区别

• 数组（[T; N]）：大小固定，存储在栈上。
• 动态数组（Vec<T>）：大小可变，存储在堆上。

动态数组适用于大小未知或需要动态调整的场景：

fn main() {
    let mut vec = vec![1, 2, 3];
    vec.push(4); // 添加元素
    println!("{:?}", vec); // 输出: [1, 2, 3, 4]
}

---

Rust 中的数组适合用于固定大小且性能敏感的场景。如果需要灵活性，通常会使用 Vec<T>。

tuple

元组是不同类型的值的集合。元组的大小是固定的，也就是说，一旦定义了元组的长度和类型，它就不能改变。

let cat = ("Furry McFurson", 3.5);
let name = &cat.0;
let age = &cat.1;

元组嵌套

let nested_tuple = ((1, 2), (3.14, 'b'));
println!("{:?}", nested_tuple);

解构元组

fn main() {
    let tuple = (42, 3.14, 'a');
    let (_, y, z) = tuple; // 忽略第一个元素
    println!("y: {}, z: {}", y, z); // 输出: y: 3.14, z: a
}

match使用示例：

fn main() {
    let point = (0, -2);
 
    match point {
        (0, y) => println!("Point lies on the y-axis at {}", y),
        (x, 0) => println!("Point lies on the x-axis at {}", x),
        (_, _) => println!("Point is somewhere else"),
    }
}