Performance API是一个浏览器提供的API，可用于测量和分析Web应用程序的性能

Performance API


Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句。这些语句可以控制代码的执行流程，使程序能够根据不同的条件执行不同的代码路径。

以下是 Swift 中常用的控制流语句：

条件语句（if、else、else if）

```swift
let age = 20
if age < 18 {
  print("未成年人")
} else if age < 30 {
  print("年轻人")
} else {
  print("中年人")
}
```

循环语句（for、while、repeat-while）

```swift
// for 循环
for i in 1...5 {
  print(i)
}

// while 循环
var i = 0
while i < 5 {
  print(i)
  i += 1
}

// repeat-while 循环
i = 0
repeat {
  print(i)
  i += 1
} while i < 5
```

控制转移语句（break、continue、fallthrough、return、throw）

```swift
// break 语句
for i in 1...10 {
if i == 5 {
  break
}
print(i)
}

// continue 语句
for i in 1...10 {
if i % 2 == 0 {
  continue
}
print(i)
}

// fallthrough 语句
let score = 80
var grade = ""
switch score {
  case 0..<60:
  grade = "不及格"
  case 60..<70:
  grade = "及格"
  case 70..<80:
  grade = "中等"
  case 80..<90:
  grade = "良好"
  case 90...100:
  grade = "优秀"
  fallthrough
  default:
  print("你的成绩是 \(score)，评级是 \(grade)")
}

// return 语句
func sum(_ a: Int, _ b: Int) -> Int {
  return a + b
}

// throw 语句
enum MyError: Error {
  case error1
  case error2
}

func test() throws {
  throw MyError.error1
}
```

Swift 的控制流语句功能强大，使用灵活，可以编写出各种复杂的逻辑结构，从而满足不同的编程需求。需要根据具体的需求选择不同的控制流语句。


Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句

Swift - 控制流


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

![x9yBXT](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/x9yBXT.jpg)

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

![1zBzNp](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/1zBzNp.jpg)

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

![7eG9pZ](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/7eG9pZ.jpg)

### 比较同表的行

![GRiyfG](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/GRiyfG.jpg)

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

![AFkjme](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/AFkjme.jpg)


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


Next.js 是基于 React 的框架，它提供了一个简单的构建工具，可以让你快速构建一个网站。

## 安装

> 前置条件：安装 Node.js、npm

```bash
npm init -y
npm install next react react-dom

# + "next": "^12.1.6",
# + "react": "^18.1.0",
# + "react-dom": "^18.1.0"
```

```json
{
  "dependencies": {
    "next": "^12.1.6",
    "react": "^18.1.0",
    "react-dom": "^18.1.0"
  },
  "name": "demo",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {},
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "pfan",
  "license": "ISC",
  "description": ""
}
```

添加`build`和`start`命令

```bash
{
  "dependencies": {
    "next": "^12.1.6",
    "react": "^18.1.0",
    "react-dom": "^18.1.0"
  },
  "name": "demo",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {},
  "scripts": {
    "build": "next build",
    "start": "next start"
  },
  "author": "pfan",
  "license": "ISC",
  "description": ""
}
```

## 创建`pages`目录

```bash
mkdir pages && cd pages && touch index.js
```

```js
function HomePage() {
  return <div>Welcome to Next.js!</div>
}

export default HomePage
```

## 启动服务

```bash
npm run dev

#npm run dev --port=8888
#
#> demo@1.0.0 dev
#> next dev
#
#ready - started server on 0.0.0.0:3000, url: http://localhost:3000
```

![2mCs2M](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/2mCs2M.png)


Next.js是基于React的框架，它提供了一个简单的构建工具，可以让你快速构建一个网站。

Next.js - Environment Setup


## 什么是容器

在容器化里，容器是最基本的概念。正如官方解释：

> A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.
> 容器是一个标准的软件单元，它将代码和所有依赖打包起来，使得应用程序可以快速可靠地从一个计算环境迁移到另一个计算环境。

![5zgpMt](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/5zgpMt.jpg)

每个虚拟机都有自己的客户操作系统，其重量与主机操作系统一样。

在虚拟机中运行的应用程序与客户操作系统进行通信，客户操作系统与虚拟机管理程序进行通信，虚拟机管理程序再与主机操作系统进行通信，从而将必要的资源从物理基础设施分配给正在运行的应用程序。

