## 操作系统概述

![](/static/img/24591489eb487ade62bc1ba9aa536d7f.image.png)

- 管理整个系统的软硬件资源
- 控制程序运行
- 人机之间的结构
- 应用软件与硬件之间的接口

管理职能：

- 进程管理
- 存储管理
- 文件管理
- 作业管理
- 设备管理





## 进程管理

### 进程状态

在操作系统中对进程进行管理时，为其指定几种状态以便分配资源

三态模型与五态模型：

![](/static/img/6ec3e1b30b25146579f35c1e5fc3a7fa.image.png)

### 前趋图

常考知识点，通常和pv操作结合起来考查

直观看到哪些任务可以并行，哪些任务有先后关系

### 进程的同步与互斥

同步与互斥不是一对反义词

互斥：在同一时刻只允许某一进程使用这一资源，其他进程等待，如同千军万马过独木桥（人行天桥：可以很多人一起过，是共享资源）

同步：速度有差异，在一定情况下等待

生产者与消费者问题：

![](/static/img/cfc97a432adc7e63fa93d594f05e5329.image.png)

### PV操作

解决并发操作中某些进程间的相互约束关系

临界资源：诸进程间需要互斥方式对其进行共享的资源，如打印机、磁带机等

临界区：每个进程中访问临界资源的那段代码称为临界区

信号量：一种特殊的变量

![](/static/img/7b538ec121b6f4256d0bb5786eb394b4.image.png)

![](/static/img/145be9def5a68102359389193874889b.image.png)

> 练习：
>
> ![](/static/img/a7e2a2e8594e99155677ff0b549b6f6d.image-20240825012338499.png)
>
> a1和b1应为一对PV操作，a2和b2应为一对PV操作，b1处应等待，a2处应等待，答案为A、C
>
> PV操作的核心在于找出进程的约束关系

### PV操作与前趋图

常考

![](/static/img/b30825eca676bee0bf289a559c6e0898.image.png)

![](/static/img/44a6ea92164407515bef5dea11b8e471.image-20240825013553542.png)

可以在箭头上标注信号量，箭头的起点位置是V操作，终点是P操作

### 死锁问题

如果一个进程在等待一件不可能发生的事，进程就死锁了，如果一个或多个进程产生死锁，就会造成系统死锁

> 例：系统有3个进程A、B、C，这三个进程都需要5个资源，则系统至少有13个资源才不可能发生死锁

k个进程，每个进程需要n个资源，则至少需要：`k * (n - 1) + 1`个资源

死锁的预防与避免：

![](/static/img/d573a5ff2a6c3bac14d76508cb569001.image.png)

### 银行家算法

基本思想：银行放贷的思路

- 当一个进程对资源的最大需求量不超过系统中的资源数时可以接纳该进程
- 进程可以分期请求资源，但请求的总数不能超过最大需求量
- 当系统现有的资源不能满足进程尚需资源数时，对进程的请求可以推迟分配，但总能使进程在有限的时间里得到资源

![](/static/img/4a709f0576552fd274d6767a22f3b621.image.png)

![](/static/img/64583c7961dc9ea66fc988e8a94f4f24.image.png)

## 存储管理

### 分区存储组织

- 首次适应法：按分区顺序放入第一个能放下的区块
- 最佳适应法：空闲区块按大小顺序连成一个链，从最小的开始比较，放入第一个能放下的区块，运行一段时间后系统中的碎块非常多且不好利用
- 最差适应法：空闲区块按大小顺序连成一个链，从最大的开始比较，放入第一个能放下的区块
- 循环首次适应法：把空闲区域连成一个环状，顺次分配

![image.png](/static/img/afff6b117e549e33cb634e29de12eb32.image.png)

### 页式存储组织

- 优点：利用率高，碎片小，分配及管理简单
- 缺点：增加了系统开销；可能产生抖动现象

页表存的是页号和页帧号（物理地址页号）

高级程序语言使用逻辑地址，运行状态、内存中使用物理地址

逻辑地址和物理地址的页内地址是相同的，页号是不同的


> ![image.png](/static/img/695bd943e4c384cd53275b181ed8f3aa.image.png)
>
> 1. $4K=2^{12}$，对应到十六进制是三位，页内地址为A29，页号为5.查表指物理地址页号（页帧号）为6
> 2. 不在内存中的页面不能淘汰，已经访问过的不能淘汰，故淘汰页号为1的页面

### 段式存储组织

段式存储组织按逻辑结构划分

- 优点：多道程序共享内存，各段程序修改互不影响
- 缺点：内存利用率低，内存碎片浪费大

段表存的是段长和基址

### 段页式存储组织

将段式和页式存储结合起来

- 优点：空间浪费小、存储共享容易、存储保护容易、能动态连接
- 缺点：由于管理软件的增加，复杂性和开销也随之增加，需要的硬件以及占用的内容也有所增加，使得执行速度大大下降

