一、Rust介绍

Rust 是由 Mozilla 主导开发的高性能编译型编程语言，遵循"安全、并发、实用"的设计原则。

Rust 语言由 Mozilla 开发，首次发布于 2010 年。

Rust 支持多种编程范式，包括函数式、并发式、过程式和面向对象风格。

Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。

一、基础语法

1、变量

声明变量用 let 关键字。 默认情况下声明的变量不可变，除非使用mut关键字声明：

let a = 10; // 不可变变量
let mut a = 10; // 可变变量

2、常量

常量使用const关键字声明。 不可变变量和常量的区别：

// 编译不报错，会警告
let a = 123;
let a = 234;

// 不合法
const a = 123;
let a = 234;

3、数据类型

整数

位长度	有符号	无符号
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
arch	isize	usize
isize 和 usize 两种整数类型是用来衡量数据大小的，它们的位长度取决于所运行的目标平台，如果是 32 位架构的处理器将使用 32 位位长度整型。

浮点数

32 位浮点数（f32）和 64 位浮点数（f64）。 默认情况下 11.0 表示64位浮点数。

布尔型

用bool表示，值为 true 或 false。

字符型

用char表示，类型大小为 4字节。一般使用字符串储存UTF-8文字。 中文有GBK和UTF-8编码，要使用UTF-8编码才能正常编译。

复合类型

元组

用()包裹的一组数据，包含不同类型的数据。

let tup: (i32, f64, u8) = (500, 6.4, 2);
// tup.0 等于500
// tup.1 等于6.4
let (x, y, z) = tup;
// x等于500

数组

用[]包裹的一组数据，包含相同类型的数据。

let a = ["a", "b"];
let a: [i32, 3] = [22, 33, 44]; // 表示一个长度为3的32位有符号整数数组
// a[0] 等于22

4、运算符

不可以使用 ++和--

运算符	说明	示例	结果
+	加法	5 + 2	7
-	减法	5 - 2	3
*	乘法	5 * 2	10
/	除法（整除）	5 / 2	2 （整数）
%	取余	5 % 2	1

运算符	说明	示例	结果
==	相等	5 == 5	true
!=	不相等	5 != 2	true
>	大于	5 > 2	true
<	小于	5 < 2	false
>=	大于等于	5 >= 5	true
<=	小于等于	2 <= 5	true

运算符	说明	示例	结果
&&	逻辑与（AND）	true && false	false
||	逻辑或（OR）	true || false	true
!	逻辑非（NOT）	!true	false

运算符	说明	示例	结果
&	按位与	5 & 3	1
|	按位或	5 | 3	7
^	按位异或	5 ^ 3	6
!	按位取反	!5	-6
<<	左移	5 << 1	10
>>	右移	5 >> 1	2

运算符	说明	示例	结果
=	赋值	let mut x = 5; x = 3;	x = 3
+=	加并赋值	x += 2	x = x + 2
-=	减并赋值	x -= 2	x = x - 2
*=	乘并赋值	x *= 2	x = x * 2
/=	除并赋值	x /= 2	x = x / 2
%=	取余并赋值	x %= 2	x = x % 2
&= |= ^= <<= >>=	位运算复合赋值	x &= 2	类似

运算符	说明	示例
..	范围（不含右端）	0..5 产生 0 到 4
..=	范围（含右端）	0..=5 产生 0 到 5
as	类型转换	5 as f32
?	错误传播（在 Result 中）	some()?;
*	解引用	*ptr
&	取引用	&x
ref	绑定为引用	let ref y = x;

5、函数

函数表示：

fn <函数名> ( <参数> ) <函数体>

• Rust 函数名称的命名风格是小写字母以下划线分割
• Rust 中定义函数如果需要具备参数必须声明参数名称和类型
• Rust 中函数定义可以嵌套
• 函数表达式使用 {}包含一个块，不能使用return

let x = {
	let a = 1;
	a + 1
};
// x 输出为 2
// 最后的 a+1 不能以分号结尾，分号结尾的就是语句，不是表达式

• 函数返回值，在参数后面使用 -> 来声明返回值类型，不支持自动返回类型判断，没有声明返回类型，则表示函数是纯过程无返回

6、条件语句

fn main() { 
    let a = 12; 
    let b; 
    if a > 0 { 
        b = 1; 
    }  
    else if a < 0 { 
        b = -1; 
    }  
    else { 
        b = 0; 
    } 
    println!("b is {}", b); 
}

• 条件不需要()
• 不支持单语句代替一个块

7、循环语句

没有do-while，不能使用三元语句控制循环

while循环

fn main() {
    let mut number = 1; 
    while number != 4 { 
        println!("{}", number); 
        number += 1; 
    } 
    println!("EXIT"); 
}

for循环

fn main() { 
    let a = [10, 20, 30, 40, 50]; 
    for i in a.iter() { 
        println!("值为 : {}", i); 
    } 
}

fn main() { 
	let a = [10, 20, 30, 40, 50]; 
    for i in 0..5 { 
        println!("a[{}] = {}", i, a[i]); 
    } 
}

loop循环

fn main() { 
    let s = ['R', 'U', 'N', 'O', 'O', 'B']; 
    let mut i = 0; 
    loop { 
        let ch = s[i]; 
        if ch == 'O' { 
            break; 
        } 
        println!("\'{}\'", ch);
        i += 1; 
    } 
}

8、迭代器

创建迭代器：

• .iter()返回集合的不可变引用迭代器
• .iter_mut()返回集合的可变引用迭代器
• .into_iter()将集合转移所有权并生成值迭代器