Rust概述

Rust是一个多范式编译型静态类型语言， 注重于内存安全， 支持函数式编程.

我和Rust的缘分： 在b站上看到一个光速入门Rust的视频， 并且通过Fireship.io了解到了Rust. 因为一句： 可变不共享，共享不可变 而对Rust有了深刻印象

声明变量

• 使用 let 关键字， 在Rust中默认的变量都是不可变的， 需要使用mut关键字修饰后才可以重新赋值， 例如 let mut foo = 5;

  let 关键字声明的是不可变的变量

• 声明常量需要使用 const 关键字实现， 并且不可以使用mut关键字修饰, 常量可以在任意范围定义, 常量需要显式的声明类型

const NUMBER: i32 = 3; 

fn main() {  
    println!("Number {}", NUMBER);  
}

let 关键字可以使用Shadow 操作， 在不使用mut 关键字的请款下覆盖原本的变量而无需创建新的变量

fn main() {
    let x = 5;

    let x = x + 1;

    let x = x * 2;

    println!("新的值是: {}", x);
}

// 第二个例子

fn main() {  
    let number = "T-H-R-E-E";  
    println!("Spell a Number : {}", number);  
    let number = 3;  
    println!("Number plus two is : {}", number + 2);  
}

数据类型

• 如果需要将一个字符串类型的数字转换为整型需要使用<T>.parse().except("<MSG") 函数来完成, 但是需要在原本的字符串变量声明为 u32， 例如

  fn main() {  
  // 必须显式的声明类型才可以进行转换
  let guess: u32 = "42".parse().expect("Not a number!");  
  println!("{}", guess);  
  }

Rust中的整形类型有5种

整型

Rust中整形默认为u32

浮点型

Rust中浮点型默认为 f32

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

    let _y: f32 = 3.0; // f32  

    let _z = 4.0f32; // f32  
}

数值运算

Rust中数值运算数字的类型必须一致

fn main() {  
    // 相加 
    let sum = 5 + 10;  

    // 相减  
    let difference = 95.5 - 4.3;  

    // 相乘  
    let product = 4 * 30;  

    // 相除  
    let quotient = 56.7 / 32.2;  

    // 取余  
    let remainder = 43 % 5;  
}

布尔值

布尔值在Rust中使用 bool 表示， 可用值有 true false

fn main() {
    let right = true;

    let wrong: bool = false;
}

字符类型

Rust 中 char 字符使用 ' (单引号标出), 长度为4 字节

fn main() {
    let heart = '❤';
}

判断字符是否为字母可以使用 <char>.is_alphabetic() 方法, 判断是否为数字可以使用<char>.is_numeric() 方法， 两个方法均返回bool类型

函数

Rust中的函数分为 main 和其他函数, 声明一个函数需要使用fn关键字, 可以在括号内加上参数并标注类型

注意: main函数内不能添加参数

fn main() {  
    println!("Hello, world!");  
    let x = 32;
    second_fn(x);  
}  

fn second_fn(x: i32) {
    println!("{}", x)
    println!("Another function.");  
}

匿名函数 (lambda)

匿名函数的最后一行将作为返回值赋值给变量， 在匿名函数内声明的变量仅在当前的匿名函数体作用域生效

fn main() {
    let x = {
        let temp = 77;
        temp + 1
    };
    println!("{}", x)  // 结果是88
}

带有返回值的函数

返回值需要使用 return 关键字实现， 返回值的类型需要使用 ->操作符在函数后显示声明

main方法内不能有返回值， 如果不使用return和关键字那么函数体最后一行将作为返回值

fn five() -> i32 {  
    5  
}  

fn plus_one(x: i32) -> i32 {  
    x + 1  
}  

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

条件判断

条件判断语句需要使用 if 关键字和 else 关键字， 语法和Java类似， 但是条件不需要使用括号包裹

fn main() {
    let number = 3;

    if number >= 10 {
        println!("number more than 10");
    } else {
        println!("number less than 10");
    }
}

多条件判断

以上的情况仅适用于两种情况判断， 如果需要多个条件则需要使用 else if 两个关键字组合使用