快表：一块小容量的相联存储器，速度快，由高速缓存器组成，可以从硬件上保证按内容并行查找，一般用来存放当前访问最频繁的少数活动页面的序号

### 页面置换算法（页面淘汰算法）

- 最优算法（OPT）：理论层面上的算法
- 随机算法（RAND）
- 先进先出算法（FIFO）：有可能产生“抖动”，淘汰第一个被使用的页面
- 最近最少使用算法（LRU）：不会“抖动”，淘汰最久没有被访问到的页面

![image.png](/static/img/20a9ff57a012bdf82beec4def73da2ce.image.png)


> 练习
>
> ![image.png](/static/img/89ad7445d1e518b3cab02c82ef7a2fb4.image.png)
>
> 1.不使用快表：需要查表，每一个页都要访问两次内存，一共六个页，需要访问十二次内存
>
> 2.约定俗成：认为指令是一次性读入，所以swap指令产生1次缺页中断，A和B各产生2次缺页中断，共5次

## 文件管理

### 索引文件结构

![image.png](/static/img/6439a5fe52e6b599027236dd6a1c583f.image.png)

一般索引文件结构有13个结点


> 练习
>
> ![image.png](/static/img/c5c8d45afaefed1049260d32b725a90d.image.png)

### 文件和树形目录结构

主要考查相对路径和绝对路径概念

文件属性

- R只读文件属性
- A存档属性
- S系统文件
- H隐藏文件

文件名的组成

- 驱动器号
- 路径
- 主文件名
- 扩展名

![image.png](/static/img/1ede242b54d2990d0341116229cd52f7.image.png)

### 空闲存储空间的管理

- 空闲区表法
- 空闲链表法
- 位示图法
- 成组链接法

![image.png](/static/img/7232ec8f38d1d534a736685c806fdeee.image.png)


> 练习
>
> ![image.png](/static/img/34f8cdd310b643ba18118e967154a368.image.png)
>
> $(4195+1)/32=131.125$，应在第132个字中描述
>
> $131*32=4192 -> 0-4191$，第132个字中，第0位置：4192，第3位置：4195
>
> **第n个字：从1开始；第m位置：从0开始**

## 设备管理

### 数据传输控制方式

内存和外设之间

- 程序控制方式（CPU介入最多）
- 程序中断方式
- DMA方式
- 通道
- 输入输出处理机

### 虚设备和Spooling技术

![image.png](/static/img/bb6e4c6ba1f066ede85f2441e5e55da1.image.png)

## 微内核操作系统

把内核做得更小的操作系统

可靠性、稳定性、安全性

![image.png](/static/img/8f08016eccbdf48f849c4a70b7e2873f.image.png)

软件设计师02-操作系统

## 数据的表示

### 进制转换

R进制转十进制使用**按权展开法**，每一位数都是 $R^k$
$$
二进制 10100.01 = 1 * 2^4 + 1 * 2^2 + 1 * 2^{-2}
$$
十进制转R进制使用**短除法**，将R作为除数，记录余数，逆序拼接

每三个二进制位对应一个八进制位，每四个二进制位对应一个十六进制位





### 编码

|      | 数值1         | 数值-1        | 1-1（1加负1） |
| ---- | ------------- | ------------- | ------------- |
| 原码 | **0**000 0001 | **1**000 0001 | **1**000 0010 |
| 反码 | **0**000 0001 | **1**111 1110 | **1**111 1111 |
| 补码 | **0**000 0001 | 1111 1111     | **0**000 0000 |
| 移码 | 1000 0001     | 0111 1111     | 1000 0000     |

正数的原码、反码、补码相等

负数的反码：符号位不变，其他位按位取反

负数的补码：反码+1

移码：对补码首位取反

表示范围：

|      | 整数                         |
| ---- | ---------------------------- |
| 原码 | $-(2^{n-1}-1)$ ~ $2^{n-1}-1$ |
| 反码 | $-(2^{n-1}-1)$ ~ $2^{n-1}-1$ |
| 补码 | $-2^{n-1}$~ $2^{n-1}-1$      |

原码和反码中+0与-0的表示不同，补码中相同，所以比原码和反码的范围少1

### 浮点数运算

浮点数表示：$N = M * R ^ e$，M：尾数，e：指数，R：基数

对阶→尾数计算→结果格式化

## 计算机结构

![image.png](/static/img/99828c942b95e184f95a6874d4681da2.image.png)

状态条件寄存器：存储运算过程中相关的标志位

## Flynn分类法

分类依据：指令流和数据流

