使用 Nodejs、 Express、 Postgres 和 Docker 在 JavaScript 中构建 CRUD Rest API


## 总览

程序员经常会用到的集合，列表、字典、集合。比如：

- 股票池
- 股票价格

有多种选择来处理这一系列数据：

- 列表。表示一组有序的数据
- 字典。表示一组键值对的数据
- 集合。表示一组无序的数据

## 列表

当数据的顺序很重要时，使用列表。记住列表可以容纳任何类型的对象。例如，元组列表。

```python
portfolio = [
    ('GOOG', 100, 490.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44)
]

portfolio[0]            # ('GOOG', 100, 490.1)
portfolio[2]            # ('CAT', 150, 83.44)

# 列表构造
records=[] #初始化一个空列表

records.append(('foo', 1, 2)) #添加元素
records.append(('bar', 'hello')) #添加元素

#从文件读取数据并写入列表
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        records.append((row[0], row[1], row[2]))
```

## 字典

如果你想要快速随机查找(按键名) ，字典是很有用的。例如，股票价格字典:

```python
prices = {
   'GOOG': 513.25,
   'CAT': 87.22,
   'IBM': 93.37,
   'MSFT': 44.12
}

prices['IBM']           # 93.37
prices['MSFT']          # 44.12

# 字典构造
prices = {} #初始化一个空字典

prices['GOOG'] = 513.25 #添加元素
prices['CAT'] = 87.22 #添加元素

#从文件读取数据并写入字典
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        prices[row[0]] = row[1]

# 字典查找
if 'GOOG' in prices:
    print('GOOG is in prices')

name = prices.get('GOOG', 'N/A') #N/A表示默认值

prices.get('GOOG', 0) # 513.25
prices.get('SCOX', 0) # 0

# 复合键 - 任何类型的数据都可以作为字典的键。例如，元组:

holidays = {
    (1, 1): 'New Year\'s Day',
    (7, 4): 'Independence Day',
    (12, 25): 'Christmas'
}
holidays[(1, 1)] # 'New Year\'s Day'
```

## 集合

集合是一种特殊的字典，表示一组无序的数据，数据不重复。

```python
tech_stocks = {'GOOG', 'IBM', 'CAT'}
tech_stocks = set(['GOOG', 'IBM', 'CAT'])

names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']

unique = set(names)
# unique = set(['IBM', 'AAPL','GOOG','YHOO'])

unique.add('CAT')        # Add an item
unique.remove('YHOO')    # Remove an item

s1 = { 'a', 'b', 'c'}
s2 = { 'c', 'd' }
s1 | s2                 # Set union { 'a', 'b', 'c', 'd' }
s1 & s2                 # Set intersection { 'c' }
s1 - s2                 # Set difference { 'a', 'b' }

```


Collections of python - 集合


在关系数据库中，数据通常分布在多个表中，要选择完整的数据，通常需要从多个表中选择数据。

使用`INNER JOIN`组合来自多个表的数据。

## 语法

```sql
SELECT
	pka,
	c1,
	pkb,
	c2
FROM
	A
INNER JOIN B ON pka = fka;
```

- 首先指定要选择的列
- 指定要选择的表为主表
- 指定要选择的表为从表，然后使用`INNER JOIN`连接主表和从表

对于表中的每一行`A`，`INNER JOIN`将`pka`列中的值与表中每一行的`fka`列中的值进行比较`B`：

- 如果想到，则将两个表中的相同的值连接起来添加到结果集中
- 如果没有相同的值，则忽略

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

## 示例

示例数据库
![mC6IHk](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mC6IHk.jpg)

### 使用`INNER JOIN`连接两个表

在这些表中，每当客户付款时，都会在表中插入一个新的`payment`，而客户可能有零次或多次付款。通过`customer_id`建立两个表关系。

```sql
SELECT
	customer.customer_id,
	first_name,
	last_name,
	amount,
	payment_date
FROM
	customer
INNER JOIN payment
    ON payment.customer_id = customer.customer_id
ORDER BY payment_date;
```

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

```sql
SELECT
	customer_id,
	first_name,
	last_name,
	amount,
	payment_date
FROM
	customer
INNER JOIN payment USING(customer_id)
ORDER BY payment_date;
```

### 使用`INNER JOIN`连接多个表

下图说明了三个表之间的关系：`staff`、`payment`和`customer`

- 每个员工处理 0 或多个付款，每个付款只能被一个员工处理
- 每个客户进行 0 或多次付款，每次付款只能被一个客户支付

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

```sql
SELECT
	c.customer_id,
	c.first_name customer_first_name,
	c.last_name customer_last_name,
	s.first_name staff_first_name,
	s.last_name staff_last_name,
	amount,
	payment_date
FROM
	customer c
INNER JOIN payment p
    ON p.customer_id = c.customer_id
INNER JOIN staff s
    ON p.staff_id = s.staff_id
ORDER BY payment_date;
```

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


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

Postgresql - INNER JOIN


在这篇文章中将学习给浏览器添加通知推送事件，如下视频：

<video
  src="https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/notification_qlwotx.webm"
  autoPlay
/>

## 添加通知推送

[Browser notifications](https://web.dev/push-notifications-overview/)类似于手机上的消息通知。

添加权限

```json
{
  "permissions": ["notifications"]
}
```

修改`src/App.jsx`

```jsx
export function App() {
  const createNotification = () => {
    chrome.notifications.create({
      type: 'basic',
      iconUrl: 'icons/icon-48.png',
      title: 'Hi there 👋',
      message: 'Just a reminder that you rock!',
      buttons: [{title: 'I know ☺️'}],
      priority: 0
    })
  }

  return (
    <div className="flex flex-col items-center justify-center w-screen h-auto bg-indigo-400 p-4">
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={createNotification}
      >
        Surprise me 🎉
      </button>
    </div>
  )
}
```

`chrome.notifications`创建浏览器通知

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

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension/tree/weather)


