| **Path** | **Description**                                              |
| -------- | ------------------------------------------------------------ |
| `/`      | The top-level directory is the root filesystem and contains all of the files required to boot the operating system before other filesystems are mounted as well as the files required to boot the other filesystems. After boot, all of the other filesystems are mounted at standard mount points as subdirectories of the root. |
| `/bin`   | Contains essential command binaries.                         |
| `/boot`  | Consists of the static bootloader, kernel executable, and files required to boot the Linux OS. |
| `/dev`   | Contains device files to facilitate access to every hardware device attached to the system. |
| `/etc`   | Local system configuration files. Configuration files for installed applications may be saved here as well. |
| `/home`  | Each user on the system has a subdirectory here for storage. |
| `/lib`   | Shared library files that are required for system boot.      |
| `/media` | External removable media devices such as USB drives are mounted here. |
| `/mnt`   | Temporary mount point for regular filesystems.               |
| `/opt`   | Optional files such as third-party tools can be saved here.  |
| `/root`  | The home directory for the root user.                        |
| `/sbin`  | This directory contains executables used for system administration (binary system files). |
| `/tmp`   | The operating system and many programs use this directory to store temporary files. This directory is generally cleared upon system boot and may be deleted at other times without any warning. |
| `/usr`   | Contains executables, libraries, man files, etc.             |
| `/var`   | This directory contains variable data files such as log files, email in-boxes, web application related files, cron files, and more. |

| **Column Content** | **Description**                                              |
| ------------------ | ------------------------------------------------------------ |
| `drwxr-xr-x`       | Type and permissions                                         |
| `2`                | Number of hard links to the file/directory                   |
| `cry0l1t3`         | Owner of the file/directory                                  |
| `htbacademy`       | Group owner of the file/directory                            |
| `4096`             | Size of the file or the number of blocks used to store the directory information |
| `Nov 13 17:37`     | Date and time                                                |
| `Desktop`          | Directory name                                               |

---

linux foundamental ：

htb


htb learning

htb bizness

# WP usage

首先nmap扫描开放端口：

```shell
Host is up (0.44s latency).
Not shown: 998 closed tcp ports (reset)
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 8.9p1 Ubuntu 3ubuntu0.6 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   256 a0:f8:fd:d3:04:b8:07:a0:63:dd:37:df:d7:ee:ca:78 (ECDSA)
|_  256 bd:22:f5:28:77:27:fb:65:ba:f6:fd:2f:10:c7:82:8f (ED25519)
80/tcp open  http    nginx 1.18.0 (Ubuntu)
|_http-server-header: nginx/1.18.0 (Ubuntu)
|_http-title: Daily Blogs
| http-methods: 
|_  Supported Methods: GET HEAD
Aggressive OS guesses: Linux 5.4 (95%), Linux 3.1 (95%), Linux 3.2 (95%), AXIS 210A or 211 Network Camera (Linux 2.6.17) (94%), Linux 5.0 (93%), ASUS RT-N56U WAP (Linux 3.4) (93%), Linux 3.16 (93%), Linux 4.15 - 5.8 (93%), Adtran 424RG FTTH gateway (92%), Linux 3.10 (92%)
No exact OS matches for host (test conditions non-ideal).
Uptime guess: 32.230 days (since Fri Mar 22 15:57:29 2024)
Network Distance: 2 hops
TCP Sequence Prediction: Difficulty=256 (Good luck!)
IP ID Sequence Generation: All zeros
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

```

可以看到就只有两个端口打开，80和22，分别是http和ssh的默认端口。



然后我们dirsearch看看有没有什么隐藏目录和文件：



usage

# Rust

## 第四章 所有权

所有权是Rust最独特的特性，他让rust不用GC就可以保证内存安全。




 ### 4.1.1 什么是所有权

* Rust的核心特性就是所有权
* 所有程序在运行时必须管理他们使用计算机内存的方式
  * 有一些语言有垃圾收集机制，在程序运行时，他们会不断地寻找不再使用的内存
  * 在其他语言中，程序员必须显示的分配和释放内存：如C，malloc以及free
* 在rust中采用了第三种方式：
  * 内存是通过一个所有权系统来管理的，其中包含一组编译器在编译时检查的规则，并且不会产生任何开销，也就是说这一特性，并不会减慢程序的速度。

