变量与可变性

声明变量使用let关键字，默认情况下，变量是不可变的（Immutable）。声明变量时，在变量前面加上mut，就可以使变量可变。

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

    x = 6;
    println!("The value of x is {}",x);
}

变量与常量

常量（constant），常量在绑定值以后也是不可变的，但是它与不可变的变量有很多区别：

• 不可以使用mut，常量永远都是不可变的；
• 声明常量使用const关键字，它的类型必须被标注；
• 常量可以在任何作用域中进行声明，包括全局作用域；
• 常量只可以绑定到常量表达式，无法绑定到函数的调用结果或只能在运行时才能计算出的值。

在程序运行期间，常量在其声明的作用域内一直有效。命名规范：Rust里常量使用全大写字母，每个字母用下划线分开，例如：MAX_POINTS。

const MAX_POINTS:u32 = 100_000;

Shadowing（隐藏）

可以使用相同的名字声明新的变量，新的变量就会shadow（隐藏）之前声明的同名变量，在后续的代码中这个变量名代表的就是新的变量。

shadow和把变量标记为mut是不一样的：如果不使用let关键字，那么重新给非mut的变量赋值会导致编译时错误；而使用let声明的同名新变量，也是不可变的。使用let声明的同名新变量，它的类型可以与之前不同。

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

数据类型

rust是静态编译语言，在编译时必须知道所有变量的类型。基于使用的值，编译器通常能够推断出它的具体类型。但如果可能的类型较多（例如把String转为整数的parse方法），就必须添加类型的标注，否则就会报错。

标量类型

一个标量类型代表一个单个的值，Rust有四个主要的标量类型：整数类型，浮点类型，布尔类型，字符类型。

1.整数类型

整数类型没有小数部分，例如u32就是一个无符号的整数类型，占据32位空间。无符号整数以u开头，有符号整数以i开头。rust的整数类型列表如图：

每种都分i和u，以及固定的位数。有符号范围：-2^n-1到 2^n-1-1。无符号范围：0到2ⁿ-1。

isize和usize类型的位数由程序运行的计算机的架构所决定：如果是64位计算机，那就是64位的。使用isize或usize的主要场景是对某种集合进行索引操作。

整数的字面值如图所示：

除了byte类型外，所有的数值字面值都允许使用类型后缀。如果你不太清楚应该使用哪种类型，可以使用Rust相应的默认类型：整数的默认类型就是i32，总体上来说速度很快，即使在64位系统中。

整数溢出：例如u8的范围是0~255，如果你把一个u8变量的值设为256，那么调试模式下编译，Rust会检查整数溢出，程序在运行时就会panic；发布模式下（–release）编译，Rust不会检查可能导致panic的整数溢出，如果溢出发生，Rust会执行环绕操作，256变成0，257变成1，但程序不会panic。

2.浮点类型

Rust有两种基础的浮点类型，也就是含有小数部分的类型。

• f32，32位，单精度
• f64，64位，双精度

Rust的浮点类型使用了IEEE-754标准来表述，f64是默认类型，因为在现代CPU上f64和f32的速度差不多，而且精度更高。

3.布尔类型

Rust的布尔类型也有两个值：true和false。一个字节大小，符号是bool。

4.字符类型

Rust语言中char类型被用来描述语言中最基础的单个字符。字符类型的字面值使用单引号，占用4字节大小，是Unicode标量值，可以表示比ASCII多得多的字符内容：拼音、中日韩文、零长度空白字符、emoji表情等。Unicode标量值的范围是U+0000到U+D7FF，U+E000到U+10FFFF。但是Unicode中并没有字符的概念，所以直觉上认为的字符也许与Rust中的概念并不相符。

复合类型

复合类型可以将多个值放在一个类型里。Rust提供了两种基础的复合类型：元组（Tuple）、数组。

1.Tuple

Tuple可以将多个类型的多个值放在一个类型里，Tuple的长度是固定的，一旦声明就无法改变。可以使用模式匹配来解构（destructure）一个Tuple来获取元素的值。

let tup: (i32, f64, u8)=(100, 6.4, 1);
println!("{},{},{}", tup.0, tup.1, tup.2);
let (x, y, z) = tup;
println!("{},{},{}", x, y, z);

2.数组

数组也可以将多个值放在一个类型里，数组中每个元素的类型必须相同。如果想让你的数据存放在stack（栈）上而不是 heap（堆）上，或者想保证有固定数量的元素，这时使用数组更有好处。数组是Stack上分配的单个块的内存，可以使用索引来访问数组的元素。如果访问的索引超出了数组的范围，那么编译会通过，运行会报错（runtime时会panic），Rust不会允许其继续访问相应地址的内存。

let a: [i32; 5]=[1, 2, 3, 4, 5];
println!("{},{},{}", a[1], a[2], a[3]);

函数

声明函数使用fn关键字，依照惯例，针对函数和变量名，Rust使用snake case命名规范，所有的字母都是小写的，单词之间使用下划线分开。

fn main() {
    another_function();
}

fn another_function() {
    println!("Another function")
}

如果有参数，必须声明每个参数的类型。

fn main() {
    another_function(5);
}


fn another_function(x:i32) {
    println!("The value of x is:{}", x);
}

函数由一系列语句组成，可选的由一个表达式结束。Rust是一个基于表达式的语言，语句是执行一些动作的指令，表达式会计算产生一个值。函数的定义也是语句，语句不返回值，所以不可以使用let将一个语句赋给一个变量。

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

在->符号后声明函数返回值的类型，但是不可以为返回值命名。在Rust里面，返回值就是函数体里面最后一个表达式的值，若想提前返回，需要使用return关键字，并指定一个值。大多数函数都是默认使用最后一个表达式为返回值。

fn five()->i32{
    5
}

fn plus_five(x: i32)->i32{
    x + 5
}

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

    let x = plus_five(5);
    println!("The value of x is {}",x);
}

if表达式

if表达式允许您根据条件执行不同的代码分支，这个条件必须是bool类型。if表达式中，与条件相关联的代码块就叫分支（arm）。可选的，在后边可以加上一个else表达式。

fn main() {
    let number = 3;
    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

如果使用多个else if。那么最好使用match来重构代码。

fn main() {
    let number = 3;
    match number < 5 {
        true => println!("condition was true"),
        false => println!("condition was false"),
    }
}

因为if是一个表达式，所以可以将它放在let语句中等号的右边。

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("The value of number is {}", number);
}

循环

1.loop

loop关键字告诉Rust反复的执行一块代码，直到你喊停。

fn main() {

    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("The value of result is {}", result);
}

2.while

另外一种常见的循环模式是每次执行循环体之前都判断一次条件。while条件循环为这种模式而生。

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number = number - 1;
    }
}

3.for

使用for循环遍历集合。可以使用while或loop来遍历集合，但是易错（索引超出集合大小）且低效（每次循环判断条件是否成立）。使用for循环更简洁紧凑，它可以针对集合中的每个元素来执行一些代码。由于for循环的安全、简洁性，所以它在Rust中用的最多。

fn main() {
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is {}", element);
    }
}

使用for循环实现上述while循环内容，标准库提供range，指定一个开始数字和结束数字，range可以生成它们之间的数字（不含结束），rev方法可以反转range。

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
}