Rust学习1 - 安装和简单使用

Rust 官方资料

Rust官网

Rust的包，类似npm包

Rust的标准库std的文档

《Rust 程序设计语言 简体中文版》

《Rust语言圣经》

Rust的背景

Rust在2012年推出第一个版本，最新版本是2021年

Rust语言的特点：高性能（没有运行时）、可靠性（编译期能消除错误）、生产力（文档、包管理器）

Rust能做的事：命令行应用、WebAssembly、网络服务、嵌入式、图形界面应用、Web页面

Rust安装（Mac）：curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh,安装成功之后，$HOME/.cargo就是Rust相关文件，重启终端窗口cargo --version看到版本信息，即安装成功。

Rust辅助命令：

• rustup update 升级Rust到最新版
• rustc xx.rs 执行单个rust文件，不大用

Rust最常用的包管理命令，是cargo系列

写Rust

mac安装Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# 重启终端
cargo --version
# 打印出版本表示安装成功
# 后期需要更新rust的话
rustup update

安装成功之后，$HOME/.cargo就是Rust相关文件

VS code安装rust-analyzer插件

# 创建项目，生成hello_cargo文件夹，文件夹有Cargo.toml和src/main.rs
cargo new hello_cargo
# 运行
cargo run
# 构建测试版二进制文件，window是exe文件，在target/debug/hello_cargo
cargo build
# 构建正式版二进制文件，window是exe文件，在target/release/hello_cargo
cargo build --release
# 加包
cargo add rand
# 看依赖crate文档
cargo doc --open
# 看rust文档
rustup doc
​
# 在不生成二进制文件的情况下构建项目来检查错误
cargo check 
​

配置文件Cargo.toml

配置文件，类似package.json,项目名、项目版本、rust版本、依赖包

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"
​
[dependencies]
rand = "0.8.5"
​

体验Rust：猜数字游戏

猜数游戏的逻辑： 1.随机生成一个数，就是答案 2.提示让用户输入 3.获取用户输入的值，变成整数 4.比较大小，相等表示猜中，不等就重新234

// rand是rust的一个包，rust的包叫crate，增加包需要`cargo add rand`
// 导入 Rng trait，它定义了随机数生成器的方法
use rand::Rng;
// ios是标准库std的一个模块，提供I/O操作接口，这边只引入stdin函数
use std::io::stdin;
use std::cmp;
​
​
// main文件的main函数是入口函数，项目默认从这里执行
fn main() {
  /*
   * 1.随机生成一个数，就是答案
   */
  // rand::thread_rng()生成随机数生成器的实例，gen_range接受两个参数，这里表示生成[1-100]的某个整数
  let answer = rand::thread_rng().gen_range(1..=100);
  /*
   * 2、3、4步的循环
   */
  loop {
    /*
     * 2.提示让用户输入
     */
    // println! 可以理解为console.log, !是表示宏的意思
    println!("请输入你的数字：");
    // let mut相当于let，后面变量值可能发生改变，如果不加mut相当于const
    // 定义一个字符串变量，准备存放用户输入的字符串。
    let mut input = String::new(); 
    /*
     * 3.获取用户输入的值，变成整数
     */
    // 读取用户输入的内容，赋值给input。expect是出错的提示
    stdin().read_line(&mut input).expect("Failed to read line");
    // input可以被重复的声明，也叫 变量遮蔽（variable shadowing）,节省空间
    // 将输入的字符串变成number类型，这里声明u32之后，parse会根据类型去转换
    let input:u32 = input.trim().parse().expect("Failed to parse");
    /*
     *  4.比较大小，相等表示猜中结束，不等就重新234
     */ 
    // 比较猜的和答案，cmp返回的是一个枚举值 input小的话 返回Ordering::Less，等
    let result = input.cmp(&answer);
    // match是控制流结构，将一个值和一系列的模式进行比较，匹配到不同模式执行相应的代码块，每个分支叫arm
    match result {
      cmp::Ordering::Less => println!("猜的数字小了"),
      cmp::Ordering::Equal => {
        println!("猜中了！");
        break;
      },
      cmp::Ordering::Greater => println!("猜的数字大了"),
    }
  }
}

基础概念

变量和可变性

let声明变量

fn main() {
    // 加了mut
    let mut x = 5;
    println!("The value of x is: {x}");
    // 才能修改值
    x = 6;
    println!("The value of x is: {x}");
}

let mut相当于js的let

let相当于js的const

const是不依赖任何函数的的常量

Rust里let可以重复赋值给同一变量，也叫变量遮蔽（varible shadowing）。