| 体系结构类型               | 结构                                                 | 关键特性                               | 代表                                                       |
| -------------------------- | ---------------------------------------------------- | -------------------------------------- | ---------------------------------------------------------- |
| 单指令流单数据流<br />SISD | 控制部分：一个<br />处理器：一个<br />主存模块：一个 |                                        | 单处理器系统                                               |
| 单指令流多数据流<br />SIMD | 控制部分：一个<br />处理器：多个<br />主存模块：多个 | 各处理器以异步的形式执行同一条指令     | 并行处理机<br />阵列处理机（数组类型）<br />超级向量处理机 |
| 多指令流单数据流<br />MISD | 控制部分：多个<br />处理器：一个<br />主存模块：多个 | 被证明不可能，至少是不实际             | 目前没有，有文献称流水线计算机为此类                       |
| 多指令流多数据流<br />MIMD | 控制部分：多个<br />处理器：多个<br />主存模块：多个 | 能够实现作业、任务、指令等各级全面并行 | 多处理机系统<br />多计算机                                 |



## CISC与RISC

| 指令系统类型 | 指令                                                         | 寻址方式   | 实现方式                                             | 其它                       |
| ------------ | ------------------------------------------------------------ | ---------- | ---------------------------------------------------- | -------------------------- |
| CISC（复杂） | 数量多，使用频率差别大，可变长格式                           | 支持多种   | 微程序控制技术（微码）                               | 研制周期长                 |
| RISC（精简） | 数量少，使用频率接近，定长格式，大部分为单周期指令，操作寄存器，只有Load/Store操作内存 | 支持方式少 | 增加了通用寄存器；硬布线逻辑控制为主；适合采用流水线 | 优化编译，有效支持高级语言 |



## 流水线技术

**几乎每次考试都会考到**

### 概念

流水线是指在程序执行时多条指令重叠进行操作的一种准并行处理实现技术。各种部件同时处理是针对不同指令而言的，它们可同时为多条指令的不同部分进行工作，以提高各部件的利用率和指令的平均执行速度

取指→分析→执行

![image.png](/static/img/b84762fa78fc6dfe88c428fb5e060fea.image.png)

### 计算

流水线周期为执行时间最长的一段

流水线计算公式：1条指令执行时间 + (指令条数 - 1) * 流水线周期*

1. 理论公式：$(t1 + t2 + ... + tk) + (n - 1) * {\Delta}t$
2. 实践公式：$(k + n - 1) * \Delta t$
3. 考试时首先用到理论公式，若无理论公式答案再用实践公式

### 吞吐率计算

在单位时间内流水线处理的任务数量或输出的结果数量

基本公式：$TP = \frac{指令条数}{流水线执行时间}$

流水线最大吞吐率：$TP_{max} = \lim_{n \to \infty} \frac{n}{(k+n-1)\Delta{t}} = \frac{1}{\Delta{t}}$

### 加速比计算

完成同一批任务，不使用流水线的时间与使用流水线的时间的比值

### 效率计算

流水线的设备利用率。在时空图上，流水线的效率定义为n个任务占用的时空区与k个流水段总的时空区之比

公式：$E = \frac{n个任务占用的时空区}{k个流水段的总的时空区} = \frac{T_0}{kT_k}$

### 例
:::note{title="例1"}
![image.png](/static/img/6712498a19d145c82ede8e9ff5aae758.image.png)

- 流水线周期为2ns
- 流水线执行时间使用理论公式计算为$(2ns + 2ns + 1ns) + 99 \times 2ns = 203ns$
- 流水线执行时间使用实践公式计算为$(3 + 100 - 1) \times 2ns = 204ns$
- 流水线吞吐率$TP = \frac{100}{203}$
- 最大吞吐率$TP_{max} = \frac{1}{2}$
- 加速比$\frac{(2 + 2 + 1) \times 100}{203} = \frac{500}{203}$
:::

:::info{title="例2"}
![image.png](/static/img/44472f4fc05eeafd473de6afeeabd533.image.png)
- 流水线效率$E = \frac{(\Delta t + \Delta t + \Delta t + 3\Delta t) \times 4}{4 \times 15\Delta t}$
:::

## 存储系统

### 层次化存储结构

![image.png](/static/img/934ed287167727d83e48a24f736c1912.image.png)

寄存器容量极小，速度极快

Cache是高速缓存，按内容存取，不是必需的，K字节和M字节

从上到下，速度减慢，容量增加

### Cache

- 提高CPU数据输入输出的速率，突破冯·诺依曼瓶颈（即CPU与存储系统间数据传送带宽限制）
- 在计算机的存储系统体系中，Cache是访问速度最快的层次（有寄存器可选时选寄存器，没有寄存器选cache）
- 使用Cache改善系统性能的依据；程序的局部性原理

$t_1$：Cache的周期时间（1ns），$t_2$：主存储器周期时间（1ms），$t_3$：以读操作为例使用“Cache+主存储器”的系统的平均周期，$h$：访问命中率（95%），1-h：失效率（未命中率）
$$
t_3 = h \times t_1 + (1 - h) \times t_2 \\
t_3 = 95 \% \times 1ns + (1 - 95\%) \times 1000ns = 50.95ns
$$