正如你所看到的，在虚拟机中运行的应用程序与物理基础设施之间存在一条长长的通。在虚拟机中运行的应用程序可能只占用很少的资源，但是来宾操作系统增加了明显的开销。与虚拟机不同，容器以更智能的方式完成虚拟化的工作。它没有在容器中拥有完整的客户操作系统，而是通过容器运行时利用主机操作系统，同时保持隔离——就像传统的虚拟机一样。

![fVYWrK](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/fVYWrK.jpg)

容器运行时是一个软件层，它位于主机操作系统和容器之间。容器运行时的主要任务是将容器中的应用程序与主机操作系统隔离开来。容器运行时还负责管理容器的生命周期，包括创建、启动、停止、删除和暂停容器。

```shell
uname -a
# Linux alpha-centauri 5.8.0-22-generic #23-Ubuntu SMP Fri Oct 9 00:34:40 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

docker run alpine uname -a
# Linux f08dbbe9199b 5.8.0-22-generic #23-Ubuntu SMP Fri Oct 9 00:34:40 UTC 2020 x86_64 Linux
```

在上面的代码块中，我已经在主机操作系统上执行了 uname-a 命令，以打印出内核的详细信息。

然后在下一行中，我在运行 Alpine Linux 的容器中执行了相同的命令。

正如您在输出中看到的，容器确实使用了来自我的主机操作系统的内核。这证明了容器虚拟化主机操作系统而不是拥有自己的操作系统的观点。

如果你在一台 Windows 机器上，你会发现所有的容器都使用 WSL2内核。之所以会发生这种情况，是因为 WSL2充当 Windows 上 Docker 的后端。在 macOS 上，默认的后端是运行在 HyperKit hypervisor 上的 VM。

## 容器操作

当你部署你的应用程序，然后你想修复一个 bug，或者只是发布一个更新，会发生什么？

运行容器后，可以使用 docker ps 获取其 ID，然后使用 docker commit 从中为图像创建新标记：

```bash
docker commit <id> <username>/<imagename>:<tagname>
```

您还可以添加一条 changelog 消息，列出新版本中更改的内容：

```bash
docker commit --change "description" <id> <username>/<imagename>:<tagname>
```

```bash
# 列出本机正在运行的容器
$ docker container ls
```

```bash
# 列出本机所有容器，包括终止运行的容器
$ docker container ls --all
```

上面命令的输出结果之中，包括容器的 ID。很多地方都需要提供这个 ID，比如上一节终止容器运行的 docker container kill 命令。

终止运行的容器文件，依然会占据硬盘空间，可以使用 docker container rm 命令删除。

```bash
$ docker container rm [containerID]
```

运行上面的命令之后，再使用 docker container ls --all 命令，就会发现被删除的容器文件已经消失了。


什么是容器


`zlib`模块提供通过 `Gzip` 和 `Deflate/Inflate` 实现的压缩功能

## 创建和使用压缩流

```js
const zlib = require('zlib')
const gzip = zlib.createGzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt')
const out = fs.createWriteStream('input.txt.gz')
inp.pipe(gzip).pipe(out)
// 在桌面创建 input.txt 和 input.txt.gz 文件
```

## 解压缩和创建文件

```js
const zlib = require('zlib')
const gunzip = zlib.createGunzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt.gz')
const out = fs.createWriteStream('input.txt')
inp.pipe(gunzip).pipe(out)

// 在桌面创建 input.txt 和 input.txt.gz 文件
```

```

```


zlib模块提供通过 Gzip 和 Deflate/Inflate 实现的压缩功能

Node.js - zlib


**nohup**用于忽略 SIGHUP ("signal hang up" 译：挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行。

nohup 命令在默认情况下（非重定向时），会输出一个名叫 nohup.out 的文件到当前目录下，如果当前目录的 nohup.out 文件不可写，输出重定向到 $HOME/nohup.out 文件中。

## 使用方法

```bash
nohup <command>
```

停止运行

```bash
#使用如下命令找到进程pid，然后使用kill杀掉进程
ps -aux | grep <command>
```

## 参数

- Command：要执行的命令。
- Arg：一些参数，可以指定输出文件。
- &：让命令在后台执行，终端退出后命令仍旧执行。

nohup 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用


用于忽略 SIGHUP (挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行