Postgresql INNER JOIN从多个表中选择数据。

Postgresql - INNER JOIN


**协议没看懂~**

> 协议规定了用来实现某一特定功能所必需的方法和属性。
> 任意能够满足协议要求的类型被称为遵循(conform)这个协议。
> 类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能。

## 创建协议

```swift
protocol Identifiable {
    // 协议定义
    var id: String { get }
}
```

如果一个类型遵循协议，那么它必须提供协议中定义的所有要求。

```swift
struct User: Identifiable {
    var id: String
}
```

## 协议继承

协议之间可以继承，这样可以让遵循协议的类型拥有父协议中的属性和方法。

```swift
protocol Payable {
    func calculateWages() -> Int
}

protocol NeedsTraining {
    func study()
}

protocol HasVacation {
    func takeVacation(days: Int)
}

# 继承

protocol Payable: Payable, NeedsTraining, HasVacation {
    // 协议继承
}
```

## 扩展

`extension`允许向现有的类型添加方法，属性或者下标。类似于 js 的`prototype`。

```swift
extension Int {
    func squared() -> Int {
        return self * self
    }
}

let number = 8
number.squared() // 64
```

**不允许在扩展中添加存储属性**

```swift
extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}
```

## 协议扩展

```swift
let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"]
let beatles = Set(["John", "Paul", "George", "Ringo"])
```

Swift 的数组和集合都属于`Collection`，所以可以写个扩展来满足协议要求。

```swift
extension Collection {
    func summarize() {
        print("There are \(count) of us:")

        for name in self {
            print(name)
        }
    }
}

pythyon.summarize()
beatles.summarize()
```

## 总结

- 协议描述了一致类型必须具有的方法和属性，但不提供这些方法的实现。
- 您可以在其他协议之上构建协议，类似于类。
- 扩展允许您将方法和计算属性添加到特定类型，例如 Int.
- 协议扩展允许您向协议添加方法和计算属性。
- 面向协议的编程是将您的应用程序架构设计为一系列协议，然后使用协议扩展来提供默认方法实现的实践


协议规定了用来实现某一特定功能所必需的方法和属性。

Protocols - 协议


颜色是设计中一个非常重要的元素，对于网站、移动应用、平面设计、产品设计等多个领域都有着至关重要的作用。在 Web 设计中，我们通常使用 CSS 来定义颜色。

CSS 中，颜色的表示方法有以下几种：

- 关键词表示法：通过关键词来表示颜色，如 red、green、blue 等。这种方法简单易懂，但是可用的关键词数量有限，且颜色表达不够精确。
- 十六进制表示法：通过三个或六个十六进制数值来表示颜色，如 #FF0000 表示红色。这种方法可以表示任何颜色，且具有较高的精确度和灵活性，是 Web 设计中最常用的颜色表示方法之一。
- RGB 表示法：通过三个 RGB 值来表示颜色，如 rgb(255, 0, 0) 表示红色。这种方法也可以表示任何颜色，与十六进制表示法相比，更易于计算和调整。
- RGBA 表示法：与 RGB 表示法类似，但是增加了一个 alpha 通道，用于表示颜色的透明度。如 rgba(255, 0, 0, 0.5) 表示半透明的红色。
- HSL 表示法：通过色相（Hue）、饱和度（Saturation）、亮度（Lightness）三个值来表示颜色，如 hsl(0, 100%, 50%) 表示红色。这种方法更接近人类感知颜色的方式，也更容易理解和调整。
- HSLA 表示法：与 HSL 表示法类似，但是增加了一个 alpha 通道，用于表示颜色的透明度。如 hsla(0, 100%, 50%, 0.5) 表示半透明的红色。

以上就是 CSS 中常用的颜色表示方法。除了这些方法，还有其他一些颜色表示方法，如系统色、渐变色等，但在 Web 设计中应用较少。在实际设计中，我们需要根据设计需求和效果选择最合适的颜色表示方法。

## 案例

使用十六进制表示法定义背景颜色：

```css
body {
  background-color: #f7df1e; /* 黄色 */
}
```

使用 RGB 表示法定义字体颜色：

```css
h1 {
  color: rgb(255, 0, 0); /* 红色 */
}
```

使用 HSLA 表示法定义边框颜色和透明度：

```css
div {
  border: 2px solid hsla(240, 100%, 50%, 0.5); /* 半透明的蓝色边框 */
}
```

使用关键词表示法定义按钮颜色：

```css
button {
  background-color: deepskyblue; /* 深天蓝色 */
  color: white; /* 白色文字 */
}
```

使用渐变色定义背景颜色：

```css
body {
  background-image: linear-gradient(
    to bottom,
    #2980b9,
    #6dd5fa,
    #ffffff
  ); /* 从上到下渐变色背景 */
}
```