fn main() {
    let x = 5;
    // 可以重复赋值，这样遮蔽了第一个变量
    let x = x + 1;
​
    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }
​
    println!("The value of x is: {x}");
}

数据类型

数据类型分为两大类：标量类型（scalar）和复合类型（compound），类似js的普通类型和引用类型。

标量类型有：整型、浮点型、布尔类型、字符类型。

整型

如果存放的值溢出，有四种处理方式：

• wrapping_*-------wrapping 方法允许算术操作自由地溢出，而不会导致任何运行时错误。它们会按照数字的位表示进行环绕，即超出最大值时会从最小值开始，低于最小值时会从最大值结束。
• checked_* -------checked 方法在执行算术操作时会检查是否会发生溢出。如果操作会导致溢出，这些方法会返回 None，否则返回 Some(result)
• overflowing_*------overflowing 操作符是一类特殊的算术操作符，它们允许你对整数进行操作，并且在发生溢出时仍然继续执行，同时返回一个包含结果和溢出标志的元组。
• saturating_* ------- saturating 方法在发生溢出时不会返回错误，而是会返回该类型能表示的最小值或最大值。

/* checked */
let a: u32 = u32::MAX;
let b: u32 = 1;
​
match a.checked_add(b) {
    Some(result) => println!("结果: {}", result),
    None => println!("溢出发生了"),  // 走到这里
}
​
/* wrapping */
let a: u32 = u32::MAX;
let b: u32 = 1;
​
let result = a.wrapping_add(b);
println!("结果: {}", result); // 结果将是 0，因为 u32::MAX + 1 溢出后变为 0
​
​
/* overflowing */
let a: u8 = 255; // u8 的最大值
let b: u8 = 1;
​
let (result, overflowed) = a.overflowing_add(b);
println!("结果: {}", result);  // 0
println!("溢出: {}", overflowed);   // true
​
/* saturating */
let a: u32 = u32::MAX;
let b: u32 = 1;
​
let result = a.saturating_add(b);
println!("结果: {}", result); // 结果将是 u32::MAX，因为无法进一步增加
​
​

其他

浮点型，一个是f32，一个是f64，f32 的范围大约是 1.4e-45 （10的负45次方）到 3.4e+38（10的38次方）。 f64 的范围大约是 4.9e-324到 1.8e+308。默认是f64。

数值运算：加减乘车取模

    // addition
    let sum = 5 + 10;
​
    // subtraction
    let difference = 95.5 - 4.3;
​
    // multiplication
    let product = 4 * 30;
​
    // division
    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // 结果为 -1
​
    // remainder
    let remainder = 43 % 5; // 3 

布尔型：true和false

    let t = true;
​
    let f: bool = false; // with explicit type annotation

字符类型：

1. char 存储单个字符的码点。

   • 类型：char 是 Rust 的原始字符类型，代表单个 Unicode 字符。
   • 例子：'中'
   • 区别：char 是一个不可变的原始类型，它存储的是单个字符的码点（code point）。它不能存储多个字符，也不能修改。

2. &str存储字符串的不可变引用。

   • 类型：&str 是 Rust 的引用类型，代表字符串的不可变部分。
   • 例子："你好，世界！"
   • 区别：&str 是一个不可变的引用，它指向一个字符串切片（slice）。你可以将 &str 视为一个字符串的子集，它指向原始字符串（String 或 CString）的某个位置。

3. String存储可变的字符串

   • 类型：String 是 Rust 的可变字符串类型，用于存储可变字符串。
   • 例子：String::from("你好，世界！")
   • 区别：String 是一个可变的动态数组，它存储字符的 UTF-8 编码。你可以修改 String 中的字符，甚至可以将其转换为其他字符串类型。

let character: char = '中';
 println!("这是一个字符: {}", character);
​
let string_literal: &str = "你好，世界！";
println!("这是一个字符串字面量: {}", string_literal);
​
let mut string: String = String::from("你好，世界！");
string.push('！'); // 向字符串末尾添加一个字符
println!("这是一个可变的字符串: {}", string);
​

复合类型

复合类型是可以将多个值组合成一个类型，元组（tuple）和数组（array）。

元组长度固定，一个单独的复合元素。为了从元组中获取单个值，可以使用模式匹配（pattern matching）来解构（destructure）元组值。

    let tup = (500, 6.4, 1);
​
    let (x, y, z) = tup;
​
    println!("The value of y is: {y}");
​
    let five_hundred = tup.0;

不带任何值的元组叫做 单元（unit） 元组,写作 ()，表示空值或空的返回类型。如果表达式不返回任何其他值，则会隐式返回单元值。