#### stack VS heap

* stack 存储数据的方式是顺序的，并且遵循LIFO
*  并且所有存储咋stack上面的数据必须拥有已知且固定的大小。
  * 也就是说，编译时大小未知的或者运行时可能发生改变的都应该放在heap上面。
* 但是heap的内存组织性会差一些：
  * 当你把数据放入heap中时，你会申请一块足够大的空间，并标记为使用中，然后返回一个指针，作为这个空间的地址。
  * 这个过程叫在heap上进行的分配，简：”分配“。

**这一部分知识与pwn基础知识大量重合，就不记录了。**

主要就是，函数调用栈以及堆相关内容。

#### 所有权存在的原因

* 所有权解决的问题：
  * 跟踪代码**哪些部分**在使用heap **哪些数据**
  * 最小化heap上面的重复数据
  * 清理heap上个面的未使用数据以避免空间不足

总之，管理heap数据才是所有权出现的原因



### 4.1.2 所有权规则

* 每个值都只能有一个变量，这个变量是该值的所有者
* 每个值同时只能有一个所有者
* 当所有者超出作用域（scope）时，该值被删除。

#### 变量作用域

注意变量的作用域仅仅只在声明变量之后到花括号结束点，这么一段范围。

#### String类型

* string类型存储在heap上面
* 字符串字面值：程序里面写死的字符串值，不可改变。
* 能够在heap上面分配，能够存储在编译时未知数量的文本。

#### 创建String类型的值

可以使用from函数从字符串字面值

![image-20240110200025417](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401102000497.png)

> 其中，”::“表示from时String类型下的关联函数；

并且这类字符串是可以修改的

* 为什么String类型的值可以修改，而字符串字面值却不能修改？

因为他们之间处理内存的方式不同。

#### 内存和分配

* 字符串字面值，在编译时就知道它的内容了，其文本内容直接被硬编码到最终的可执行文件中，
  * 而其优点就是：速度快，高效。
* String 类型，为支持可变性，需要在heap上面使用某种方式返回给操作系统
  * 这一步，在拥有Gc的语言之后，GC会跟踪并清理不再使用的内存
  * 如果没有GC，就需要我们去辨识内存何时不再使用，并调用代码将他返回。
* RUST采用了不同的操作方式，当变量走出其作用范围后，就会收回他的内存。

#### 变量和数据交互的方式：移动（MOVE）

* 多个变量可以与同一个数据以一种独特的方式交互。

* let x = 5；

  let y = x；

* 整数时已知的且固定的大小简单的值，这两个5被压到了stack中。

但如果这里的类型是**String**类型

##### String类型

* 一个String类型有3部分组成，一个 **指向存放字符串内容的指针**，一个 **表示该字符串长度的值**，一个 **表示该字符串容量的值**，而这些都存放在 **Stack**上面。内容则全部存放在，heap上面。
* 而我们知道 在rust里面，如果一个变量走出了他的作用域，**Rust就会调用一个Drop函数来释放他的内存**，而这里我们就会遇到一个问题，如果let x = String::from("hello")；let y = x；这里的y就会copy一份x的Stack上面的三个值，而不会copyheap上面的值，所以在同一个作用域中，就有了两个指向同一个区域的指针，在该作用域结束时，他们都会被回收，**这也就代表着，这一块heap上面的区域，会被释放两次，也就会造成double free**

这样肯定是不可以的，所以，Rust在这里引出了一个重要的概念 **MOVE移动**。

也就是说当我进行如上的赋值操作后，x会直接失效，y会代替x存在，而当作用域结束后，x并不会释放，那一块heap区域，完全交由y来释放。

这里就要引出一个新的概念：

##### 浅拷贝与深拷贝

我们一般认为，这样单纯复制指针，长度，容量的操作为浅拷贝，它不会复制实际的在heap上面的内容。

**这里也隐含了一个RUst的设计原则：RUST不会自动的创建数据的深拷贝**。

* 就运行是效率而言：任何赋值操作都是廉价的。

当然如果真的想对heaps上面的数据进行深度拷贝操作，而不仅仅是stack上面的数据，我们可以使用clone操作。

