rust 笔记之变量与函数

变量

默认为不可变变量，一旦绑定赋值将不再允许改变。

1

let x=1;//默认推断为i32类型

定义为可变变量后变量可被随意改变。

1

let mut x=1;

常量与变量的区别

常量的一旦定义不可再变。
用 const 声明，不能用 mut修饰。
常量可以在任何作用域中声明。
在编译期确定值，而变量在运行期确定值。
常量使用全大写字母作为名称，下划线_隔开单词。

隐藏（Shadowing）

可通过隐藏变量对一个不可变变量“重新赋值”，实质上是重新定义了一个新的变量。

1
2
3
4
5
6
7
8
9


fn main() {
    let x = 5;

    let x = x + 1;

    let x = x * 2;

    println!("The value of x is: {}", x);//  x 的值最终为12
}

数据类型

标量

整型：

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

每一个有符号的变体可以储存包含从 -(2n - 1) 到 2n - 1 - 1 在内的数字，这里 n 是变体使用的位数。所以 i8 可以储存从 -(27) 到 27 - 1 在内的数字，也就是从 -128 到 127。
无符号的变体可以储存从 0 到 2n - 1 的数字，所以 u8 可以储存从 0 到 28 - 1 的数字，也就是从 0 到 255。
isize 和 usize 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的， 32 位架构上它们是 32 位的。
整形字面值：

数字字面值例子

Decimal (十进制) 98_222

Hex (十六进制) 0xff

Octal (八进制) 0o77

Binary (二进制) 0b1111_0000

Byte (单字节字符)(仅限于u8) b'A'
除 byte 以外的所有数字字面值允许使用类型后缀，例如 57u8，同时也允许使用 _ 做为分隔符以方便读数，例如 1_000。
debug 构建中 rust 会检查整形溢出并报错。
release 构建中不会检查溢出，会进行二进制补码包装。u8 赋值 256 会变成 0，赋值 257 会变成 1，以此类推。标准库 wrapping 类型显示这种行为。

数字字面值	例子
Decimal	(十进制)	98_222
Hex	(十六进制)	0xff
Octal	(八进制)	0o77
Binary	(二进制)	0b1111_0000
Byte	(单字节字符)(仅限于u8)	b'A'

浮点型

f32 和 f64 两个浮点数据类型。
默认 f64 类型，因为在现代 cpu 中性能差异不大的前提下 f64 精度更高。
基本运算:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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。

1
2
3
4
5


fn main() {
    let t = true;

    let f: bool = false; // 显式指定类型注解
}

字符类型

字符串用双引号引起来。
单引号表示 char 类型，大小为 4 个字节，代表一个 Unicode 标量值但是又有所区别，是 rust 特有的原生字符类型。

复合类型

多个值组合的类型。包含元组（tuple）和数组（array）两个原生复合类型。

元组

元素可包含不同类型，声明后长度不可变。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


fn main() {
    // 声明并赋值
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    // 赋值
    let tup = (500, 6.4, 1);
    // 取值，使用模式匹配（pattern matching）来解构（destructure）元组值
    let (x, y, z) = tup;
    println!("The value of y is: {}", y);
    // 还可以使用 . 运算符取值
    let five_hundred = x.0;
    let six_point_four = x.1;
    let one = x.2;
}

数组类型

区别于元组，数组的元素类型必须是相同的。长度不可变，标准库中提供 vector 类型可实现可变长度数组。
声明方式:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


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];
    // 长度为 5 每个元素的值都是 3，等同于 let a = [3, 3, 3, 3, 3];
    let a = [3; 5];
    // 读取元素  
    let first = a[0];
    let second = a[1];
}

下标溢出时编译期不会出错但是会产生 runtime 错误。

函数

基本函数结构

1

fu another_function(x: i32){}

名称都是小写字母构成,用下划线 _ 隔开单词。
函数体由一系列的语句和一个可选的结尾表达式构成。
语句指没有返回值的指令，如let y = 6;，表达式执行一些计算操作并且有返回值。
不能将语句赋值给变量。
语句可以包含表达式，一般的语句以 ; 结束，表达式后面不跟分号。
rust 是一个基于表达式的语言。

具有返回值的函数

1
2
3
4
5
6
7
8
9


// 该函数在 rust 中有效，返回 5
// 但是函数内容必须是一个表达式，不能在末尾添加分号
fn five() -> i32 {
    5
}
// 以元组返回
fn five() -> (i32,u8) {
    (1,2)
}

可以用 return 提前返回值。

rust 笔记之变量与函数

相关文章：