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"),
    }
}

posted @ 2025-01-15 16:52 代码世界faq 阅读(86) 评论(0) 收藏举报

刷新页面返回顶部

learnForLife

03. rust基本类型-primitive_type

Booleans (`bool`)

Characters (`char`)

Rust 中的 `char`

`char` 的常用方法

1. 检查字符属性

2. 转换字符

3. ASCII 检查

4. 转换为数字或 Unicode 值

array

数组的声明与初始化

1. 声明数组

2. 创建重复元素的数组

数组的访问与操作

1. 通过索引访问元素

2. 防止索引越界

3. 数组长度

数组的特性

1. 数组是固定大小的

2. 数组是连续存储的

3. 复制与赋值

数组的迭代

多维数组

常用操作与方法

数组和切片

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

tuple

元组嵌套

解构元组

match使用示例：

公告

learnForLife

03. rust基本类型-primitive_type

Booleans (bool)

Characters (char)

Rust 中的 char

char 的常用方法

1. 检查字符属性

2. 转换字符

3. ASCII 检查

4. 转换为数字或 Unicode 值

array

数组的声明与初始化

1. 声明数组

2. 创建重复元素的数组

数组的访问与操作

1. 通过索引访问元素

2. 防止索引越界

3. 数组长度

数组的特性

1. 数组是固定大小的

2. 数组是连续存储的

3. 复制与赋值

数组的迭代

多维数组

常用操作与方法

数组和切片

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

tuple

元组嵌套

解构元组

match使用示例：

公告

Booleans (`bool`)

Characters (`char`)

Rust 中的 `char`

`char` 的常用方法