第一天-基本知识整理，目的：能写点东西

第一天-基本知识整理：能写点东西

将之前学习的各种知识做一个简单的梳理，有了这些知识能写一个小函数。当然，这对于Rust甚至都算不上入门。

1. 数据类型（1）

1. let 不同于var声明变量，let有绑定的意思，绑定就意味着可以和另一个绑定(同时会解除旧的绑定)。

    let num = 1;
    println!("print num:{}", num);
    let num = 2; // 这时候a重新绑定了2，1因为没有人绑定了，编译器会自动判断 回收
    println!("print num:{}", num);
1
2
3
4

2. 可变、不可变的变量，rust奇葩之处，可变必须明确。
   感觉一是清晰；二是告诉编译器这个是可变的，后面操作错了编译器就会提醒你，之后要么改成可变的，要么说明写了错误代码。

结合后面的共享引用、可变引用，Rust通过控制读写权限，从编译器/代码的层面实现了读写锁，避免数据不一致。

    let mut num = 10;
    println!("print num:{}", num);
    num += 1;
    println!("print num:{}", num);
1
2
3
4

3. 命名规范

这里和go不太一样，尤其是变量函数方法都是蛇形

大驼峰（UpperCamelCase）来命名类名、结构体名等类或类型的标识符，
蛇形命名法（snake_case）用于命名变量、函数、方法、文件名等其他。

4. 数值类型声明：可以推断类型 + 显示类型注解+添加类型后缀

    let num_i32: i32 = 87; // 类型注解
    let num_i64 = -999i64; // 类型后缀
    let num_auto = 788; // 自动推断
    println!("print num_auto:{}", num_auto);
1
2
3
4

5. 数字可以有方法

    println!("val:{},valAbs:{}", num_i64, num_i64.abs());
1

6. 类型转换，强类型。高到低也可以，可能会溢出。

    println!("{},{},{}", num_i32, num_i64, num_i32 > num_i64 as i32);
1

2.控制流

1. if，for ，for主要是用来迭代容器/集合

    for i in 0..10 { // 0..10 即[0,10)左开右闭
        if i % 5 == 0 {
            println!("for finish i:{}", i);
            break;
        } else if i % 3 == 0 {
            continue;
        } else {
            // do some thing
        }
    }
1
2
3
4
5
6
7
8
9
10

匿名循环

    for _ in 0..10 {}
1

2. while 执行到一定程度

    let mut i = 0; // mut 代表可变变量
    while i <= 10 {
        i += 1;
    }
    println!("while finish i:{}", i);
1
2
3
4
5

3. loop 无限循环专用

    let mut i = 100;
    loop {
        if i % 10 == 0 || i % 3 == 0 {
            println!("finish,{}", i);
            break; // 这里还有一个知识点，后面详解
        }
        i += 1;
    }
1
2
3
4
5
6
7
8

3.函数（1）

fn add(i:i32, j:i32) -> i32 {}
关键字 函数名(参数1:类型,参数2:类型) -> 返回类型 {}

fn add(i: i32, j: i32) -> i32 {
    // 以下三种返回值都可以
    i + j // Rust风格
    // return i + j // 非常不Rust
    // return i + j;
}
println!("add func{}", add(99, 100));
1
2
3
4
5
6
7

作业

到此大概能写一个简单的函数练练手了
由于力扣的题目基本都需要高级数据结构，此时还写不了力扣的题目

编写一个函数，入参是 numCount, val ，打印从0到这个值的所有能整除val的前三个数

fn get_all_nums(num_count: i32, val: i32) {
    // 直接算出来有多少个，然后打印前几个
    let max_count = num_count / val + 1;
    for i in 0..min(max_count, 3) {
        println!("{}", i * val);
    }
    println!("finish");
    // 一般的解法
    let mut count = 0;
    for i in 0..=num_count { // [0,num_count] 左闭 右闭,Rust里面提供的各种各样
        if i % val == 0 {
            count += 1; // 没有++
            println!("{}", i);
            if count >= 3 {
                println!("finish");// 用宏打印
                return;
            }
        }
    }
}

fn min(a: i32, b: i32) -> i32 {
    if a < b {
        return a;
    }
    b
}

// 整个简单的ut
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn get_all_nums_test() { // 这是一个测试函数，上面需要加上#[test]
        get_all_nums(3, 3); //
        println!("----");
        get_all_nums(10, 3); //
        // assert_eq!(result, 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