数组中的每个元素的类型必须相同。Rust 中的数组与一些其他语言中的数组不同，Rust 中的数组长度是固定的。

// 可以在前面定义类型和长度
let a: [i32; 5] = [1, 2, 3, 4, 5];
// 也可以在后面定义，这里表示 [3, 3, 3, 3, 3]
let a = [3; 5];
let first = a[0];
let second = a[1];
let over = a[11]; // 超过长度的索引会报错，index out of bounds: the length is 5 but the index is 11

函数

Rust的函数和变量名使用xx_yy（snake case）规范风格。参数必须声明类型。

fn main() {
    print_labeled_measurement(5, 'h');
}
​
fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {value}{unit_label}");
}

rust的语句不返回值，和其他语言不一样。

let x = (let y = 8); // 这是会报错的 ，let y = 8并没有返回值

表达式会返回一个值。数学运算是一个表达式，函数调用是一个表达式。宏调用是一个表达式。用大括号创建的一个新的块作用域也是一个表达式。

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
​
    println!("The value of y is: {y}"); // 4
}

y的后面是一个大括号，也就是一个表达式，所以是4.

注意！！！x+1后面没有分号，如果加上分号就变成了语句，那就会报错。

类似的还有

fn main() {
    let x = plus_one(5);
​
    println!("The value of x is: {x}"); // 6
}
​
fn plus_one(x: i32) -> i32 {
    x + 1  // 这里是表达式，有返回值。如果加了分号就变成语句，也就是默认返回单位类型()，所以会报错
}

控制流

if表达式

if后面的判断表达式没有小括号。符合条件只执行一个分支代码，且分支代码必须返回相同的数据类型，执行完就结束了。过多分支，推荐用match。

    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后面的表达式只能返回布尔类型，不然就会报错，这个和js不一样！

    let number = 3;
​
    if number {
        println!("number was three");
    }
   // 报错if number {  ^^^^^^ expected `bool`, found integer

将 if 表达式的返回值赋给一个变量

    let condition = true;
    let number = if condition { 5 } else { 6 };
​
    println!("The value of number is: {number}"); // 5

循环

Rust 有三种循环：loop、while 和 for。

loop 循环是一个无限循环，它没有特定的终止条件，除非手动中断。适用于需要一个无限循环或者手动中断的场景。

loop {
    println!("循环还在继续...");
    break; // 手动中断循环
}
​

while 循环在条件为 true 时执行代码块，适用于有特定终止条件的场景。

let mut count = 0;
while count < 10 {
    println!("count: {}", count);
    count += 1;
}
​

for 循环通常用于迭代集合（如数组、字符串、向量等）。

let arr = [1, 2, 3, 4, 5];
for num in arr {
    println!("数组中的元素: {}", num);
}
​
  for number in 1..4 {
     println!("{number}!"); // 1 2 3
  }
  println!("LIFTOFF!!!");

简单搓码

摄氏温度和华氏温度转换

1. 摄氏温度（Celsius） ：

   • 定义：摄氏温度是以绝对零度（-273.15°C）为零点，以水的冰点和沸点为参考点的温度单位。
   • 转换：摄氏温度与华氏温度之间的转换公式是：°F = °C × 9/5 + 32。
   • 例子：当温度为 25°C 时，对应的华氏温度大约是 77°F。

2. 华氏温度（Fahrenheit） ：

   • 定义：华氏温度是以水的冰点（32°F）和沸点（212°F）为参考点的温度单位，零点是人为设定的。
   • 转换：华氏温度与摄氏温度之间的转换公式是：°C = (°F - 32) × 5/9。
   • 例子：当温度为 77°F 时，对应的摄氏温度大约是 25°C。

fn main() {
    /* 也可以用let定义函数  |c: f64| -> f64 表示匿名函数 */
    // let c_f = |c: f64| -> f64 { c * (9.0 / 5.0) + 32.0 };
    // let f_c = |f: f64| -> f64 { (f - 32.0) * 5.0 / 9.0 };
    fn c_f(c: f64) -> f64 { c * (9.0 / 5.0) + 32.0 }
    fn f_c(f: f64) -> f64 { (f - 32.0) * 5.0 / 9.0 }
​
    let f: f64 = c_f(25.0);
    let c: f64 = f_c(77.0);
​
    println!("{f} {c}"); // 77 25
}
​

生成第 n 个斐波那契数

斐波那契数列是一个数学数列，其中每个数字（称为斐波那契数）都是前两个数字之和。数列开始于两个数字：0 和 1。因此，斐波那契数列的前几个数字是：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …。