##### Stack上的copy（复制）

这里的复制操作，就是简单的操作，不存在浅拷贝和深拷贝。

* Copy trait，可以用于像整数这样完全村存放在Stack上面的类型
* 如果一个类型实现了Copy这个Trait，那么旧的变量再赋值后仍然可用
* 如果一个类型或者该类型的一部分实现了Drop trait，那么Rust不允许让他再去实现Copy Trait

##### 哪些类型可以实现copy trait

* 所有标量的组合
* 所有的整数类型
* bool
* char
* 浮点类型
* Tuple（所有字段值均可实现copy trait）

### 4.1.3 所有权与函数

* 在语义上面将值传递给变量是类似的
  * 将值传递给函数将会发生移动或者复制
* 注意，这里如果变量是上面几个说过的有copy trait的变量类型，那么他们就不会进行一个所有权的转移，仅仅只是一个浅拷贝，但如果是类似String类型的变量，那他在调用函数时，就会将所有权转移到被调用的函数中去。

#### 返回值和作用域

* 函数在返回值的过程中同样也会发生所有权的转移
* 一个变量的所有权总是遵循着同样的模式：
  * 当一个值赋给其他变量时就会发生移动
  * 当一个包含heap数据的变量离开作用域时，他的值就会drop函数清理，除非数据被移动到另外一个变量中

#### 如何让某个函数使用值，但不获得其所有权

* 第一种方法就是，先将变量正常传入然后利用返回值的所有权传递，传回新变量手中，这样虽然变量名发生里改变，但是所有权没变，作用域也没变。

![image-20240111212041346](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112120427.png)

* 利用Rust的特性，“引用reference”。

### 4.2.1 引用与借用

#### 引用

* 参数的类型是&String 而不是String

* & 符号就是引用：允许你引用某些值而不获得其所有权。

  ![image-20240111212611379](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112126414.png)

也就是说在引用时，回创建一个新变量内容是引用变量的指针。

#### 借用

**我们把引用作为函数的这个行为叫做借用**

同样的借用是不可以修改原变量的，因为只是 **借用**。



#### 可变引用

将变量设为可变，参数可变，引用时可变即可。·

 但是，**可变引用有一个限制：在特定的作用域内，对某一块数据，只能有一个可变引用**。

这样做的好处是可以在编译时防止数据竞争。

* 发生数据竞争的条件：
  * 两个或者多个指针同时访问一个数据
  * 至少有一个指针用于写入
  * 没有使用任何机制来同步对数据的访问

RUst在编译时就防止了这一种err发生

但是，**我们只需要添加作用域即可**：

![image-20240111213523993](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112135021.png)

可以看到这里我们只是添加了一对花括号而已，这样就完成了

**第二个限制：不允许同时拥有可变引用和不可变引用：**

![image-20240111213751262](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112137314.png)

#### 悬空引用（dangling references）

 

```rust
fn main(){
    let m = dangling();
}
fn dangling() -> &String{
    let note = String::from("helloe ");
    &note
}
```

报错：

![image-20240111214207053](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112142125.png)

#### 引用的规则

* 一个可变引用或者任意数量的不可变引用
* 引用必须一直有效

### 4.3 切片

Rust part2

# RUST 学习

## 第一章



安装rust，我选择在wsl中安装：

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

查看版本：

```shell
rustc --version
```

查看文档：

```shell
rustup doc
```



### hello world

源码：

```rust
fn main(){
    println!("Hello World!");
}
```

编译：

```shell
rustc main.rs  
```

注意事项：

* 和c语言一样，main函数也是rust语言第一个被执行的函数。
* fn （function）用于创建函数
* main没有参数，没有返回
* rust中的缩进是4个空格，不是tab
* **println**！是rust的宏（rust macro），所以这里如果将！删去，println就是一个函数
* 每块语句以分号结尾；

rust语言特点：ahead-of-time预编译，可以将编译完成的rust程序直接发送给未安装rust的电脑运行。

注意：

**rustc**只适用于简单的，小型的rust程序。复杂的则需要**cargo**

### Cargo

cargo是rust构建系统和包管理工具

