Rust 基础数据类型 —— Rust 的神级语法


前言：

在 Rust 中，每一个值都具有明确的类型。在这些类型中，分为：标量（scalar） 和 复合（compound） 两大类。

一、标量

标量 代表一个单独的值，诸如 bool 的 True 、i32 的 3 。Rust 有四种基本的标量类型：整型、浮点型、布尔类型 和 字符类型。

1、整型

以下是为整型的类型表格

长度 有符号 无符号
8-bit i8 u8
16-bit i16 u16
32-bit i32 u32
64-bit i64 u64
128-bit i128 u128
arch isize usize

arch 应该有弹性的意思

值得注意的是：isize 和 usize 类型的长度取决于运行程序的计算机架构。64 位架构上它们是 64 位的， 32 位架构上它们是 32 位的。

在许多语言中，都允许采用其它形式来表示数字。这在 Rust 中也不例外：

数字字面值 例子
Decimal（十进制） 98_222
Hex（十六进制） 0xff
Octal （八进制） 0o77
Binary（二进制） 0b1111_0000
Byte (仅适用于 u8 ) b'A'

符号_在数字中并无意义，只是为了方便阅读。

Rust 的整数默认是 i32类型，（在 64 位系统也一样）。isize 或 usize 主要作为某些集合的索引。

2、浮点型

Rust 有两个原生的 浮点数（floating-point numbers） 类型，它们用来表示具有小数点的数字（如 3.14 ）。Rust 的浮点数类型是 f32 和 f64，长度分别为 32 位和 64 位。但一个具有小数的数字的默认类型是 f64，因为在现代 CPU 中，计算它与 f32 的速度几乎一样，但具有更高的精度。

目前这些数字类型都支持基本的数学运算：加法、减法、乘法、除法 和 取余 。进行这些数学运算的表达方式与其它语言相似：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn main() {
    //如果数字为 1 ，将报错：mismatched types
    //类型不匹配的原因是 1 的默认类型为 i32
    let number:f64 = 1.0;

    // number 之前是不可变变量，这里利用 Rust 的 重影
    //乘以 9.0 （同样，9 的话将报错）
    let mut number = number * 9.0;

    //等价于 number = number / 2.0;
    number /= 2.0;

    //加、减法
    number -= 1.0;
    number += 2.0;

    println!("{}",number);
}

计算结果为：5.5
计算结果为：5.5

3、布尔型

布尔类型即为 bool，它具有 True （真）与 False（假）两种值。

1
2
3
4
5
6
7
8
9
10
fn main() {
    let number = 1;
    let test:bool = number > 10;
    if test {
        println!("1 大于 10");
    }
    else {
        println!("1 并不大于 10");
    }
}

输出为：1 并不大于 10

1 并不大于 10

4、字符类型

Rust 除了数字之外也是可以存储字母的。而 char 类型就是语言中最原生的字母类型。（''（单引号）表示 char，字符串采用""(双引号））

这里用 char 输出十个字母“ C”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn main() {
    //也可以隐式声明为 let c  = 'c';
    let c :char = 'c';

    //输出的次数
    const NUMBER:i32 = 10;
    //记录已输出的次数
    let mut count = 0;
    //输出
    while count < NUMBER {
        println!("{}",c);
        count += 1;
    }
}

共输出 10 次
Rust 的 char 类型的长度为四个字节，并代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。

二、复合

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

1、元组

为什么要有 元组 ？譬如一个人，他有姓名、升高及很多其它信息。而这些信息对于 Rust 来说并不是单一的类型（尽管它们都可以用字符串表示），通过元组可以很方便的表达这些信息。

1
2
3
4
fn main() {
    let people:(&str,f64) = ("小明",0.9);
    println!("{}的升高是：{}",people.0,people.1);
}

输出为：

在这里插入图片描述
可以看出，代码中的 people.0的可读性并不好，有什么更好的方式呢？

1
2
3
4
5
6
fn main() {
    let people:(&str,f64) = ("小明",0.9);
    //用模式匹配来解构元组
    let (name,height) = people;
    println!("{}的升高是：{}",name,height);
}

输出与之前一样，但代码的可读性更好了。

有点形式主义

２、数组

不同于 元组 ，数组 的每一个元素的类型都是 相同的 。

这里计算了是三个人的总升高：

1
2
3
4
5
6
7
8
fn main() {
    //同样，第二个 2.0 为 2 的话将报错。
    let heights = [2.1,2.0,2.4];

    let sum = heights[0] + heights[1] + heights[2];

    println!("这三个大汉的总身高是：{}",sum);
}

输出：

在这里插入图片描述
还可以这样声明数组

1
2
//具有 5 个元素的数组
let a: [i32; 5] = [1, 2, 3, 4, 5];

也可以这样：

1
2
//一个长度为 4 且每个元素为 -1 的数组。
let arr:[i32;4] = [-1;4];

既然每个数组都有个确定的长度，那么如何获取数组的长度呢？

下面演示了计算三个人的平均长度：

1
2
3
4
5
6
7
8
9
10
11
fn main() {
    //同样，第二个 2.0 为 2 的话将报错。
    let heights = [2.1,2.0,2.4];

    let sum = heights[0] + heights[1] + heights[2];

    //数组的长度是 usize 类型，这里强转为 f64 类型和 sum 类型相同
    let average = sum / (heights.len() as f64);

    println!("这三个大汉的平均身高是：{}",average);
}

输出：

在这里插入图片描述
——————

通过写博客掌握 Rust 的神级语法。

顺带丰富 Rust 资料……

二零二零年四月二十三日。