基于react、tailwindcss开发自己的chrome插件

Chrome插件开发 - Adding browser notifications


Js 中的 `assert` 模块用于测试 `Node.js` 应用程序中的功能表达式。如果测试结果返回 `false`,`assert` 将抛出一个错误并停止程序。

可以将 `assert` 模块与 `unit Js`、 `Mocha` 和 `Chai` 等单元测试工具一起使用。

开发人员使用 `assert` 来测试应用程序中的不变量。

## assert

`assert`接收两个参数：

- `condition`: 测试的条件。
- `message`: 如果条件不成立，则抛出的错误消息。

```js
var assert = require('assert')
var a = 5
var b = 3

assert(a < b)
// 抛出错误: AssertionError: a < b
```

## assert.deepStrictEqual

`assert.deepStrictEqual` 方法用于检查两个值是否相等。

deepEqual 方法用来比较两个对象。只要它们的属性一一对应，且值都相等，就认为两个对象相等，否则抛出一个错误。

```js
const assert = require('assert')
assert.deepStrictEqual({a: 1}, {a: '1'})
// 抛出错误: AssertionError: { a: 1 } deepStrictEqual { a: '1' }
```

## assert.fail

`assert.fail`接收两个参数：

- `message`: 如果条件不成立，则抛出的错误消息。
- `actual`: 实际值。

该方法共有四个参数，但是不管参数是什么值，它总是抛出一个错误。如果 message 参数对应的布尔值不为 false，抛出的错误信息就是 message，否则错误信息就是“实际值 + 分隔符 + 预期值”。

```js
const assert = require('assert').strict

/** AssertionError [ERR_ASSERTION]: Failed. This just prints failed as error message. This is not a good practice**/
assert.fail()

// AssertionError [ERR_ASSERTION]: This is why I failed
assert.fail('This is why I failed')

// TypeError: This is why I failed
assert.fail(new TypeError('This is why I failed'))
```

## assert.deepEqual

`assert.deepEqual`接收两个参数：

- `actual`: 实际值。
- `expected`: 期望值。

deepEqual 方法用来比较两个对象。只要它们的属性一一对应，且值都相等，就认为两个对象相等，否则抛出一个错误。

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

const val1 = {
  x: {
    y: 1
  }
}
const val2 = {
  x: {
    y: 2
  }
}
const val3 = {
  x: {
    y: 1
  }
}

assert.deepEqual(val1, val3)
// Returns OK since val1 is equal to val3

// Values of b are different (Child properties)
assert.deepEqual(val1, val2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
```

## assert.equal

`equal`接收两个参数：

- `actual`: 实际值。
- `expected`: 期望值。

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

assert.equal(1, 1)
// This throws no exception since 1 == 1

assert.equal(1, '1')
/** This throws no exception since with abstract equality comparison 1 == '1' **/

assert.equal(NaN, NaN)
// This throws no exception

assert.equal(1, 2)
// This throws an error, AssertionError: 1 == 2

assert.equal({a: {x: 1}}, {a: {x: 1}})
/**This throws an error AssertionError: { a: { x: 1 } } == { a: { x: 1 } } because it dosen't check child value**/
```

## assert.notEqual

`notEqual`和`notStrictEqual`效果相同

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

assert.notEqual(1, 1)
// This throws an exception since 1 == 1

assert.notEqual(1, '1')
/** This throws an exception since with abstract equality comparison 1 == '1' **/

assert.notEqual(1, 2)
// This throws no error, since 1 !== 2
```

## assert.notDeepEqual

`notDeepEqual` 方法与 `deepEqual` 方法正好相反，用来断言两个对象是否不相等。

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

const val1 = {
  x: {
    y: 1
  }
}
const val2 = {
  x: {
    y: 2
  }
}
const val3 = {
  x: {
    y: 1
  }
}

assert.notDeepEqual(val1, val3)
// Returns an error, since val1 is equal to val3

// Values of b are different (Child properties)
assert.deepEqual(val1, val2)
// Returns no error since the child properties are not equal
```

[Assert 参考](https://javascript.ruanyifeng.com/nodejs/assert.html#toc5)
[Using Assert Module](https://blog.logrocket.com/using-assert-modules-to-verify-invariants-in-nodejs/)


使用 Assert 模块验证 Node.js 中的不变量

Node.js - Assertion


Next.js 内置了 Typescript 支持。

首先，在项目根目录新建`tsconfig.json`，Next.js 会自动检测项目中的`tsconfig.json`文件，并将其解析为项目的配置。

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

接下来安装相关依赖

```bash
npm install -D typescript @types/react @types/node
```

启动服务

```bash
npm run dev
```

打开`tsconfig.json`，可以看到内容已经被`Next.js`修改

```json
{
  "compilerOptions": {
    "target": "es5",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": false,
    "forceConsistentCasingInFileNames": true,
    "noEmit": true,
    "incremental": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve"
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
  "exclude": ["node_modules"]
}
```

创建`hello.ts`

```tsx
import {NextApiRequest, NextApiResponse} from 'next'
export default (req: NextApiRequest, res: NextApiResponse) => {
  res.status(200).json({
    message: 'Hello World'
  })
}
```


Next.js - Typescript Support


## 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)
})
```