```shell
~/rust_learning                                      19:21:10 ─╮
❯ cargo --version                                             ─╯
cargo 1.75.0 (1d8b05cdd 2023-11-20)
```

可以通过cargo new *** .rs创建项目：

他会直接在当前目录下创建一个新的目录：

里面包含：

src以及该项目的配置文件

![image-20240107193700042](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401071937125.png)

.gitgnore是仓库初始文件，Cargo.toml是该项目的配置文件：

里面包含文件依赖，版本信息等



运行：

```shell
cargo run//类似docker run

```

## 第二章



### 牛刀小试：1.简单的猜数游戏

题目信息：

![image-20240107193945963](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401071939998.png)

* 第一步，创建项目：

  ```shell
  ❯ cargo new guessing                                                              ─╯
       Created binary (application) `guessing` package
      
  ```

* 第二步，编写源码：

  ```rust
  use std::io;//因为我们下面
  fn main() {
      println!("let us play a game!");
      println!("guess what is next number!");
  
      let mut guess = String::new();
      io::stdin().read_line(&mut guess).expect("error");
      println!("this is your guess: {}", guess);
  }
  ```

  代码详解：

  ```rust
  use std::io;//因为我们下面引用了read_line函数，他是IO库中的函数，而IO库又是STD库中的函数，所以我们再调用read_line函数的时候需要用 USE 导入该库，因为这一个库没有被preclude
  
  fn main() {
      println!("let us play a game!");
      println!("guess what is next number!");//注意println！不是函数，是一个宏
  
      let mut guess = String::new();
      //let 用于声明变量
      //mut关键字表明该变量是可修改的，而在rust中所有变量在申明时默认都是immuteable，不可修改的
      //举个例子：如果let foo = 1;声明foo为1，那么我们不可以再foo = 2;对其赋值。
      //::表明new是String类型的关联函数，关联函数就是指，他是针对这一类型来实现的，而不是针对某一个实例实现的。String是标准库中的，采用utf-8格式。
      io::stdin().read_line(&mut guess).expect("error");
      //如果未申明use std::io，可以换一种写法：std::IO::read_line...这样子可以达到同样的效果。注意read_line返回的值为有两种：OK err，这里.expect就是指当readline返回值为err时就输出“error”；然后就是这里关于引用&，这样子引用的是同一块数据区域，注意read_line函数第二个参数规定了是String类型，只能用字符串类型的参数，引用&在rust里面也是默认不可更改，这也是加mut的原因。
      println!("this is your guess: {}", guess);
      //{}为占位符，类似C语言中的%d等等。
  }
  ```

### 牛刀小试：2.生成神秘数字

在rust中，我们为了生成随机数，需要外部导入一个lib类型的库 **rand**，这个库要添加到cargo.toml的[dependencies]部分中，如下：

![image-20240109141907653](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091419760.png)

然后我们重新编译一下：

![image-20240109142205738](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091422771.png)

可以看到，这里已经成功将rand依赖导入

导入库的过程大致如下：

先将crates.io这个网址最新的索引下载下来，就是一个注册表，然后更新注册表，然后cargo就会检查dependieces下有哪些库未下载，然后再下载，同样的因为rand库也有一个依赖，所以我们可看到上图中第一个位置是libc，这就是rand库的依赖。

简单源码：

```rust
use std::io;
use rand::Rng;//trait 类似接口
fn main() {
    println!("let us play a game!");
    println!("guess what is next number!");
    println!("this is the number you should know!");
    let secretnumber = rand::thread_rng().gen_range(1..101);//范围[1,101)，这里最新版的rand库，要求范围这么写，旧版本（1，101）；
    println!("生成的随机数是 {}",secretnumber);
    println!("plz guess the number.");
    let mut guess = String::new();
    io::stdin().read_line(&mut guess).expect("error");
    println!("this is your guess: {}", guess);
}

```

**注意：RUST严格区分大小写**；

### 牛刀小试：3.比较猜测数字与神秘数字