### 局部性原理

- 时间局部性：顺序执行的代码，分成不同的块，放入cache中，特别是for循环比较明显，将其运行的代码放入cache中，每次循环从cache调用即可
- 空间局部性：数组较为明显，当程序首先访问某空间，立即访问邻近的空间
- 工作集理论：工作集是进程运行时被频繁访问的页面集合

### 主存

#### 分类

![image.png](/static/img/ceee086c86d4d346ef65626ed3f70614.image.png)

#### 编址

把芯片组成相应的存储器

![image.png](/static/img/2ee99b61aa299b0b8befd0e84a329761.image.png)

> ![image.png](/static/img/252e49307047949a21c55c08732e6e28.image.png)
>
> 地址单元：$C7FFFH + 1 - AC000H = C8000H - AC000H = 1C000H = \frac{1C000}{2^{10}} K = 112K$
>
> 每个存储单元存储几位：$\frac{112K \times 16bit}{28 \times 16K \times xbit} = 1$，得出$x = 4$

### 磁盘结构与参数

![image.png](/static/img/873910ce03d2bcb5cffb955f77dc0199.image.png)


存取时间 = 寻道时间 + 等待时间（平均定位时间 + 转动延迟）

寻道时间是磁头移动到磁道所需的时间，等待时间为等待读写的扇区转到磁头下方所用的时间

> ![image-20240824231613563.png](/static/img/ad2dfe481616d86e907720dbf04b34e5.image-20240824231613563.png)
>
> 磁盘旋转周期为33ms，则平均每一个扇区的旋转时间为3ms，即读取时间为3ms
>
> 单缓冲区意味着一次只能处理一个记录，当$R_0$被读取并处理时，磁盘继续转动，要想继续处理$R_1$，需要等待磁盘继续旋转至磁头在$R_1$处
>
> 所以最长处理时间为$(33ms + 3ms) \times 10 + 6ms = 366ms$
>
> 对于最少处理时间，最优分布情况为，我们希望在$R_0$处理完毕后，磁头恰好处于$R_1$的位置，以此类推，最少处理时间为$6ms \times 11 = 66ms$，如下图所示
>
> ![image-20240824232412060.png](/static/img/1e209a45ce0045be121dcfdc09d53e73.image-20240824232412060.png)


## 总线系统

根据总线所处的位置不同通常分为三种类型：

- 内部总线：微机内部各个外围芯片与处理器之间的总线
- 系统总线：CPU、主存、I/O设备各大部件之间的信息传输线
  - 数据总线
  - 地址总线
  - 控制总线
- 外部总线：微机和外部的总线

## 可靠性

串联系统与并联系统

![image.png](/static/img/d4eb18ebe080f6143699efb5b3093ac6.image.png)

![image.png](/static/img/269a5f8ede70696c14e2ffdc0d469efc.image.png)

n模冗余模型


![image.png](/static/img/a7ad7b6feb5110ad66870e71a10ee78f.image.png)


> ![image.png](/static/img/bf7e56c8623bcf3522bc598eb10011d5.image.png)
>
> $R \times (1 - (1 - R)^3) \times (1 - (1 - R)^2)$

## 校验码

### 基本概念

检错和纠错的方法就是提高码距

码距：整个编码系统中任意（所有）两个码字的最小距离

- 在一个码组内为了检测e个误码，要求最小码距d应该满足：d>=e+1
- 在一个码组内为了纠正t个误码，要求最小码距d应该满足：d>=2t+1

> 若用1位长度的二进制编码，若A=1，B=0，这样A、B之间的最小码距为1
>
> 若用2位长度的二进制编码，若A=11，B=00，这样A、B之间的最小码距为1
>
> 若用3位长度的二进制编码，可选用111，000作为合法编码，A、B之间的最小码距为3

### 循环校验码CRC

考试中所认可的标准：可以做检错，不能做纠错

用到模2除法：做除法运算的过程中不计其进位的除法


![image.png](/static/img/4d23159da71474e3b92dc260936c2173.image.png)

> 原始报文为`11001010101`，其生成多项式为：$x^4+x^3+x+1$，对其进行CRC编码：
>
> - 生成多项式，对应二进制的位数为0还是1，本例中为11011
> - 编码时，要对原始报文用0进行末尾补位，补位长度为生成多项式长度-1
> - 最后进行模2除法，得到余数后，替换补位
> - ![image.png](/static/img/661130928a0b2f0b72e0ccaed85d3426.image.png)
> - 收到编码信息后，将编码与生成多项式进行模2除法，得到的余数应该是0


### 海明校验码

**难点，考查频度高**

了解海明码编码基本规则，知道如何编码，计算多少位信息位需要多少个校验位

