rust study - 01

[zhuzhh]

learn book
playground

安装

curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh

校验

rustc --version

编译

rustc main.rs

Cargo是Rust的构建系统和包管理器
检测版本

cargo --version

创建项目

cargo new hello_catgo

构建并运行Cargo项目

cargo build // 这个命令会创建一个可执行文件 target/debug/hello_cargo

默认的构建方法是调试构建(debug build)，Cargo会将可执行文件放在debug目录。在命令行可直接运行执行文件

./target/debug/hello_cargo

cargo run // build 构建并运行项目

cargo check // 再不生成二进制文件的情况下构建项目来检测错误

常量

const THEN_PHONE = 12131312;
可以在任何作用域中声明，包括全局作用域。
常量只能被设置为常量表达式，而不是任何只能在运行时计算出的值。

隐藏
可以定义一个与之前变量同名的新变量。
称之为第一个变量被第二个变量隐藏了。
实际上，第二个变量遮蔽了第一个变量，此时任何使用该变量的行为，都是在使用第二个变量，直到第二个变量自己也被隐藏或作用域结束。

隐藏与 mut 是有区别的

1. 当不小心尝试对变量重新赋值时，如果没有使用 let 关键字，就会导致编译时错误。通过使用 let，我们可以用这个值进行一些计算，不过计算完之后变量仍然是不可变的
2. 再次使用let时，实际创建了一个新变量，我们可以改变值的类型，并复用这个名字

let s = " ";
let s = s.len();

Rust是静态类型语音，也就是说在编译时就必须知道所有变量的类型。
根据值及其使用方式，编译器通常可以推断出想要的类型。当多种类型均有可能时，必须手动增加类型注解

数据类型
在Rust中，每一个值都属于某一个数据类型
两类数据类型子集，标量、复合

标量代表一个单独的值
Rust中有四种基本的标量类型: 整型、浮点型、布尔、字符

整数 是一个没有小数部分的数字
有符号 和 无符号 代表数字能否为负值，换句话说，这个数字是否有可能是负数（有符号数），或者永远为正而不需要符号（无符号数）。

每一个有符号的变体可以储存包含从 -(2n - 1) 到 2n - 1 - 1 在内的数字，这里 n 是变体使用的位数

另外，isize 和 usize 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的， 32 位架构上它们是 32 位的。

浮点型
浮点数 是指带小数点的数字。类型是 f32 和 f64，默认类型是 f64 。

布尔型
指 true 和false

字符类型
单引号声明 char 字面量，使用双引号声明字符串字面量。
char类型的大小为四字节，意味着他可以比ASCII表示更多内容

复合类型
复合类型有 元组(tuple)和数组(array)

元组类型

let tup = (1, true, 'aa', "xx");
let (a, b, c, d) = tup; // 称为解构
// 取出单个值
let num = tup.0

数组类型
与元组不同，数组中每个元素类型必须相同，rust中的数组长度固定
当明确知道元素长度时，推荐使用数组，不确定长度时，使用vector类型，vector类型是标准库提供的一个允许增长和缩小长度的类似数组的集合类型。

let arr = [1,2,3] // 类型是 let arr: [i32; 3] 注意是分号

i32代表类型，3 代表数组的长度

let a = [3; 5] // 表示数组将包含5个元素，每个元素都是3
等价 let a = [3, 3, 3, 3, 3]

访问超出数组长度的元素，将会抛错(运行时)

函数
main函数，多程序的入口
fn关键字，声明一个函数

Rust中，函数名和变量名使用 snake case 规范风格——所有字母都是小写并使用下划线分割单词

定义和调用

fn main() {
    another_func();
}
fn another_func() {}

函数的参数必须声明每个参数的类型

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

Rust 是一门基于表达式的语言

语句 是执行一些操作但并不返回值的指令
表达式 计算并产生一个值

let x = 6; 表示使用let关键字创建变量并绑定一个值——是一个语句
let x = 6;语句并不返回值
let x = (let y = 6); 会编译报错，因为没有绑定到x上的值
x = y = 6 Rust中不能这样写

函数调用是一个表达式
宏调用是一个表达式
用大括号创建一个新的块作用域也是一个表达式

let y = {
     let x = 3;
    x + 1 // 注意，最后一行没加分号
};

此时y的值是 4，如果 x + 1 后加;，他就变成语句了，而语句不会有返回值，所以这里会编译报错

函数返回值
声明返回值类型

fn five() -> i32 {}
let x = five()

此时x的类型就是 i32

定义返回值

// 有效
fn five() -> {
    5
}
// 有效
fn plus_one(x: i32) -> i32 {
    x + 1
}
// 无效，将会报错 ，“mismatched types”（类型不匹配）
fn plus_one(x: i32) -> i32 {
    x + 1;
}

x + 1; 分号把表达式变成了语句，表达式有返回值，语句没有返回值

函数签名

fn test(a: char) {}
fn test(a: bool) {}

不允许这么使用，编译报错 -> the name test is defined multiple times

注释
单行注释 —— 使用双斜杠 //
文档注释 —— 使用三斜杠 ///

if表达式

let number = 5;
if number < 5 {}

// 抛错 mismatched types 
if number {} // rust 期望一个 bool 却得到一个整数

if number != 0 {}

if number % 4 == 0 {
} else if number % 3 == 9 {
}

let condition = true;
let number = if condition { 5 } else { 6 };


let condition = true;
let number = if condition { 5 } else { "xxx" };
// 编译阶段会报错，condition 值不同，会影响number的类型，但是Rust在编译阶段就得知道number类型
// 如果不这么做，那么number的类型就得在运行时确定，Rust编译阶段就不能验证每处使用number变量的类型是否有效；且编译器必须跟踪每个变量的多种假设类型，那么他就变得更加复杂，对代码的保证也会减少。

循环——重复执行
Rust的三种循环: loop、while、for

符合^C代表按下了 Ctrl-C，
跳出循环 —— break关键字
跳到下个迭代 —— continue 关键字

从循环返回值

let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2;
    }
};
println!("The result is {result}")

// 打印结果 20

循环标签：在多个循环直接消除歧义
嵌套循环中，break和continue应用于最内层的循环

let mut count = 0;
'counting_up: loop {
    println!("count = {count}");
    let mut remaining = 10;
    loop {
        println!("remaining = {remaining}");
        if remaining == 9 {
            break;
        }
        if count == 2 {
            break 'counting_up;
        }
        remaining -= 1;
    }
    count += 1;
}
println!("End count = {count}");

while循环

let a = [10, 20, 30, 40, 50];
let mut index = 0;
while index < 5 {
    println!("the value is: {}", a[index]);
    index += 1;
}

for 循环

let a = [10, 20, 30, 40, 50];
for element in a {
    println!("the value is: {element}");
}