```rust
use std::io;
use rand::Rng;//trait 类似接口
use std::cmp::Ordering;
fn main() {
    println!("let us play a game!");
    println!("guess what is next number!");
    println!("this is the number you should know!");
    let secretnumber = rand::thread_rng().gen_range(1..101);//范围[1,101)
    println!("生成的随机数是 {}",secretnumber);
    println!("plz guess the number.");
    let mut guess = String::new();
    io::stdin().read_line(&mut guess).expect("error");
    println!("this is your guess: {}", guess);

    let guess:u32 = guess.trim().parse().expect("error");//因为之前guess在申明时直接就是String类型，而secretnumber是整数型，无法直接比较，会报错，所以这里我们需要
    //将String类型转为整形，trim是为了将字符串两边空格等不显示字符去掉，parse()转整形，如果有xy等字符，转型失败，同read_line的expect用法。
    //这样的同名变量会隐藏之前一个变量（shadow），其统属范围以覆盖位置为结尾。let guess:u32显示类型，同样的为了比较，secretnumber也会被转型从i32转为u32
    match guess.cmp(&secretnumber){
        Ordering::Less => println!("Too small"),
        Ordering::Greater => println!("Too big"),
        Ordering::Equal => println!("you win!"),//注意match的分支arm，结尾需要以，结尾.
    }
}
```

这节主要就是学习了：

* std::cmp::Ordering枚举的用法，以及简单match的用法。
* 同名函数转型及shadow的用法
* trim(),parse()等用法



### 牛刀小试：4.连续猜测的实现

```RUST
use std::io;
use rand::Rng;//trait 类似接口
use std::cmp::Ordering;
fn main() {
    println!("let us play a game!");
    println!("guess what is next number!");
    println!("this is the number you should know!");
    let secretnumber = rand::thread_rng().gen_range(1..101);//范围[1,101)
    println!("生成的随机数是 {}",secretnumber);
    loop{//无限循环
        println!("plz guess the number.");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("error");
        println!("this is your guess: {}", guess);
    
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,//将解析成功的数字赋给guess
            Err(_) => continue,//_通配符表示忽略报错信息，然后continue
        };//为了避免输入无法转型的字符导致的退出，因为parse返回也为result枚举型，可以用match分支实现
        match guess.cmp(&secretnumber) {
            Ordering::Less => println!("Too small"),
            Ordering::Greater => println!("Too big"),
            Ordering::Equal => {
                println!("you win!");
                break;//这里利用break实现在猜对后推出loop的效果
            }
        }
}
}

```

这里第一时间，我想的是直接在read_line后面match，然后报错了，发现原来是result类型不一致：

以下是chatgpt给出的回答：

> 
> 在你的代码中，`read_line` 和 `parse` 都返回 `Result` 类型，但它们代表的不同操作，因此包含的信息也不同。
>
> 1. **`io::Result`（`read_line`的返回类型）:**
>
>    - `io::Result` 是 `std::io` 模块中的一个特定 `Result` 类型，用于表示 I/O 操作可能的成功或失败。
>    - `io::Result` 的 `Ok` 分支包含成功时的结果，通常是读取的字节数或其他 I/O 相关信息。
>    - `io::Result` 的 `Err` 分支包含错误信息，它可能是由于文件不存在、权限问题、或其他 I/O 错误而导致的失败。
>
>    例如，在你的代码中，`io::stdin().read_line(&mut guess).expect("Error")` 尝试从标准输入读取一行，并返回 `io::Result`，其中 `Ok` 包含读取的字节数，而 `Err` 包含可能的 I/O 错误信息。
>
> 2. **`Result<u32, ParseIntError>`（`parse`的返回类型）:**
>
>    - `parse` 函数返回的 `Result` 是一个泛型类型，它表示解析字符串为数字可能的成功或失败。
>    - `Ok` 分支包含成功时的解析结果，这里是一个 `u32` 类型的数字。
>    - `Err` 分支包含解析失败时的错误信息，通常是一个实现了 `std::error::Error` trait 的类型，比如 `ParseIntError`。
>
>    在你的代码中，`match guess.trim().parse()` 用于处理 `parse` 的返回结果，其中 `Ok(num)` 包含解析成功时得到的数字，而 `Err(_)` 包含解析失败的错误信息。在这里，`continue` 语句用于跳过当前迭代并提示用户重新输入，表示解析失败。

所以这里只能在parse这里使用match分枝。

## 第三章：通用编程概念

* 变量与可变性
* 数据类型
  * 标量类型’
  * 复合类型
