本文专栏： Rust学习
目录
一，数据类型
1，标量类型
1.1，整型
按照比特位长度和有无符号分为以下几种：
|---------|-------|-------|
| 位长度 | 有符号 | 无符号 |
| 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 位位长度整型。
在数学运算上Rust不支持++和--
1.2，整型溢出
例如：u8的范围是0-255，如果把一个u8类型的变量设为256。那么：
在调试模式下：Rust会检查整数 溢出，如果发生溢出，程序在运行时就会panic
在发布模式下（--release）：Rust不会检查真书溢出。如果溢出，Rust会执行环绕操作，如256变成0，257变成1.
1.3，浮点数型
Rust支持32位浮点数和64位浮点数。64位精度更高。
f64是默认的精度类型
fn main()
{
let a=2.0; //f64
let b:f32=3.0; //f32
}
1.4，布尔类型
布尔型用bool表示，值只能为true或false
1.5，字符型
字符型用char表示，Rust的char类型大小为4个字节。
是Unicode标量值，可以表示比ASCLL多得多的字符内容，如拼音，中日韩文，emoji表情等等。
fn main()
{
let _x='z';
let _y:char='&';
let _z='😽';
println!("_z is {}",_z);
}
2，复合类型
2.1，Tuple(元组)
元组是用一对（ ）包括的一组数据，可以包含不同种类型的数据。
元组的长度是固定的。
访问Tuple元素：在Tuple变量后使用点标记法，后接元素的索引号。
fn main()
{
let tup:(i32,f64,u8)=(500,6.4,1);
println!("{} {} {}",tup.0,tup.1,tup.2);
}
获取Tuple的元素值：可以使用模式匹配来结构（destructure）一个Tuple获取元素值
fn main()
{
let tup:(i32,f64,u8)=(500,6.4,1);
//模式匹配
let (x,y,z)=tup;
println!("{} {} {}",x,y,z);
}
2.2，数组
数组中每个元素的类型必须是相同的。数组的长度也是固定的。
数组用一对 [ ] 包括的同类型数据。
let a=[1,2,3,4];
数组的类型可以以这种方式进行表示：[ 类型;长度 ]
let a[i32;5]=[1,2,3,4,5];
如果数组的每个元素都相同，那么可以在中括号里指定初始值。
let a[3;5]； 它就相当于[3,3,3,3,3]
访问数组的元素，使用下标访问
fn main()
{
// a 是一个长度为 5 的整型数组
let a = [1, 2, 3, 4, 5];
// 数组访问
let first = a[0];
let second = a[1];
}
二，函数
2.1，函数的声明
声明函数使用 fn 关键字
其中 Rust 函数名称的命名风格是小写字母以下划线分割：
fn main() {
println!("Hello, world!");
another_function();
}
fn another_function() {
println!("Hello, runoob!");
}
运行结果：
Hello, world!
Hello, runoob!
Rust不会在乎在何处定义了函数，只要定义了就可以使用，而C/C++的函数必须定义在调用者之前。
2.3，函数的参数
函数如果需要定义参数，必须声明类型
fn main() {
another_function(5, 6);
}
fn another_function(x: i32, y: i32) {
println!("x 的值为 : {}", x);
println!("y 的值为 : {}", y);
}
2.4，函数体的语句和表达式
**Rust函数体由一系列的语句组成，语句是执行某些操作并且没有返回值的步骤，**如：
let a = 6;
语句没有返回值，所以不可以let将一个语句赋给一个变量。
这个步骤没有返回值，所以以下语句不正确
let a = (let b = 2);
表达式是有返回值的。以下是表达式：
a = 7
b + 2
c * (a + b)
Rust 中可以在一个用 { } 包括的块里编写一个较为复杂的表达式：
fn main()
{
let x=5;
let y={
let x=3;
x+1 //这个表达式 就会作为返回值返回
};
println!("x is {}",x);
println!("y is {}",y);
}
在这个块中：
{
let x = 3;
x + 1
};
注意：x+1之后没有分号，如果有分号，将会变成一条语句，没有返回值
在整个块中，最后一个步骤是表达式，此表达式的结果值是整个表达式块结果值，这种表达式叫做函数体表达式。在块中，也可以使用函数语句。
如果在块的最后一个步骤加上分号，那么将成为一条语句，没有 返回值。
此时该表达式 块的返回值就是一个空元组（Tuple），也就是 ( )。无法打印出来
{
let x = 3;
x + 1;//（）
};
2.5，函数的返回值
在参数声明之后用 -> 来声明函数返回值的类型。
在函数体中，随时都可以以 return 关键字结束函数运行并返回一个类型合适的值。
大多数函数都是使用最后一个表达式作为默认的返回值的。
fn add(a: i32, b: i32) -> i32 {
return a + b;
}
注意：函数体表达式不同于函数体，它不能使用return关键字。
在Rust中，函数可以嵌套定义。
fn main() {
fn five() -> i32 {
5
}
println!("five() 的值为: {}", five());
}
三，条件语句
if 后的变量必须是bool类型的，Rust不会像C语言一样将它转化位bool类型，会直接报错。
fn main()
{
let number=3;
if number<5
{
println!("condition was true");
}
else
{
println!("condition was false");
}
}
条件表达式 number < 5 不需要用小括号包括。
但是 Rust 中的 if 不存在单语句不用加 {} 的规则，不允许使用一个语句代替一个块。
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);
}
因为if是一个表达式，所以可以将他放在let语句等号的右边。
fn main()
{
let condition=true;
let number=if condition {5} else {6};
println!("number is {}",number);
}
其中if 和else块中的返回值类型必须相同。如果不同，那么在编译的时候就无法确定number的类型。
四，循环
1，while循环
fn main() {
let mut number = 1;
while number != 4 {
println!("{}", number);
number += 1;
}
println!("EXIT");
}
2，for循环
fn main() {
let a = [10, 20, 30, 40, 50];
for i in a.iter() {
println!("值为 : {}", i);
}
}
Range由标准库提供，指定一个开始数字和一个结束数字，Range可以生成他们之间的数字，不包含结束数字。rev方法可以反转Range。示例：
fn main()
{
for number in 1..4
{
println!("number is {}",number);
}
}
fn main()
{
for number in (1..4).rev()
{
println!("number is {}",number);
}
}
3，loop循环
Rust 语言有原生的无限循环结构 ------ loop
可以在loop循环里使用break关键字，告诉程序何时停止循环。
fn main()
{
let mut counter=0;
let result=loop{
counter+=1;
if counter==10
{
break counter*2; //返回counter*2
}
};
println!("result is {}",result);
}
