RUST 0x01 数据类型

Posted 2020-11-30 wr786

RUST 0x01 数据类型

1 变量与可变性

先上两段代码和一段错误信息：

fn main() {
    let x = 5;
    println!("The value of x is: {}",x);
    x = 6;
    println!("The value of x is: {}",x);
}

error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("The value of x is: {}", x);
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

fn main() {
    let mut x = 5;
    println!("The value of x is: {}",x);
    x = 6;
    println!("The value of x is: {}",x);
}

let是函数式语言中的绑定(binding)，而不是赋值(assignment)

• let→使前者绑定后者，且前者不能再被改变

• mut→可变的（mutable）

• let mut→使前者绑定后者，但前者可以改变

变量与常量间的区别

• 使用const定义常量的时候 必须 将常量的数据类型注明。

• 常量可以在任何区域声明，包括全局。

• 常量只能被定义为一个常表达式，而不能是一个函数的返回值或者其他只能在运行中被计算出来的值。

• 常量的命名规范：大写字母、数字、下划线。为了提高可读性，可以在定义的数字之中加入下划线，如：

const MAX_POINTS: u32 = 100_000;

这种情况下，MAX_POINTS的值就是100000。

Shadowing

shadow一个变量：利用相同的变量名并再次使用let，如：

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("The value of x is: {}", x);
}

> cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs
     Running `target/debug/variables`
The value of x is: 12

shadowing与用mut标记变量不同，因为我们如果不使用let，就会CE（Compile-time Error）。

我们可以利用shadow对一个不可变的变量进行一些变换。在shadow之后，该变量仍然是不可变的。

shadow与mut的另一个不同之处在于：当我们再次使用let时，我们相当于是有效地创建了一个新的变量，我们可以在使用相同的变量名的同时改变变量的数据类型，比如：

let spaces = "   ";
let spaces = spaces.len();

而如果使用的是mut，就会跳出CE：

error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected &str, found usize
  |
  = note: expected type `&str`
             found type `usize`

2 数据类型

Rust是静态类型语言。所以编写代码时应该注意标记数据类型。

数字类型

Rust有四种基本数字类型：整数，浮点数，逻辑量和字符。

整数类型

长度(Length)	带符号(Signed)	无符号(Unsigned)
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
arch	isize	usize

每个变量都具有具体的大小(size)，而且要么带符号，要么无符号。

带符号变量可存储的数字大小：
[ [-(2^{n-1}),2^{n-1}-1],n=二进制位数(bits) ]
无符号变量可存储的数字大小：
[ [0,2^n-1],n=二进制位数(bits) ]
比如i8就是[-128, 127]。

此外，isize和usize类型的二进制位数是由运行的计算机决定的。如果是在64位计算机上运行就是64位，如果是在32位计算机上运行就是32位。

在Rust中，可以在代码中用如下方式表示要表达的数字。

数字表示方法(Number literals)	示例
十进制(Decimal)	98_222
十六进制(Hex)	0xff
八进制(Octal)	0o77
二进制(Binary)	0b1111_0000
字节(Byte) (u8 only)	b‘A‘

而且除了字节，所有数字表示方法都允许加入标注类型的后缀比如57u8以及分隔符_比如1_000。

整数类型默认为i32，因为i32无论在64位系统还是32位系统都是运行得最快的。

浮点类型

Rust有两种基本浮点类型：f32、f64

浮点类型默认为f64，因为现代的CPU运算f64的速度和f32几乎一样快，但却有更高的精度。

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

f32是单精度浮点数，f64是双精度浮点数。

数字运算

Rust提供基本数字运算：加、减、乘、除、取余。

fn main() {
    let sum = 5 + 10;  //加
    let difference = 95.5 - 4.3;  //减
    let product = 4 * 30;  //乘
    let quotient = 56.7 / 32.2;  //除
    let remainder = 43 % 5;  //模
}

逻辑类型

bool。大小只有一个字节。

两种值：true和false。

fn main() {
    let t = true;
    let f: bool = false; // 有具体的类型标示
}

字符类型

char。用单引号‘‘。

fn main() {
    let c = 'z';
    let z = '?';
    let heart_eyed_cat = '??';
}

Rust里的char，大小四字节，能表示Unicode数值。

也就是说它可以表示不只ASCII字符，还有古字母、中文、日本语、韩语、emoji以及宽度为0的空格。

Unicode数值的数据范围为[U+0000,U+D7FF]、[U+E000,U+10FFFF]。

复合类型

Rust有两种基本复合类型：元组(tuples)和数组(arrays)。

元组类型(The Tuple Type)

Tuple可以将多个可以是不同类型的值组合进一个复合类型。

Tuple具有固定的长度(length)，一旦声明就不能增长或缩短。

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

变量tup绑定(bind)了整个tuple。如果要取得一个tuple里的某个数据，可以如下：

fn main() {
    let tup = (500, 6.4, 1);
    let (x, y, z) = tup; //解构(destructuring)
    println!("The value of y is: {}", y);
}

除了模式匹配解构外，也可以使用.+索引(index)来访问tuple里的元素。

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);
    let five_hundred = x.0;
    let six_point_four = x.1;
    let one = x.2;
}

index从0开始。

数组类型(The Array Type)

不同于tuple，数组中的元素必须是相同数据类型的。

且不同于一些其他的语言，Rust中的数组是具有固定长度的。

fn main() {
    let a = [1, 2, 3, 4, 5];
}

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

数组的数据类型的写法：[元素类型; 元素个数]

let a: [i32; 5] = [1, 2, 3, 4, 5];

初始化一个每个元素均为同一数值的数组：

let a = [3; 5];// let a = [3, 3, 3, 3, 3];

访问数组元素：

fn main() {
    let a = [1, 2, 3, 4, 5];
    let first = a[0]; //1
    let second = a[1]; //2
}

如果index越界，则会编译通过，但是在运行时会自动退出并抛出一个RE(Runtime Error)。

参考

The Rust Programming Language by Steve Klabnik and Carol Nichols, with contributions from the Rust Community : https://doc.rust-lang.org/book/