常见编程概念-Rust

变量可变性

let声明变量

image-20241202164311818

image-20241202164845322

const声明常量，常量规范全大写

image-20241202165455448

隐藏shadowing

shadowing可以改变原有变量的类型，例如字符串可以被重新修改为整数型

image-20241202165746985

Rust是静态编译语言，编译时必须确认所有数据类型，编译器根据变量的值通常可以自己判断一些类型

但是如果调用了一些方法进行数据类型转换就需要添加具体类型的标注

1
2
3
4
5
6
fn main() {
   
   let test:i32 = "200".parse().expect("error...");//parse方法是一个非常常用的方法，它用于将字符串（&str）转换为其他类型

   println!("{}",test);
}

image-20241202171637263

标量类型

整数类型

整数类型的大小

image-20241202172453356

1
2
3
4
5
6
fn main() {
   
   let test:u32 = 200;//无符号整数类型，占据32位空间，无符号以u开头，有符号以i开头

   println!("{}",test);
}

isize与usize根据计算机位数来定，如果是64位计算机那么isize就是i64，需要注意的是在调试模式下如果尝试进行整数溢出那么程序会panic(运行时异常)

浮点类型

请忽略注释

image-20241202173144767

布尔类型

image-20241202173356376

字符类型

image-20241202173547541

复合类型

复合类型可以将多个值放在一个类型里

元组

使用let声明，小括号赋值，如果不添加类型编译器会自动帮忙识别可识别的默认类型，可以添加不同类型的数据

image-20241202174119851

image-20241202174413162

数组

数组中的元素类型必须一致，长度固定

image-20241202175150666

1
2
3
4
5
6
7
fn main() {
   
   let a = [3;5];//等于let a =[3,3,3,3,3];


  
}

访问数组元素

image-20241202175543624

访问数组元素越界的话Rust会禁止访问相关内存

main函数

fn用于声明函数，函数声明在main函数之后，但是在main函数里照样可以调用

image-20241203100527738

添加参数

在函数声明里需要指明类型

image-20241203100753337

image-20241203102046104

语句与表达式，函数的定义过程就可以称为语句，表达式需要一个具体的值

• 表达式：在 Rust 中，表达式是用来计算值的代码片段。它们可以是简单的，比如一个数字或者变量，也可以是复杂的，比如函数调用或者算术运算。表达式总是有返回值。

• 语句：语句是执行动作但不返回值的代码片段。它们用来控制程序的流程，比如声明变量（ let ）、条件分支（ if ）、循环（ for 、 while ）等。语句通常以分号结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
fn main() {
    // 这是一个语句：它声明了一个变量 `number` 并初始化为 5。
    // 这个语句没有返回值。
    let number = 5;

    // 这是一个表达式：它计算两个数的和，并返回结果。
    // 这个表达式有一个返回值，即 10。
    let sum = number + 5;

    // 打印结果，这是一个表达式，因为它返回一个需要打印的值。
    println!("The sum is: {}", sum);

    // 这是一个语句：它是一个控制流结构，没有返回值。
    if sum > 10 {
        println!("The sum is greater than 10.");
    } else {
        println!("The sum is not greater than 10.");
    }

    // 这是一个语句：它执行一个代码块，并绑定变量 `result` 到代码块的最后一个表达式的值。
    let result = {
        // 这是一个表达式：它计算两个数的乘积，并返回结果。
        2 * 3
    };

    // 打印结果，这是一个表达式，因为它返回一个需要打印的值。
    println!("The result is: {}", result);
}

返回值

Rust函数的返回值类型使用箭头定义在函数之后，返回值不可以命名

默认函数最后一个表达式的值为返回值

使用return可以提前返回数值

1
2
3
4
5
6
7
8
9
10
11
fn test() -> i32{
    12//没有分号，如果添加分号该语句没有意义，函数无返回值会报错
}

fn main() {

    let a = test();

    println!("{}",a);
  
}
1
2
3
4
5
6
7
8
9
10
11
fn test() -> i32{
    return 12;//添加分号就需要使用return返回值
}

fn main() {

    let a = test();

    println!("{}",a);
  
}

if…else

根据布尔类型的条件来执行不同的代码分支，条件可以是数值也可以是表达式，与条件关联的代码块被称为分支

1
2
3
4
5
6
7
8
9
10
fn main() {
      let num =3;
      if num > 80 {

println!("you are good man!");

      }else {
          println!("you are bad man!");
      }
}

image-20241203134115472

1
2
3
4
5
6
7
8
9
10
11
12
fn main() {
      let num =100;
      if num % 4 == 0 {

println!("4");

      }else if num % 3 == 0{
    println!("3");
      }else {
    println!("1!");
      }
}

当出现多个if…else上面的分支可以优化为

1
2
3
4
5
6
7
8
9
fn main() {
    let num = 100;

    match (num % 4 == 0, num % 3 == 0) {
        (true, _) => println!("4"),//_代表忽略值的占位符
        (false, true) => println!("3"),
        _ => println!("1!"),
    }
}

循环

loop

反复执行一块代码，可以使用break设定条件结束

image-20241203145053383

while

每次执行前都要判断一次条件

1
2
3
4
5
6
7
8
9
10
11
fn main() {

    let mut num = 5;

    while num !=0 {
        num -=1;
        println!("this is the {} while",num);

    }
   
}

for

遍历集合

1
2
3
4
5
6
7
8
9
10
11
fn main() {

    let num1 = [1,2,3,4,5,6];

    for val in num1.iter(){

        println!("value is {}",val);

    }
   
}

image-20241203145828876

Range使用

指定一个开始数字和结束数字，不包括结束数字，rev方法反转range

image-20241203150201159