【 Rust 基础】数据类型 —— Rust 的神级语法02
前言：
在 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 的速度几乎一样，但具有更高的精度。
目前这些数字类型都支持基本的数学运算：加法、减法、乘法、除法 和 取余 。进行这些数学运算的表达方式与其它语言相似：
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
3、布尔型
布尔类型即为 bool，它具有 True （真）与 False（假）两种值。
fn main() {
let number = 1;
let test:bool = number > 10;
if test {
println!("1 大于 10");
}
else {
println!("1 并不大于 10");
}
}
输出为：1 并不大于 10
4、字符类型
Rust 除了数字之外也是可以存储字母的。而 char 类型就是语言中最原生的字母类型。（''（单引号）表示 char，字符串采用""(双引号））
这里用 char 输出十个字母“ C”。
fn main() {
//也可以隐式声明为 let c = 'c';
let c :char = 'c';
//输出的次数
const NUMBER:i32 = 10;
//记录已输出的次数
let mut count = 0;
//输出
while count < NUMBER {
println!("{}",c);
count += 1;
}
}
Rust 的 char 类型的长度为四个字节，并代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。
二、复合
复合类型（Compound types） 可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple） 和 数组（array）。
1、元组
为什么要有 元组 ？譬如一个人，他有姓名、升高及很多其它信息。而这些信息对于 Rust 来说并不是单一的类型（尽管它们都可以用字符串表示），通过元组可以很方便的表达这些信息。
fn main() {
let people:(&str,f64) = ("小明",0.9);
println!("{}的升高是：{}",people.0,people.1);
}
输出为：
可以看出，代码中的 people.0的可读性并不好，有什么更好的方式呢？
fn main() {
let people:(&str,f64) = ("小明",0.9);
//用模式匹配来解构元组
let (name,height) = people;
println!("{}的升高是：{}",name,height);
}
输出与之前一样，但代码的可读性更好了。
有点形式主义
２、数组
不同于 元组 ，数组 的每一个元素的类型都是 相同的 。
这里计算了是三个人的总升高：
fn main() {
//同样，第二个 2.0 为 2 的话将报错。
let heights = [2.1,2.0,2.4];
let sum = heights[0] + heights[1] + heights[2];
println!("这三个大汉的总身高是：{}",sum);
}
输出：
还可以这样声明数组
//具有 5 个元素的数组
let a: [i32; 5] = [1, 2, 3, 4, 5];
也可以这样：
//一个长度为 4 且每个元素为 -1 的数组。
let arr:[i32;4] = [-1;4];
既然每个数组都有个确定的长度，那么如何获取数组的长度呢？
下面演示了计算三个人的平均长度：
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 资料……
二零二零年四月二十三日。