css - Color


源码：[fhsinchy/hello-dock](https://hub.docker.com/r/fhsinchy/hello-dock)

这是一个非常简单的 JavaScript 项目。

## 创建一个 Dockerfile

```dockerfile
FROM node:14.15.4-alpine3.12
EXPOSE 3000
USER node
RUN mkdir /home/node/app
WORKDIR /home/node/app
COPY ./package.json .
RUN npm install

COPY . .

CMD ["npm", "start"]
```

对以上文件进行解释：

- `FROM`：指定基础镜像，这里使用的是 `node:14.15.4-alpine3.12`，这是一个非常小的镜像，只有 88.9MB。
- `EXPOSE`：指定端口，这里指定的是 3000 端口。
- `USER`：指定用户，这里指定的是 `node`。
- `RUN`：执行命令，这里执行的是 `mkdir /home/node/app`。
- `WORKDIR`：指定工作目录，这里指定的是 `/home/node/app`。
- `COPY`：复制文件，这里复制的是 `package.json`。
- `RUN`：执行命令，这里执行的是 `npm install`。
- `COPY`：复制文件，这里复制的是 `.`，也就是当前目录下的所有文件。
- `CMD`：指定命令，这里指定的是 `npm start`。

## 构建镜像

```bash
docker build -t hello-dock .
```

`--file`选项可以指定 Dockerfile 的路径，`-t`选项可以指定镜像的名称。

执行命令后可以访问 [http://localhost:3000](http://localhost:3000) 查看效果。

## 挂载本地目录

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

```bash
docker run -it -p 3000:3000 -v $(pwd):/home/node/app hello-dock
```

`-v`选项可以挂载本地目录，这里挂载的是当前目录，也就是 `.`。

挂载本地目录后，修改本地文件后，可以直接在浏览器中查看效果。

## 使用匿名卷

```bash
docker run -it -p 3000:3000 -v /home/node/app/node_modules -v $(pwd):/home/node/app hello-dock
```

## 多阶段构建

```dockerfile
FROM node:lts-alpine as builder

WORKDIR /app

COPY ./package.json ./
RUN npm install

COPY . .
RUN npm run build

FROM nginx:stable-alpine

EXPOSE 80

COPY --from=builder /app/dist /usr/share/nginx/html
```

多阶段构建和单阶段构建的区别在于，多阶段构建可以减少镜像的大小。

- 第一阶段：安装依赖，构建项目。
- 第二阶段：使用 Nginx 镜像，将第一阶段构建的项目复制到 Nginx 的目录下。

构建镜像后，可以访问 [http://localhost:8080](http://localhost:8080) 查看效果。

多阶段构建适用于前端项目，因为前端项目的构建过程比较复杂，需要安装很多依赖，构建完成后，只需要将构建后的文件复制到 Nginx 的目录下即可。

## 忽略不需要的文件

```bash
.git
*Dockerfile*
*docker-compose*
node_modules
```


如何创建一个JavaScript docker镜像


## TLS & SSL

TSL 是一种安全传输协议，它是一种基于 SSL 的加密协议。

TSL 使用公钥加密数据，使用私钥解密数据。

公开密钥加密（public-key cryptography）也称为非对称密钥加密（asymmetric cryptography），是一种密码学算法类型。该加密算法使用两个不同的密钥：加密密钥和解密密钥。

私钥创建：

```bash
openssl genrsa -out private.pem 2048
```

证书创建：

```bash
openssl req -new -key private.pem -out csr.pem
```

使用 CSR 证书创建证书：

```bash
openssl x509 -req -in csr.pem -signkey private.pem -out certificate.pem
```

TLS 客户端实例：

```js
const tls = require('tls')
function connected(stream) {
  if (stream) {
    stream.write('GET / HTTP/1.0\n\rHost: encrypted.google.com:443\n\r\n\r')
  } else {
    console.log('Connection failed')
  }
}
var dummy = this
dummy.socket = tls.connect(443, 'encrypted.google.com', function () {
  dummy.connected = true
  if (dummy.socket.authorized) {
    dummy.socket.setEncoding('utf-8')
    connected(dummy.socket)
  } else {
    console.log(dummy.socket.authorizationError)
    connected(null)
  }
})
dummy.socket.addListener('data', function (data) {
  console.log(data)
})
dummy.socket.addListener('error', function (error) {
  if (!dummy.connected) {
    connected(null)
  }
  console.log('FAIL')
  console.log(error)
})
dummy.socket.addListener('close', function () {
  // do something
})
```

## Debugger

`Node.js`提供一个简单的基于 TCP 的调试器，可以在控制台中调试脚本。

语法：`node --inspect [script] [arguments]`或`node debug [script] [arguments]`

```bash
node demo.js
```

除此之外还可以使用`console.log`输出调试信息，这些信息将被输出到控制台。


TLS负责安全传输，SSL负责安全签名，Debugger负责调试。

Node.js - TLS & SSL & Debugger


## DNS

DNS 模块包含了域名解析的功能。

- `dns.getServers()` 返回一个数组，包含当前 DNS 服务器的 IP 地址。
- `dns.setServers(servers)` 设置 DNS 服务器的 IP 地址。
- `dns.lookup(domain, callback)` 查询域名的 IP 地址。
- `dns.lookupService(address, port, callback)` 查询 IP 地址和端口的服务名。
- `dns.resolve(domain, callback)` 查询域名的 IP 地址。
- `dns.resolve4(domain, callback)` 查询域名的 IPv4 地址。
- `dns.resolve6(domain, callback)` 查询域名的 IPv6 地址。
- `dns.resolveMx(domain, callback)` 查询域名的 MX 记录。
- `dns.resolveTxt(domain, callback)` 查询域名的 TXT 记录。
- `dns.resolveSrv(domain, callback)` 查询域名的 SRV 记录。
- `dns.resolveNs(domain, callback)` 查询域名的 NS 记录。
- `dns.resolveCname(domain, callback)` 查询域名的 CNAME 记录。
- `dns.reverse(domain, callback)` 查询 IP 地址的域名。

```js
const dns = require('dns')

dns.lookup('manon.icu', (err, address, family) => {
  console.log('ip 地址: %j 地址族: IPv%s', address, family)
})
```

## Net

模块提供了异步的网络 API，用于创建基于流的 `TCP` 或 `IPC` 服务器 `(net.createServer())` 和客户端

```js
const net = require('net')

const server = net
  .createServer((socket) => {
    socket.write('hello\r\n')
    socket.pipe(socket)
  })
  .on('error', (err) => {
    throw err
  })

server.listen(() => {
  const {port} = server.address()
  console.log('opened server on %j', port)
})
```


Node.js - DNS & Net


查询结果是无序的或者按照 id 排序的，如果需要按照某个字段排序，可以使用 order by 语句。

## 语法

```sql
SELECT
	select_list
FROM
	table_name
ORDER BY
	sort_expression1 [ASC | DESC],
        ...
	sort_expressionN [ASC | DESC];
```

- 首先需要在`ORDER BY`后面指定排序的字段和排序表达式，每个字段之间用逗号分隔。
- 如果没有指定排序的字段，则默认按照 id 排序。
- `ASC`表示升序，`DESC`表示降序。

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

## 示例

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

#### 查询所有的用户，并按照 first_name 升序排序。

```sql
SELECT
	first_name,
	last_name
FROM
	customer
ORDER BY
	first_name ASC;
```

`ASC`是默认排序选项，可以省略。

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

#### 查询所有的用户，并按照 last_name 降序排序。

```sql
SELECT
       first_name,
       last_name
FROM
       customer
ORDER BY
       last_name DESC;
```

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

#### 对多列排序

```sql
SELECT
	first_name,
	last_name
FROM
	customer
ORDER BY
	first_name ASC,
	last_name DESC;
```

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

#### 表达式排序

```sql
SELECT
	first_name,
	LENGTH(first_name) len
FROM
	customer
ORDER BY
	len DESC;
```

选择名字，并按照名字的长度进行降序排序。

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

## NULL

`NULL`是一个标记，表示丢失的数据或记录时数据未知。

对包含`NULL`行进行排序时，可以使用指定的排序表达式进行排序，比如：

```sql
ORDER BY sort_expresssion [ASC | DESC] [NULLS FIRST | NULLS LAST]
```

`NULL FIRST`表示 NULL 值优先，`NULL LAST`表示 NULL 值后来优先。

首先创建个表

```sql
-- create a new table
CREATE TABLE sort_demo(
	num INT
);

-- insert some data
INSERT INTO sort_demo(num)
VALUES(1),(2),(3),(null);
```

查询并返回数据

```sql
SELECT num
FROM sort_demo
ORDER BY num;
```

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

可以看到默认返回排序将 null 值放到最后，如果想改变这种默认的排序，可以使用`NULLS FIRST`或`NULLS LAST`。

```sql
SELECT num
FROM sort_demo
ORDER BY num NULLS FIRST;
```

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

翻转顺序

```sql
SELECT num
FROM sort_demo
ORDER BY num DESC NULLS LAST;
```

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

## 总结

- 排序的字段可以是一个表的列，也可以是一个表达式。
- 使用`ASC`或`DESC`指定排序顺序。
- 使用`NULLS FIRST`或`NULLS LAST`指定排序的 NULL 值优先级。
