rust学习（三）通用编程主要语法和理解

（3.1）变量和可变性

1.变量

变量用“let”声明

let hao =1; //不可变变量

let mut hao =1; //可变变量

2.常量

常量用“const”声明，且常量名称都用大写字母，运行时必须指定类型（rust默认i32）

例如：const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3; //32位无符号数字型常量

3.遮蔽：

例如：

let x = 5;

let x = x+1;

（我的理解是，不可变变量x可以通过自己变，不能从外部变，即x指向的地址中的内容可以变，但不能从外部操作改变，和上节的理解也差不多；而常量是锁定，怎样都不会变）

4.let mut（可变变量）与let（不可变变量）的区别

可变变量：可通过外部变（即绑定一个新的地址），值类型不可变，（即它可以使用地址内内容，但不能改变地址内的内容。）

不可变变量：不能通过外部变（只能通过指定地址的内容的改变而变化），值类型可变（地址内什么类型都可以存储，某种意义上，它还是没变，但表现形式变了）

即：

let mut x = 1;
let mut x = x+1;
//x代表的是值本身，操作对象是个数字，所以值类型不可变

let x = 1;
let x = x+1;
//x代表的是存储1的地址，操作对象是地址内的内容，所以值类型可变

（以上是我自己的理解，如有不对请指正，如果以后发现什么问题，也会回来修改的）

5.spaces.len()：对字符串型的空格计数

（3.2）数据类型

类型分为标量类型和复合类型。rust是静态类型的语言，即需预先指定所有变量的类型

1.标量类型：单个值

四个基本的标量类型：整型、浮点型、布尔型和字符。

1.1整数：长度有8、16、32、64、128位和arch，均分为i（有符号）、u（无符号）类型，但arch的i形式为isize，u为usize。表示范围和c一样

isize 和 usize 类型取决于程序运行的计算机体系结构，长度表示为“arch”：若使用 64 位架构系统则为 64 位，若使用 32 位架构系统则为 32 位。

 数字+类型：某类型数字；例如：57u32 与57u64，不是同一个量

 数字字面量还可以使用 _ 作为可视分隔符以方便读数，如 1_000，此值和 1000 相同。

 大于该类型最大值的数值会被“包裹”成该类型能够支持的对应数字的最小值。比如在u8的情况下，256 变成 0，257 变成 1，依此类推。（类似闭环圆）

1.2浮点数：f32和f64，rust默认f64；所有浮点型都是有符号的。

fn main() {
    let x = 2.0; //f64

    let y: f32 = 3.0; //f32
}

1.3数字运算：和C一样，加法、减法、乘法、除法和取模运算

1.4布尔型：true和 flase，使用bool声明，例如：let f: bool = false;

1.5字符类型：char，用单引号声明，例如：let heart_eyed_cat = '😻';，Rust的字符类型大小是4个字节，可表示：ASCII、标音字母、中文/日文/韩文的文字，emoji，还有零宽空格(zero width space)

2.复合类型：将多个值组合成一个类型

两种基本的复合类型：元组和数组。

2.1元组类型：没有任何值的元组或只有一个值，都可写为“()”，“()”被称为单元值，如果表达式不返回任何其他值，就隐式地返回单元值。

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);
    //定义后长度不可变，其中每个元素可定义不同类型
    let five_hundred = x.0;
    //排序从0开始，依次类推
    let six_point_four = x.1;

    let one = x.2;
}

2.2数组类型：每个元素必须具有相同的类型

fn main() {
    let a = [1, 2, 3, 4, 5];//或下面
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
    let a = [3; 5];
     //=   let a = [3, 3, 3, 3, 3];
    let first = a[0];
     //访问数组
    let second = a[1];
}

如果访问超出长度的数组，Rust会立即退出来的方式防止这种错误，而不是允许内存访问并继续运行程序（类似自夸，但怕以后概念不清，还是加上了）

（3.3）函数

1.函数

fn：声明新函数；main：主函数（前面记录过，但这里应该会系统一点，还是加上了）

定义函数位置和C相同，就不赘述了

2.参数：在函数签名时，必须声明每个参数的类型

形参：参数；实参：参数提供的值；

fn main() {
    print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    //多个参数，逗号分开，每个参数声明类型
    println!("The measurement is: {}{}", value, unit_label);
}

3.语句和表达式：

语句：不返回值；表达式：返回值

fn main() {
    let y = {
        let x = 3;
        x + 1//如果表达式中，被操作对象在内部定义，则不需要加分号
    };
//可以把{}及内部所有，当作一个整体，外部有分号，内部结尾就不需要有
    println!("The value of y is: {}", y);
}

4.带有返回值的函数

可以向调用它的代码返回值。我们并不对返回值命名，但要在箭头“->”后声明它的类型

使用return关键字和指定值，可从函数中提前返回；但大部分函数隐式的返回最后的表达式

fn num(x:i32) -> i32 {
    5;6;7
}

fn main() {
    let x = num(1);//等于num函数中第二个数字

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

（3.4）注释：//：单行及以后，或 /*内容*/

（3.5）控制流：（条件语句）

1.if 、else if：

    if 条件语句1 {
    行为语句1;
    }else if 条件语句2 {
    行为语句2;
    }……else{
    行为语句n；
    }
    //if表达式的各值类型需相同

let语句也可使用if ：let number = if 条件 { 参数1 } else { 参数2 };，即number是符合条件的值

2.循环

 三种循环：loop、while、for

2.1 loop循环

//'循环名称: loop，可命名循环，则break相应变为，break  '循环名称;
    'counting_up: loop {//标志'counting_up循环开始
        其他语句
        if 条件语句{
         break 'counting_up;//标志'counting_up循环结束
         }
    }
//break; 退出循环，break 作出操作; 则返回对应操作的值

break：退出循环、continue：结束本次循环，开始下次循环

2.2 while条件循环：

while 条件语句 { 执行语句; }，可组合loop、if、else、break

3.3 for 循环：对一个集合的每个元素执行一些代码

fn main() {
    for number in (1..4).rev() {
        //倒计时3，2，1
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}
//或
fn main() {
    let a = [3,2,1];

    for element in a {
        println!("{}!", element);
    }
}

rev() ：用来反转区间