* 函数
* 注释
* 控制流

### 3.1 变量与可变性

* 声明变量使用**let**关键字
* 变量未使用**mut**关键字时，**默认不可更改**（**immutable**）

#### 常量（constant）

常量在被定义后和默认immut的变量一样不可更改，但依旧有很多区别：

* 不可用mut更改可变性
* 常量的声明需要使用const，并且必须显式的标明常量类型；
* 常量可以在任何作用域内声明，包括全局作用域
* **常量只能绑定到常量表达式**，无法绑定到函数的调用结果或只能在运行时才能计算出的值。

**在程序运行期间，常量在其声明的作用域中一直有效**

命名规范：Rust里面常量必须是使用大写字符，并且只能用下划线隔开，例：

* MAX_POINTS

定义例：

const MAX_POINTS：u32 = 100_00;**”_“** 在RUST可用于增加可读性。

#### 变量

**shadowing(隐藏)**

* 可以使用相同的名字声明变量，新的变量就会隐藏之前那个变量、
* 在后续代码中使用的变量就是新变量

![image-20240109164824070](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091648159.png)

![image-20240109164834320](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091648356.png)

* shadow和mut在某种程度上是不一样的：
  * 不使用let给immuttable变量赋值时会编译错误
  * 使用let声明同名变量时也不可变

```rust
   let mut y = 6;
    y = y+1;//不会报错
    let y = y+8;
    y = y+1;//这里会报错，重新声明也需要加mut
```

* 使用let声明同名新变量时，可以改变类型（第二章用过了）

![image-20240109165530190](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091655229.png)

usize表示与自己电脑相同位数。



### 3.2 数据类型

* 标量类型
* 复合类型

**RUST是静态编译语言，所以在编译时必须知道所有的变量的类型**：

* 基于使用的值，编译器能推断出大部分的类型

* 但对于如Parse()转型等方法使用过程中，就需要显式的写出

  ```rust
  let mut guess = "42";
  let guess:u32 = guess.parse().expect("err");
  ```

  ![image-20240109170604782](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091706831.png)

因为对于42我们可以转为i32和u32等等，所以我们需要显示的写出类型。

#### 标量类型

* 一个标量代表一个单个的值

* Rust有四个主要的标量类型：

  * 整数类型
  * 布尔类型
  * 浮点类型
  * 字符类型

  

##### 整数类型

* 1.整数类型就是没有小数部分
* 2.例如u32就是一个无符号的整数类型，占据32位空间
* 无符号类型整数以u开头
* 有符号整数以i开头
* Rust的整数类型列表如图：

![image-20240109171544339](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091715396.png)

注意一字节8位 

###### 整数字面值

![image-20240109171802534](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091718575.png)



* 除了byte类型外，所有数字字面值都允许使用类型后缀，例如:57u8

默认类型时i32，性能速度相当快。

###### 整数溢出

例如：u8的范围是0-255，如果你把一个u8的变量设为256，那么：

* 调试模式下编译就会：Rust会检查整数溢出，如果发生溢出，程序会在运行时panic
* 发布模式下（-release）编译：Rust不会检查可能导致panic的整数溢出。
  * 如果溢出发生，那么这时rust**就会进行环绕**操作：
    * 256 -> 0
    * 257->1
    * ...
    * 但是在发布模式下并不会发生panic

##### 浮点类型

Rust有两种浮点类型，也就是含有小数部分的类型

分别是：

* f32，32位，单精度
* f64，64位，双精度

Rust使用IEEE-754（计组：规格化）标准来描述，并使用f64为默认类型。

###### 数值操作

与其他语言一致，不细说。

##### 布尔类型

两种值：

false 和true

**均占一字节大小**。

![image-20240109173413254](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091734297.png)

##### 字符类型

* Rust中char类型被用来描述语言中最基础的单个字符。

* 字符类的字面值使用单引号
* 占用4字节
* 是unicode标量值，可以表示比ASCII多的字符内容：拼音，中日韩文，零长度空白字符，emoji表情等等。
  * 范围：U+0000 - U+D7FF
  * U+E000 - U+10FFFF

![image-20240109173823571](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091738649.png)

  

###  3.3 复合类型