use std::io;
​
fn main() {
    println!("请输入一个数字：");
    let n = input_number();
    fibonacci(n);
    println!("斐波那契数列的第 {n} 个数字是：{}", fibonacci(n));
}
fn input_number() -> usize {
    // 设置存放 用户输入的变量
    let mut input = String::new();
    // 让用户输入，并读取用户的输入，放进变量里
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read_line");
    // 将输入的值，trim之后转化为数字
    return input.trim().parse().expect("Failed to read_line");
}
fn fibonacci(n: usize) -> usize {
    // match会根据分支走代码，返回相应的值。相比if更推荐match
    match n {
        0 => 0,
        1 => 1,
        // 其他情况
        _ => fibonacci(n - 2) + fibonacci(n - 1),
    }
}
​

写圣诞颂歌

《圣诞节的十二天》（The Twelve Days of Christmas）是一首经典的圣诞颂歌，其歌词如下：

On the first day of Christmas,
My true love sent to me:
A partridge in a pear tree.
​
On the second day of Christmas,
My true love sent to me:
Two turtle doves,
And a partridge in a pear tree.
​
On the third day of Christmas,
My true love sent to me:
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the fourth day of Christmas,
My true love sent to me:
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the fifth day of Christmas,
My true love sent to me:
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the sixth day of Christmas,
My true love sent to me:
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the seventh day of Christmas,
My true love sent to me:
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the eighth day of Christmas,
My true love sent to me:
Eight maids a-milking,
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the ninth day of Christmas,
My true love sent to me:
Nine ladies dancing,
Eight maids a-milking,
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the tenth day of Christmas,
My true love sent to me:
Ten lords a-leaping,
Nine ladies dancing,
Eight maids a-milking,
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the eleventh day of Christmas,
My true love sent to me:
Eleven pipers piping,
Ten lords a-leaping,
Nine ladies dancing,
Eight maids a-milking,
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.
​
On the twelfth day of Christmas,
My true love sent to me:
Twelve drummers drumming,
Eleven pipers piping,
Ten lords a-leaping,
Nine ladies dancing,
Eight maids a-milking,
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
And a partridge in a pear tree.

这首歌曲以一种累积的方式，逐天描述了从第一天到第十二天收到的礼物，每一天的礼物数量和种类都比前一天多。歌曲中的每一句都以“On the [天数] day of Christmas, My true love sent to me: [礼物列表]”开头，其中最后一项总是“a partridge in a pear tree”（一只梨树上的画眉鸟）。

突破点在第12天，按照第12天的歌词来进行生成

// 开头是固定的，只是天数会发生变化
On the 【twelfth】 day of Christmas,
My true love sent to me:
​
// 大于11天，有这行
Twelve drummers drumming,
// 大于10天，有这行
Eleven pipers piping,
// 以此类推
Ten lords a-leaping,
Nine ladies dancing,
Eight maids a-milking,
Seven swans a-swimming,
Six geese a-laying,
Five golden rings,
Four calling birds,
Three French hens,
Two turtle doves,
​
// 结尾处，第一天和其他天数表现不一样，额外处理
And a partridge in a pear tree.

所以编码如下：

fn main() {
    println!("{}", create_song());
}
​
fn create_song() -> String {
    // 12天
    let day_list = [
        "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth",
        "tenth", "eleventh", "twelfth",
    ];
    // 礼物
    let gift_list = [
        "Twelve drummers drumming,",
        "Eleven pipers piping",
        "Ten lords a-leaping",
        "Nine ladies dancing",
        "Eight maids a-milking",
        "Seven swans a-swimming",
        "Six geese a-laying",
        "Five golden rings",
        "Four calling birds",
        "Three French hens",
        "Two turtle doves",
    ];
    // 最终的字符串变量
    let mut res = String::new();
    // 开始遍历，index是下标，day_th是day_list的值
    for (index, day_th) in day_list.iter().enumerate() {
        // 开头的部分
        let mut start = format!("On the {day_th} day of Christmas,\nMy true love sent to me:\n");
​
        /* 中间歌词的部分，index>10有gift_list[0]，index>9有gift_list[1]，
           以此类推 index>p有gift_list[10-p]，叠加
        */
        let mut p = day_list.len() - 1;
        while p > 0 {
            p = p - 1;
            if index > p {
                start = format!("{start}{}\n", gift_list[(day_list.len() - 2) - p]);
            }
        }
​
        // 结尾处额外处理
        let end = if index == 0 {
            "A partridge in a pear tree."
        } else {
            "And a partridge in a pear tree."
        };
​
        // 拼接
        res = format!("{res}\n{start}{end}\n\r");
    }
​
    return res;
}
​