fn main() {  
    let number = 6;  
    if number % 4 == 0 {  
        println!("number is divisible by 4");  
    } else if number % 3 == 0 {  
        println!("number is divisible by 3");  
    } else if number % 2 == 0 {  
        println!("number is divisible by 2");  
    } else {  
        println!("number is not divisible by 4, 3, or 2");  
    }  
}

三元操作符 (if/else)

此操作可以根据条件复制给变量， 使用 let if 关键字组合使用

fn main() {  
    let condition = true;  
    let number = if condition { 5 } else { 6 };  

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

如果是函数返回值也可以用 return if 操作来简化代码

pub fn bigger(a: i32, b: i32) -> i32 {  
    return if a > b {  
        a  
    } else {  
        b  
    }  
}

条件管理

和 使用 && 或 使用 ||

元组

Rust中的元组是一组数据类型相同或者不同的数据组成， 需要使用小括号包裹，Rust编译器会自动推断元组中的类型， 所以声明类型可有可无

和大多数语言一样， 元组的索引是从 0 开始的

fn main() {  
    let utup = (1, 1.0, 0x1001)
    let tup: (i32, f64, u8) = (500, 6.4, 1);  

    let (x, y, z) = tup;  

    println!("utup is {}", utup)
    println!("The value of y is: {}", y);  
    println!("The last element is: {}", tup.2);  
}

解构元组

在Rust中结构元组和其他语言有些不同， 不是使用中括号而是直接使用 .操作符 加上索引， 例如获取一个元组的第一个数据可以使用 <tuple>.0

fn main() {  
    let cat = ("Furry McFurson", 3.5);  
    let name = cat.0;  
    let age = cat.1;  

    println!("{} is {} years old.", name, age);  
}

数组

Rust中声明数字需要使用 []来包裹住, 访问数组的元素需要使用 中括号下标实现， 声明数组可以显式的声明出类型也可以不声明

fn main() {  
    let a = [1, 2, 3, 4, 5];  

    let first = a[0];  
    let second = a[1];  

    let months = ["January", "February", "March",  
    "April", "May", "June",  
    "July", "August", "September",  
    "October", "November", "December"];  

    println!("The last month is {}", months[months.len() - 1]);  
    let a = ['s'; 5];   // 声明数组如果使用分号分割， 则第一个为整个数组内的元素， 第二个参数数组内元素的数量， 此处为5个s
    println!("{}", a[4]);  
}

fn main() {  
    let a = ["666"; 1000];  

    let output = if a.len() >= 100 {  
    "Wow, that's a big array!"  
    } else {  
    "Meh, I eat arrays like that for breakfast."  
    };  

    println!("{}", output)  
}

上面这段代码展示了如何快速创建重复数据的数组

循环

Rust中有三种循环分别使用 loop while for 这三个关键字实现, 使用 break 跳出循环

loop

loop 关键字实现的循环是 ‘死’ 循环， 只能在代码作用域内部使用break关键字才能退出循环，

fn main() {  
    let mut counter = 0;  

    let result = loop {  
        counter += 1;  

        if counter == 10 {  
            break counter * 2;  
        }  
    };  

    println!("The result is {}", result);  
}

while

while 关键字实现的是条件循环， 需要添加条件进行约束， 也可以在循环体作用域内使用 break 关键字来退出循环

fn main() {  
    let mut number = 3;  

    while number != 0 {  
    println!("{}!", number);  

    number -= 1;  
    }  

    println!("LIFTOFF!!!");  
}

for

for 关键字一般用于遍历数组， 列表等等

fn main() {  
    let arr = [10, 20, 30, 40, 50];  

    for element in arr {  
    println!("the value is: {}", element);  
    }  
}

遍历操作使用 while 关键字也可以实现

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}

范围for循环

此操作和Kotlin中的for循环类似

fn main() {  
    for number in 1..5 { // 5 不会包阔在内， 左闭右开
        println!("{}", number);  
    }  

    for number in 1..=5 { // 1， 2， 3， 4， 5. 5也在内 
        println!("{}", number);  
    }  

    for number in (1..4).rev() {  // 使用.rev() 方法反向遍历
        println!("{}!", number);  
    }  
    println!("LIFTOFF!!!");  
}