Rust基础(2)-通用编程概念和操作符

基础技术 / rust基础
Word count: 1.3k   |   Reading time≈ 6 min

Rust中涉及到的一些基本概念，以下演示都是基于前面一章helloworld方式生成的项目。为了方便，这里只展示关键代码

1-变量、常量

  1. 变量
    1. 可变性：定义变量用let，如果变量没有用mut，那么是不可变的
    2. 隐藏性：后面变量隐藏前面变量
  2. 常量
    1. 关键词：const
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
const MAX_POINT: u32 = 100000;

fn main() {
    //1. 变量可变性
    //不可变变量
    let a = 1;
    let b: u32 = 1;
    //可变变量
    let mut bb: u32 = 1;

    println!("a = {}", a);
    println!("b = {}", b);
    println!("bb = {}", bb);
    bb = 2;
    println!("bb = {}", bb);
    println!("Hello, world!");

    //2. 变量隐藏，后面变量隐藏前面变量
    let c: u32 = 3;
    println!("c = {}", c);
    let c: f32 = 1.1;
    println!("c = {}", c);

    //3. 常量
    println!("MAX_POINTS = {}", MAX_POINT);
}

2-数据类型

  1. rust是静态类型语言，也就是说编译时必须知道素有变量的类型
  2. 编译器具有自动推导的能力

2.1-基础数据类型

bool、char、u32、数字类型、数组、自适应类型

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
fn main() {
   //1. bool
   let is_true: bool = true;
   println!("is_true = {}", is_true);
   let is_false = false;
   println!("is_false = {}, {}", is_false, is_true);

   //2. char 在rust里面，char是32位的，字符汉字均可
   let a = 'a';
   println!("a = {}", a);
   let b = '你';
   println!("b = {}", b);

   //3. 数字类型 i8, i16, i32, i64, u8, u16, u32, u64, f32, f64
   let c: i8 = -111;
   println!("c = {}", c);
   let d: f32 = 0.0001;
   println!("d = {}", d);

   //4. 自适应类型，根据不同系统平台，打印位数长度不同：isize（有符号），usize（无符号），
   //无符号最大长度
   println!("max = {}", usize::max_value());

   //5. 数组[type; size]这是一个整体，是一个类型，也就是size不同，则数组也是不同的类型
   let arr: [u32; 5] = [1, 2, 3, 4, 5];
   println!("arr[0] = {}", arr[0]);
}

2.2-集合数据类型

元组、结构体、枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
fn main() {
   //1. 元组
   let tup: (i32, f32, char) = (-3, 3.69, '好');
   println!("{}", tup.0);
   let tup = (-3, 3.69, '好');
   println!("{}", tup.1);
   println!("{}", tup.2);

   let (x,y,z) = tup;
   println!("{}", x);
   println!("{}", y);
   println!("{}", z);
}

2.3-字符串

3-Rust控制流

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
fn main() {
    //if else 和golang等一样
    let y = 1;
    if y == 1 {
        println!("y = 1");
    }
    //let中使用if
    let condition = true;
    let x = if condition {
        5
    } else {
        6
    };
    println!("x = {}", x);

    //loop, 无限循环
    let mut counter = 0;
    loop {
        println!("in loop");
        if counter == 10 {
            break;
        }
        counter += 1;
    }

    let result = loop {
        counter += 1;
        if counter == 20 {
            break counter * 2;
        }
    };
    println!("result = {}", result);

    //while
    let mut i = 0;
    while i != 10 {
        i += 1;
    }
    println!("i = {}", i);

    //for
    let arr: [u32; 5] = [1, 2, 3, 4, 5];
    for element in arr.iter() { 
        println!("element = {}", element);
    }
    for element in &arr {
        println!("element = {}", element);
    }
}

4-函数

直接看代码：

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
fn other_fun() {
    println!("这是一个方法");
}

fn other_fun1(a: i32, b: u32) {
    println!("a = {}, b = {}", a, b);
}

fn other_fun2(a: i32, b: i32) -> i32 {
    let result = a + b;
    return result;
}

//简化返回
fn other_fun3(a: i32, b: i32) -> i32 {
    let result = a + b;
    result
}

//简化返回
fn other_fun4(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    other_fun();
    let a: i32 = -1;
    let b: u32 = 2;
    other_fun1(a, b);

    let c: i32 = 9;
    let r: i32 = other_fun2(a, c);
    println!("r = {}", r);

    let cc: i32 = 9;
    let rr: i32 = other_fun3(a, cc);
    println!("rr = {}", rr);

    let ccc: i32 = 9;
    let rrr: i32 = other_fun4(a, ccc);
    println!("rrr = {}", rrr);

    //语句是执行一些操作，但是不返回值的指令
    let y = 1; //语句，不返回值

    //表达式会计算一些值
    let y = {
        let x = 1;
        x +1
    };
    println!("y = {}", y);
}

5-操作符

5.1-问号(?)操作符

为了让Result<T,E>类型的处理更加方便简洁，Rust中引入了?操作符。
问号操作符是针对Result<T,E>类型的一个语法糖，?操作符内部被展开成一段类似如下match匹配的代码：

1
2
3
4
5
6
//如果Result是一个E类型的错误值，则提前返回错误，结束当前函数。
//如果Result是一个T类型的正确值，则提取出值，方便后续进行链式调用。
match result {
  Ok(v) => v,
  Err(e) => return Err(e.into())
}

所以，?操作符可以方便地对Result<T,E>进行值提取（Ok(v) => v），或者返回一个错误类型值，提前结束当前函数。

注意：

  1. ?操作符只能使用在以Option或者Result作为返回值的函数体中。
  2. 如果要在main()中使用?操作符。那么首先是要求main()返回值是Option或者Result类型（满足第一条）；其次，还要求返回值是要实现std::process::Termination trait的类型。
  3. 简单说，?等价于Result，简写

5.2-'static

  1. 'static，拥有该生命周期的引用可以和整个程序活得一样久。
  2. 实在遇到解决不了的生命周期标注问题，可以尝试 T: 'static，有时候它会给你奇迹
  3. 参考：如何理解Rust语言中的 'static 生命周期?

总结

已编辑完毕

参考

[1] Rust 程序设计语言

  • Copyrights © 2017-2023 Jason
  • Visitors: | Views:

谢谢打赏～

微信