Rust 有很多类型是原始类型,也就是说这些数据类型是内置的。

布尔型(Boolean)

Rust 内置了布尔类型:bool,布尔类型只有两个值:true 和 false。

let x = true;
let y: bool = false;

布尔类型通常可以用在 if 条判断中。

字符(char)

字符的值是单一 Unicode 标量值,通过单引号创建字符,如:

let x = 'x';
let two_hearts = '💕';

和其他语言不同,Rust 的字符不是单个字节,而是四个字节。

数字类型(Numeric types)

Rust 有很多种数字类型,可以分为:有符号型(signed)、无符号型(unsigned)、固定长度类型(fixed)、可变长度类型(variable)、浮点类型(floating-point)和整数型(integer)。

这些类型包含两个部分:类型和大小。比如:u16 表示 16 位大小的无符号类型数字,位越多能表示的数字就越大。

如果定义的变量没有指明其类型,那么会指定为默认类型,如:

let x = 42;  // 默认整数类型是 i32
let y = 1.0; // 默认浮点数类型是 f64

Rust 中的数字类型有:

i8  i16  i32  i64  isize
u8  u16  u32  u64  usize
f32  f64

有符号型和无符号型

整数型分为两类:有符号型和无符号型。比如,对于四位大小(二进制),有符号的整数只能表示 - 8 到 7,而无符号的整数则可以表示 0 到 15。

固定长度类型

固定长度类型有一个特定数字表示其类型位长度,有效的长度是 8,16,32,64。所以,u32 表示无符号长度为 32 位的整数,i64 表示有符号长度为 64 的整数。

可变长度类型

Rust 还提供了一种类型, 它的长度取决于底层机器的指针的大小。用 size 表示位长,同样的,i 表示有符号型,u 表示无符号型,所以可变长度类型有两种:isize 和 usize。

浮点类型

Rust 有两种浮点类型:f32 和 f64。这对应于 IEEE-754 标准和双精度数字。

数组(Array)

和大多数编程语言一样,Rust 也有列表类型来表示一系列事物,最基础的就是数组,一个元素类型相同的定长列表,默认数组时不可变的。

let a = [1, 2, 3]; // a: [i32; 3]
let mut m = [1, 2, 3]; // m: [i32; 3]

我们可以很简单的把数组的所有值都设置为同一个数字,下面的数组长度为 20,初始化后每个元素都是 0:

let a = [0; 20]; // a: [i32; 20]

通过 a.len()获取数组长度:

let a = [1, 2, 3];
println!("a has {} elements", a.len());

通过脚标获取数组元素:

let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3]
println!("The second name is: {}", names[1]); // Brian

和大多数编程语言一样,脚标是从 0 开始的,所以第一个 name 是 name[0]。

切片(Slices)

一个切片是对另一个数据结构的引用。这允许没有复制数组的情况下安全高效的访问数组的一部分内容。比如,你想要把一个文件中的某行内容读入到内存中。自然,切片不是直接创建的,而是来自一个已经存在的变量绑定。切片定义了一个长度,可以是可变的或者不可变的。

通过 & 和 [] 创建切片,& 表示式引用,[]可以定义切片的长度。如:

let a = [0, 1, 2, 3, 4];
let complete = &a[..]; // A slice containing all of the elements in a
let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3

str

Rust 中的 str 是最原始的字符串类型,作为无符号类型,它本身没什么用,但是在引用中会变得很有用,如:&str。

元组(tuples)

元组是一个有序的定长列表,如:

let x = (1, "hello");

这是一个长度为 2 的元素,用小括号表示,元素之间通过逗号隔开。下面是完全相同的元素,只不过声明了类型:

let x: (i32, &str) = (1, "hello");

如你所见,类型声明的方式和元组一样,也是用的小括号,只不过每一项用的类型名而不是值。

如果两个元组长度相同,参数数量相同,那么可以把一个元组赋值给另一个元组。如果元组的参数数量相同,那么它们的长度也相同。

let mut x = (1, 2); // x: (i32, i32)
let y = (2, 3); // y: (i32, i32)
x = y;

let 可以通过元组声明变量,如:

let (x, y, z) = (1, 2, 3);
println!("x is {}", x);

如果元组只有一个元组,需要加一个逗号消除歧义:

(0,); // 只有一个元素的元组
(0);  // 括号中的数字 0

访问元组的元素:

let tuple = (1, 2, 3);

let x = tuple.0;
let y = tuple.1;
let z = tuple.2;

println!("x is {}", x);

脚标也是从 0 开始的,不过访问的方式和数组不同,有点奇怪。

函数

函数也有类型,如:

fn foo(x: i32) -> i32 { x }

let x: fn(i32) -> i32 = foo;

这里,x 是一个函数指针,指向一个接受 i32 类型数字的参数并返回 i32 类型数字的函数。

参考链接:https://doc.rust-lang.org/stable/book/primitive-types.html