要求校验位的位置应为2<sup>n</sup>位

例，要放1个信息位，则长度应为3位，因为前两位都是校验码

假设校验码有r位，信息位有x位，则 $2^r >= x + r + 1$

![image.png](/static/img/45cfa792ff542f7ac34aa309726572c8.image.png)

海明校验码可以检错，也可以纠错，若校验位不同，则可以根据出错的校验位定位到出错的信息位

软件设计师01-计算机组成与体系结构

<h1 style="text-align: center;font-size: 76px;line-height: 1.25;font-weight: 900;letter-spacing: -1.5px;max-width: 960px;margin: 0 auto;border-bottom: 0 !important;padding-bottom: 0 !important">
    <span style="background: -webkit-linear-gradient(315deg,#42d392 25%,#647eff);background-clip: text;-webkit-background-clip: text;-webkit-text-fill-color: transparent;">Vue3 - 渐进式</span>
    <br data-v-9e9e3e87="">
    JavaScript 框架 
</h1>
<p style="text-align: center;max-width: 960px;line-height: 1.5;color: var(--vt-c-text-2);transition: color .5s;font-size: 22px;margin: 24px auto 40px;"> 易学易用，性能出色，适用场景丰富的 Web 前端框架。 </p>



## Teleport

> 有时我们可能会遇到这样的场景：一个组件模板的一部分在逻辑上从属于该组件，但从整个应用视图的角度来看，它在 DOM 中应该被渲染在整个 Vue 应用外部的其他地方。
>
> 这类场景最常见的例子就是全屏的模态框。理想情况下，我们希望触发模态框的按钮和模态框本身是在同一个组件中，因为它们都与组件的开关状态有关。但这意味着该模态框将与按钮一起渲染在应用 DOM 结构里很深的地方。这会导致该模态框的 CSS 布局代码很难写。

Teleport 是一种能够将我们的**组件html结构**移动到指定位置的技术

例如，当父组件中使用了 `filter` 等 css 属性时，子组件的 `position` 属性会失效，这时可以使用 `<teleport to="dom"></teleport>` 挂载到某一html结点上，`to` 的值为元素选择器

```vue
<template>
  <button @click="show = true">Show Modal</button>
  <Teleport to="body">
    <div class="modal" v-show="show">
      <h2>Modal Title</h2>
      <p>Modal content</p>
      <button @click="show = false">close</button>
    </div>
  </Teleport>
</template>
```

指定目标容器：

```vue
<Teleport to="#some-id" />
<Teleport to=".some-class" />
<Teleport to="[data-teleport]" />
```

有条件地禁用：

```vue
<Teleport to="#popup" :disabled="displayVideoInline">
  <video src="./my-movie.mp4">
</Teleport>
```


:::tip{title="提示"}
`<Teleport>` 挂载时，传送的 `to` 目标必须已经存在于 DOM 中。理想情况下，这应该是整个 Vue 应用 DOM 树外部的一个元素。如果目标元素也是由 Vue 渲染的，你需要确保在挂载 `<Teleport>` 之前先挂载该元素。
:::

## Suspense


:::warning{title="实验性功能"}
`<Suspense>` 是一项实验性功能。它不一定会最终成为稳定功能，并且在稳定之前相关 API 也可能会发生变化。
:::

等待异步组件时渲染一些额外内容，让应用有更好的用户体验

使用 `Suspense` 包裹组件，并配置好 `default` 与 `fallback` (底层使用插槽实现)

```vue
<template>
  <div class="outer">
    <h2>App</h2>
    <Suspense>
      <template v-slot:default>
        <Child />
      </template>
      <template v-slot:fallback>
        <h2>loading</h2>
      </template>
    </Suspense>
  </div>
</template>
```

## 全局 API 转移到应用对象

- `app.component`

  ```typescript
  import Hello from './Hello';
  app.component('Hello', Hello);
  ```

  

- `app.config`

  ```typescript
  app.config.globalProperties.x = 99;
  declare module 'vue' {
    interface ComponentCustomProperties {
      x: number
    }
  }
  ```

  

- `app.directive`

  ```typescript
  /* main.ts */
  app.directive('beauty', (element, {value}) => {
    element.innerText += value;
    element.style.color = 'red';
    element.style.backgroundColor = 'skyblue';
  })
  
  /* Comp.vue */
  <h3 v-beauty="count">哈哈哈</h3>
  ```

  

- `app.mount`

- `app.unmount`

  ```typescript
  setTimeout(() => {
    app.unmount();
  }, 2000);
  ```

  

- `app.use`

## Vue3 的非兼容性改变