* 复合类型可以提供多个值放在一个类型里面
* Rust提供了两种基础的复合类型：元组（Tuple），数组

#### Tuple

* Tuple可以将多个固定的多个值放在一个类型里面
* Tuple的长度是固定的：一旦声明就无法改没变

##### 创建Tuple

* 在小括号里面，将值用逗号分开
* Tuple中的每个位置都对应每一个类型，tuple中个元素类型不必

```rust
let hui:(i32,f64,char) = (32,5.4,'a');
    println!("{},{},{}",hui.0,hui.1,hui.2);
    //输出
    32,5.4,a
```

##### 获取Tuple的元素值

* 可以使用模式匹配来解构（destructure）一个Tuple来获取元素的值

```rust
let hui:(i32,f64,char) = (32,5.4,'a');
    let (x,y,z) = hui;
    println!("{},{},{}",hui.0,hui.1,hui.2);
    println!("{},{},{}",x,y,z);
//输出
32,5.4,a
32,5.4,a
```

##### 访问Tuple元素

* 在Tuple变量使用点标记法，后接元素的索引号；

```rust
let hui:(i32,f64,char) = (32,5.4,'a');
    println!("{},{},{}",hui.0,hui.1,hui.2);
    //输出
    32,5.4,a
```

#### 数组

* 数组也可以将多个值放在一个类型里面
* 数组中每个元素的类型必须相同
* 数组的长度也是固定的

##### 数组的类型

let a[u32;5] = [1,2,3,4,5];

[类型：长度]

**或者**：

let a[3;5] = [3,3,3,3,3];

[值：长度]

#### 访问数组元素

通过中括号的索引访问，与其它语言中一致；

注意简单的数组越界在编译时，rust会直接报错；当然复杂的越界不会；

**最大为12时**：

报错

![image-20240110132835971](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101328069.png)

不报错：

![image-20240110132905382](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101329420.png)

### 3.4 函数

* 声明函数使用fn关键字
* 按照惯例，针对函数和变量名，rust使用snake case命名规范

> snake case;
>
> 所有字母都是小写，单词之间使用下划线分开。

#### 函数的参数

* paremeters.arguments(形参，实参)
* 在函数的签名中必须声明每个参数的类型。

```rust
fn new_function(x:i32,y:u32);//这里的参数z，y也就是形参
```

![image-20240110141259671](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101412748.png)

这里有一点很重要：

注意这里y语句部分，x+3没有以分号结尾，所以这里其实相当于y = x + 3，只不过这里x的初值为1；只要看这里有没有返回值就可以，如果加了”；“，呢么这块语句就会被判定为没有返回值，y也就会被赋空值；并爆错，无法打印。

并且我们可以看到，**这里x没有shadow前一个x，它的作用域只在花括号中。**

#### 函数返回值

* 在->符号后面声明函数返回值的类型，但是不可以返回值命名
* 在Rust里面，返回值就是函数体里面最后一个表达式的值
* 若想提前返回，需要return关键字，并指定一个值
  * 大多数函数都默认使用最后一个表达式的值为返回值

```rust
fn six() -> i32{
        6
    }
    fn plus_six(x:i32) -> i32{
        x + 6
    }
    let yu = six();
    let xu = plus_six(6);
   
    println!("the value of yu {}",yu);
    println!("the value of yu {}",xu);
//输出
the value of yu 6
the value of yu 12
```

#### 注释

//

或者/**/

### 3.5 控制流

 #### if表达式

* if表达式允许您根据条件来执行不同的代码分支
  * **这个条件必须是bool类型**
* if表达式中，与条件相关联的代码块就叫arm分支；
* 可在后面添加else；

#### else if 处理多重条件

注意：**如果使用了多于一个else if，最好使用match语句重构你的代码**。

---



#### 循环

##### loop循环

反复执行一段代码，直至手动停止，或者break；



##### while条件循环

每次执行前都判断一次条件



##### for循环

![image-20240110144251556](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101442600.png)

最为重要的循环方法

![image-20240110144354390](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101443435.png)

通过Range生成，1，2，3三个数，并用rev（），逆序输出。



htb bizness

WP usage

Rust

第四章 所有权

RUST 学习

第一章

第四章所有权