[非兼容性改变 | Vue 3 迁移指南 (vuejs.org)](https://v3-migration.vuejs.org/zh/breaking-changes/)

### 全局API

- [全局 Vue API 更改为使用应用程序实例](https://v3-migration.vuejs.org/zh/breaking-changes/global-api.html)
- [全局和内部 API 都经过了重构，现已支持 TreeShaking （摇树优化）](https://v3-migration.vuejs.org/zh/breaking-changes/global-api-treeshaking.html)

### 模板指令

- [`v-model` 指令在组件上的使用已经被重新设计，替换掉了 `v-bind.sync`](https://v3-migration.vuejs.org/zh/breaking-changes/v-model.html)
- [在`
- [`v-if` 和 `v-for` 在同一个元素身上使用时的优先级发生了变化](https://v3-migration.vuejs.org/zh/breaking-changes/v-if-v-for.html)
- [`v-bind="object"` 现在是顺序敏感的](https://v3-migration.vuejs.org/zh/breaking-changes/v-bind.html)
- [`v-on:event.native` 事件修饰符已经被移除](https://v3-migration.vuejs.org/zh/breaking-changes/v-on-native-modifier-removed)

### 组件

- [函数式组件只能通过纯函数进行创建](https://v3-migration.vuejs.org/zh/breaking-changes/functional-components.html)
- [单文件组件 (SFC) `
- [异步组件现在需要通过 `defineAsyncComponent` 方法进行创建](https://v3-migration.vuejs.org/zh/breaking-changes/async-components.html)
- [组件事件现在应该使用 `emits` 选项进行声明](https://v3-migration.vuejs.org/zh/breaking-changes/emits-option.html)

### 渲染函数

- [渲染函数 API 更改](https://v3-migration.vuejs.org/zh/breaking-changes/render-function-api.html)
- [`$scopedSlots` property 已移除，所有插槽都通过 `$slots` 作为函数暴露](https://v3-migration.vuejs.org/zh/breaking-changes/slots-unification.html)
- [`$listeners` 被移除或整合到 `$attrs`](https://v3-migration.vuejs.org/zh/breaking-changes/listeners-removed)
- [`$attrs` 现在包含 `class` 和 `style` attribute](https://v3-migration.vuejs.org/zh/breaking-changes/attrs-includes-class-style)

### 自定义元素

- [自定义元素检测现在在模板编译时执行](https://v3-migration.vuejs.org/zh/breaking-changes/custom-elements-interop.html)
- [特殊的 `is` attribute 的使用被严格限制在被保留的 `` 标签中](https://v3-migration.vuejs.org/zh/breaking-changes/custom-elements-interop.html#定制内置元素)

### 其他小改变

- `destroyed` 生命周期选项被重命名为 `unmounted`
- `beforeDestroy` 生命周期选项被重命名为 `beforeUnmount`
- [Props 的 `default` 工厂函数不再可以访问 `this` 上下文](https://v3-migration.vuejs.org/zh/breaking-changes/props-default-this.html)
- [自定义指令的 API 已更改为与组件生命周期一致，且 `binding.expression` 已移除](https://v3-migration.vuejs.org/zh/breaking-changes/custom-directives.html)
- [`data` 选项应始终被声明为一个函数](https://v3-migration.vuejs.org/zh/breaking-changes/data-option.html)
- [来自 mixin 的 `data` 选项现在为浅合并](https://v3-migration.vuejs.org/zh/breaking-changes/data-option.html#mixin-合并行为变更)
- [Attribute 强制策略已更改](https://v3-migration.vuejs.org/zh/breaking-changes/attribute-coercion.html)
- [Transition 的一些 class 被重命名](https://v3-migration.vuejs.org/zh/breaking-changes/transition.html)
- [`` 不再默认渲染包裹元素](https://v3-migration.vuejs.org/zh/breaking-changes/transition-group.html)
- [当侦听一个数组时，只有当数组被替换时，回调才会触发，如果需要在变更时触发，则必须指定 `deep` 选项](https://v3-migration.vuejs.org/zh/breaking-changes/watch.html)
- 没有特殊指令的标记 (`v-if/else-if/else`、`v-for` 或 `v-slot`) 的 `<template>` 现在被视为普通元素，并将渲染为原生的 `<template>` 元素，而不是渲染其内部内容。
- [已挂载的应用不会替换它所挂载的元素](https://v3-migration.vuejs.org/zh/breaking-changes/mount-changes.html)
- [生命周期的 `hook:` 事件前缀改为 `vue:`](https://v3-migration.vuejs.org/zh/breaking-changes/vnode-lifecycle-events.html)

### 被移除的 API

- [`keyCode` 作为 `v-on` 修饰符的支持](https://v3-migration.vuejs.org/zh/breaking-changes/keycode-modifiers.html)
- [$on、$off 和 $once 实例方法](https://v3-migration.vuejs.org/zh/breaking-changes/events-api.html)
- [过滤器 (filter)](https://v3-migration.vuejs.org/zh/breaking-changes/filters.html)
- [内联模板 attribute](https://v3-migration.vuejs.org/zh/breaking-changes/inline-template-attribute.html)
- [`$children` 实例 property](https://v3-migration.vuejs.org/zh/breaking-changes/children.html)
- [`propsData` 选项](https://v3-migration.vuejs.org/zh/breaking-changes/props-data.html)
- `$destroy` 实例方法。用户不应该再手动管理单个 Vue 组件的生命周期。
- 全局函数 `set` 和 `delete` 以及实例方法 `$set` 和 `$delete`。基于代理的变化检测已经不再需要它们了。

Vue学习07：Vue 3新特性

## shallowRef 与 shallowReactive

> 通过使用 [`shallowRef()`](https://cn.vuejs.org/api/reactivity-advanced.html#shallowref) 和 [`shallowReactive()`](https://cn.vuejs.org/api/reactivity-advanced.html#shallowreactive) 来绕开深度响应。浅层式 `API` 创建的状态只在其顶层是响应式的，对所有深层的对象不会做任何处理，避免了对每一个内部属性做响应式所带来的性能成本，这使得属性的访问变得更快，可提升性能。



```vue
<script setup lang="ts">
import { shallowReactive, shallowRef } from 'vue';

let count = shallowRef(0);
let person = shallowRef({
  name: '张三',
  age: 18
});
let car = shallowReactive({
  brand: '奔驰',
  options: {
    color: 'red',
    engine: 'V8'
  }
});

function changeCount() {
  count.value += 1;
}

function changeName() {
  person.value.name = '李四';
}

function changeAge() {
  person.value.age += 1;
}

function changePerson() {
  person.value = { name: 'tony', age: 100 };
}

function changeBrand() {
  car.brand = '保时捷';
}

function changeColor() {
  car.options.color = 'black';
}

function changeEngine() {
  car.options.color = 'V12';
}

function changeCar() {
  Object.assign(car, {
    brand: '埃文塔多',
    options: {
      color: 'yellow',
      engine: 'V10'
    }
  });
}
</script>

<template>
  <div>
    <h2>计数：{{ count }}</h2>
    <h2>姓名：{{ person.name }}</h2>
    <h2>年龄：{{ person.age }}</h2>
    <button @click="changeCount">count + 1</button>
    <button @click="changeName">修改姓名</button>
    <button @click="changeAge">修改年龄</button>
    <button @click="changePerson">修改整个人</button>
    <h2>{{ car }}</h2>
    <button @click="changeBrand">修改品牌</button>
    <button @click="changeColor">修改颜色</button>
    <button @click="changeEngine">修改发动机</button>
    <button @click="changeCar">修改整台车</button>
  </div>
</template>
```

![GIF 2024-3-3 21-40-59.gif](/static/img/f6cd734c353628707e7e4185dfb456ef.GIF%202024-3-3%2021-40-59.gif)

## readonly 与 shallowReadonly

### readonly

创建一个对象的深只读副本，对于 `ref` 和 `reactive` 都生效

特点：

- 对象的所有嵌套属性都将变为只读
- 任何尝试修改这个对象的操作都会被阻止（在开发模式下，还会在控制台中发出警告）
- 原对象更改，`readonly` 对象同步更改

应用场景：

* 创建不可变的状态快照
* 保护全局状态或配置不被修改

```vue
<script setup lang="ts">
import { readonly, ref, shallowReactive, shallowRef } from 'vue';

let count1 = ref(0);
let count2 = readonly(count1);

function addCount1() {
  count1.value += 1;
}

function addCount2() {
  count2.value += 1;
}
</script>

<template>
  <div>
    <h2>当前count1为：{{ count1 }}</h2>
    <button @click="addCount1">count1 + 1</button>
    <h2>当前count2为：{{ count2 }}</h2>
    <button @click="addCount2">count2 + 1</button>
  </div>
</template>

<style scoped></style>
```

![image-20240304200339943.png](/static/img/88ef9540208dc54e88b32f14a2f4fe5f.image-20240304200339943.png)

![GIF 2024-3-4 20-04-56.gif](/static/img/44e9cb4dae11056e2db6b1ea7c76a0ea.GIF%202024-3-4%2020-04-56.gif)
### shallowReadonly

1. 作用：与 `readonly` 类似，但只作用于对象的顶层属性

2. 用法：

   ```js
   const original = reactive({ ... });
   const shallowReadOnlyCopy = shallowReadonly(original);
   ```

3. 特点：

   * 只将对象的顶层属性设置为只读，对象内部的嵌套属性仍然是可变的
   * 适用于只需保护对象顶层属性的场景



## toRaw 与 markRaw

### toRaw

用于获取一个响应式对象（ [`reactive()`](https://cn.vuejs.org/api/reactivity-core.html#reactive)、[`readonly()`](https://cn.vuejs.org/api/reactivity-core.html#readonly)、[`shallowReactive()`](https://cn.vuejs.org/api/reactivity-advanced.html#shallowreactive) 或者 [`shallowReadonly()`](https://cn.vuejs.org/api/reactivity-advanced.html#shallowreadonly) ）的原始对象，`toRaw` 返回的对象不再是响应式的，不会触发视图更新

> 这是一个可以用于临时读取而不引起代理访问/跟踪开销，或是写入而不触发更改的特殊方法。不建议保存对原始对象的持久引用，请谨慎使用。

在需要将响应式对象传递给非 Vue 的库或外部系统时，使用 `toRaw` 可以确保它们收到的是普通对象

```typescript
import { reactive, toRaw } from 'vue';

let person = reactive({
  name: 'Morales',
  age: 23
});

console.log('person', person); // 响应式对象
console.log('toRaw(person)', toRaw(person)); // 原始对象
```

### markRaw

标记一个对象，使其**永远不会**变成响应式的

例如，使用`mockjs`时，为了防止误把`mockjs`变为响应式对象，可以使用 `markRaw` 去标记`mockjs`

```typescript
let car = markRaw({
  brand: 'BMW M3 GTR',
  price: 150
});
let car2 = reactive(car);

console.log('car', car)
console.log('car2', car2)
```


:::warning{title="谨慎使用"}
`markRaw()` 和类似 `shallowReactive()` 这样的浅层式 API 使你可以有选择地避开默认的深度响应/只读转换，并在状态关系谱中嵌入原始的、非代理的对象。它们可能出于各种各样的原因被使用：

- 有些值不应该是响应式的，例如复杂的第三方类实例或 Vue 组件对象。
- 当呈现带有不可变数据源的大型列表时，跳过代理转换可以提高性能。

这应该是一种进阶需求，因为只在根层能访问到原始值，所以如果把一个嵌套的、没有标记的原始对象设置成一个响应式对象，然后再次访问它，你获取到的是代理的版本。这可能会导致**对象身份风险**，即执行一个依赖于对象身份的操作，但却同时使用了同一对象的原始版本和代理版本：

```typescript
const foo = markRaw({
  nested: {}
})

const bar = reactive({
  // 尽管 `foo` 被标记为了原始对象，但 foo.nested 却没有
  nested: foo.nested
})

console.log(foo.nested === bar.nested) // false
```

识别风险一般是很罕见的。然而，要正确使用这些 API，同时安全地避免这样的风险，需要你对响应性系统的工作方式有充分的了解。
:::

## customRef

创建一个自定义的 `ref`，并对其依赖项跟踪和更新触发进行逻辑控制

```vue
<script setup lang="ts">
import { customRef, ref } from 'vue';

// 使用 Vue 提供的默认 ref 定义响应式数据，数据变化页面随即更新
// let msg = ref('你好')

// 使用 Vue 提供的 customRef 定义响应式数据
let initValue = '你好'
let msg = customRef((track, trigger) => { // track 跟踪，trigger 触发
  return {
    // msg 被读取时调用
    get() {
      console.log('get');
      track(); // 让 Vue 对 msg 进行追踪
      return initValue;
    },
    // msg 被修改时调用
    set(value) {
      console.log('set', value);
      initValue = value;
      trigger(); // 通知 Vue 数据 msg 发生变化
    }
  }
})
</script>

<template>
  <div>
    <h2>{{ msg }}</h2>
    <input type="text" v-model="msg">
  </div>
</template>
```

将自定义 ref 封装为 hooks，并实现输入时防抖：

*useMsgRef.ts*

```typescript
import { customRef } from "vue";

export default function (initValue: string, delay: number) {
  let msg = customRef((track, trigger) => { // track 跟踪，trigger 触发
    let timer: number;
    return {
      // msg 被读取时调用
      get() {
        console.log('get');
        track(); // 让 Vue 对 msg 进行追踪
        return initValue;
      },
      // msg 被修改时调用
      set(value) {
        clearTimeout(timer);
        timer = setTimeout(() => {
          console.log('set', value);
          initValue = value;
          trigger(); // 通知 Vue 数据 msg 发生变化
        }, delay);
      }
    }
  })
  return { msg };
}
```

*App.vue*

```vue
<script setup lang="ts">
import useMsgRef from './hooks/useMsgRef';

let { msg } = useMsgRef(initValue, 1000);
</script>

<template>
  <div>
    <h2>{{ msg }}</h2>
    <input type="text" v-model="msg">
  </div>
</template>
```

![GIF 2024-3-4 22-30-41.gif](/static/img/b16ad334f9b1c60d2d80e2294a35db7d.GIF%202024-3-4%2022-30-41.gif)

操作系统概述

数据的表示

进制转换

Vue3 - 渐进式 JavaScript 框架

shallowRef 与 shallowReactive

props

Vue3 - 渐进式
JavaScript 框架