Go - 简介


在这篇文章，我们将把我们已经非常出色的弹出式浏览器扩展变得更加个性化。

为了维护用户选择的内容，我们将利用 chrome 的存储能力。

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

## 增加浏览器扩展存储权限

修改`manifest.json`，在权限数组新增`storage`

```json
{
  "permissions": ["alarms", "notifications", "storage"]
}
```

编写扩展主体

```jsx
import {useState} from 'react'

const colorMatch = {
  indigo: 'bg-indigo-400',
  pink: 'bg-pink-400',
  purple: 'bg-purple-400'
}

export function App() {
  const [color, setColor] = useState('indigo')

  const createNotification = () => {
    chrome.alarms.create('motivation_alarm', {
      periodInMinutes: 60
    })
    window.close()
  }

  const stopNotification = () => {
    chrome.alarms.clearAll()
    window.close()
  }

  chrome.storage.sync.get('color', (storedColor) => {
    setColor(storedColor.color)
  })

  const pickColor = (pickedValue) => {
    setColor(pickedValue)
    chrome.storage.sync.set({color: pickedValue})
  }

  return (
    <div
      className={`flex flex-col items-center justify-center w-screen h-auto ${colorMatch[color]} p-4`}
    >
      <select
        onChange={(event) => pickColor(event.target.value)}
        value={color}
        className="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-indigo-500 focus:border-indigo-500 block w-full p-2.5 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-indigo-500 dark:focus:border-indigo-500"
      >
        <option>Pick a color</option>
        <option value="indigo">Indigo</option>
        <option value="pink">Pink</option>
        <option value="purple">Purple</option>
      </select>
      <br />
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={createNotification}
      >
        Motivate me 🎉
      </button>
      <br />
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={stopNotification}
      >
        Stop motivating me 😅
      </button>
    </div>
  )
}
```

## Source Code

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


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

Chrome插件开发 - Using storage


> Dockerfile 是一个包含用于组合映像的命令的文本文档。可以使用在命令行中调用任何命令。 Docker 通过读取 Dockerfile 中的指令自动生成映像。 docker build 命令用于从 Dockerfile 构建映像。可以在 docker build 命令中使用-f 标志指向文件系统中任何位置的 Dockerfile。

## 文件说明

Docker 从上到下的顺序运行 Dockerfile 的指令，第一条指令必须是 FROM。

1. FROM

用于设置基本映像，FROM 必须作为第一条指令

2. MAINTAINER

docker 镜像和指令的创建者

3. CMD

用于执行映像的应用程序

```dockerfile
CMD ["executable","param1","param2"]
```

4. RUN

用于执行当前映像的任何命令

```dockerfile
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME"
```

5. LABEL

用于添加标签，设置映像标签

```dockerfile
LABEL maintainer="manon.icu"
```

6. EXPOSE

用于暴露端口到网络

```bash
#暴露80端口

expose 80

expose 80/tcp
```

7. ENV

设置环境变量

```bash
FROM node:12

ENV workdirectory /usr/node
```

8. COPY/ADD

用于将源文件复制到目的地

```dockerfile
COPY dist /www/dist
```

9. ENTRYPOINT

docker 镜像启动后的第一条执行命令

```bash
FROM ubuntu:latest

ENTRYPOINT ["ls"]
```

10. VOLUME

挂载卷

```bash
FROM node:12
RUN mkdir /node
WORKDIR /node
RUN echo "Welcome to Node.js" > node
VOLUME /node
```

12. USER

设置运行容器的账户

```bash
USER admin
#
RUN adduser -D admin
USER admin
```

13. WORKDIR

用于为 RUN/CMD/COPY 指令设置工作目录，如不存在，会默认创建

14. ARG

用于在创建时接收的参数

```bash
ARG JAVA_PATH=/opt/jdk/jdk1.8.0_251

ENV JAVA_HOME ${JAVA_PATH}
```

15. ONBUILD

用于指定将 `Dockerfile` 中的镜像用作另一个镜像的基础镜像时运行的命令

```bash
FROM node:12
RUN mkdir -p /usr/node/app
WORKDIR /usr/node/app
ONBUILD COPY package.json /usr/node/app/
ONBUILD RUN npm install
ONBUILD COPY . /usr/node/app
CMD [ "npm", "start" ]
```

16. STOPSIGNAL

```bash
STOPSIGNAL SIGQUIT
```

17. SHELL

设置 docker 镜像默认的终端

```bash
SHELL ["/bin/bash","-c","echo hello"]
```

18. HEALTHCHECK

检查镜像是否健康运行，需要在镜像内部持续运行一段命令

```bash
FROM ubuntu:latest
HEALTHCHECK --interval=60s --timeout=5s \
CMD curl -f http://fosstechnix.info/ || exit 1
EXPOSE 80
```

19. .dockerignore

用于设置 docker 镜像构建过程中忽略的文件

```bash
sudo vim .dockerignore

*.yaml
__pycache__/
.git
.aws
.env
```

## 完整的 Dockerfile

```dockerfile
FROM node:lts-alpine

WORKDIR /app
ADD . /app
RUN npm install

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

## 更多


Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明

Dockerfile


## 运行 python

> Python 程序总是在解释器中运行。解释器是一个“基于控制台的”应用程序，通常使用命令运行。

```python
python3
Python 3.9.8 (main, Nov 10 2021, 03:55:42)
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

## 交互模式

当在终端运行`python3`后，就进入了交互模式，即 REPL。

- `>>>`表示开始新的语句
- `...`表示继续上一条语句
- `_`表示最后的返回值

```python
>>> print('hello world')
hello world
>>> 37*42
1554
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>
```

## 创建程序

> python 程序以`.py`结尾，可以直接运行。

```python
# hello.py
print('hello world')
```

## 运行程序

> python 程序运行的命令是`python hello.py`

```python
$ python hello.py
$ python3 hello.py
```

## 样例程序

> 问题：一天早上，你出去，在芝加哥西尔斯大厦旁的人行道上放了一张美元钞票。从那以后，你每天出去的账单都会翻倍。这堆钞票超过塔的高度需要多长时间？

解决方法：

```python
# sears.py
bill_thickness = 0.11 * 0.001 # Meters (0.11 mm)
sears_height = 442 # Height (meters)
num_bills = 1
day = 1

while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
print('Number of bills', num_bills)
print('Final height', num_bills * bill_thickness)
```

```bash
bash % python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
...
21 1048576 115.34336
22 2097152 230.68672
Number of days 23
Number of bills 4194304
Final height 461.37344
```

### 语句

> 每行语句以换行符结束，但是不能以分号结束。

```python
a = 3 + 4
b = a * 2
print(b)
```

### 注释 comment

> 注释以#开始，不会被运行。

```python
a = 3 + 4
# This is a comment
b = a * 2
print(b)
```

### 类型与变量 type&variable

> python 属于动态类型语言，变量可以随时变化。python 变量名称可以包含字母、数字、下划线，但不能以数字或关键字开头。对大小写敏感。

```python
height = 442           # An integer
height = 442.0         # Floating point
height = 'Really tall' # A string

# 大小写敏感
name = 'Jake'
Name = 'Elwood'
NAME = 'Guido'

while x < 0:   # OK
WHILE x < 0:   # ERROR
```

### 循环 for/while

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

### 缩进 indentation

> 缩进是用来表示一组连在一起的语句:

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

- 使用空格代替 tab 来缩进
- 使用 4 个空格来缩进

### 条件语句 if-else

```python
if a > b:
    print('Computer says no')
elif a == b:
    print('Computer says yes')
else:
    print('Computer says maybe')
```

### 输出语句 print

```python
print('Hello world!') # Prints the text 'Hello world!'

#用户输出
name = input('Enter your name:')
print('Your name is', name)
```


First Program - 第一个程序


使用`BETWEEN`运算符将一个值与一系列值进行匹配

## 语法

```sql
value BETWEEN low AND high
```

如果`value`在`low`和`high`之间，则返回`TRUE`，否则返回`FALSE`。

`BETWEEN`可以使用大于等于和小于等于运算符，但是不能使用`LIKE`运算符。

```sql
value >= low and value <= high
```

检查是否超出范围，可以使用`NOT`和`BETWEEN`组合运算符。

```sql
value NOT BETWEEN low AND high
```

等价于

```sql
value < low OR value > high
```

## 示例

使用`BETWEEN`查询金额是否在 8 和 9 之间。

```sql
SELECT
	customer_id,
	payment_id,
	amount
FROM
	payment
WHERE
	amount BETWEEN 8 AND 9;
```

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

查询金额不在 8 和 9 之间。

```sql
SELECT
	customer_id,
	payment_id,
	amount
FROM
	payment
WHERE
	amount NOT BETWEEN 8 AND 9;
```

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


使用 Postgresql BETWEEN 检索查询是否处于列表区间。

Postgresql - BETWEEN


## 什么是闭包

作用：能够在函数定义的作用域外，使用函数定义作用域内的局部变量，并且不会污染全局。

原理：基于词法作用域链和垃圾回收机制，通过维持函数作用域的引用，让函数作用域可以在当前作用域外被访问到

```js
function foo() {
  var a = 'hzfe'
  function bar() {
    console.log(a)
  }
  return bar
}

var baz = foo()
baz() // hzfe
```

在这个例子中，函数 bar 作为返回值返回后，在自己定义的词法作用域以外的地方执行。一般来说，在函数 foo 执行后，通常会期待函数 foo 的整个内部作用域被引擎回收机制销毁。而闭包可以阻止这件事情的发生。事实上内部作用域依然存在，因为函数 bar 本身在使用，所以并不会被回收。

在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

## 闭包的应用

无论何时何地，如果将函数作为返回值，就会看到闭包在这些函数中的应用。在定时器，事件监听器，ajax 请求，跨窗口通信，web workers 或者任何其他的异步/同步任务中，只要使用了回调函数，实际上就是使用闭包。使用闭包的例子可以参考实现节流防抖函数。

```js
var a = 'hzfe'
;(function IIFE() {
  console.log(a)
})()
```

通常认为立即执行函数（IIFE）是典型的观察闭包的典型例子，但严格来说并不是。虽然创建了闭包，但没有体现出闭包的作用。因为函数并不是在它本身的词法作用域以外执行的。 它在定义时所在的作用域中执行，而非外部作用域。

## 扩展

- [闭包 MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Closures)
- [垃圾回收机制](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Errors/Closed_Overlay_Requires_Arguments)
- [你不知道的 JavaScript](https://www.imooc.com/article/2907)


闭包


在本教程中，我们将使用 Nodejs、 Express、 Postgres 和 Docker 在 JavaScript 中构建 CRUD Rest API。

## 介绍

下面是我们将要创建的应用程序架构的模式:

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

5 个基本 CURD 基本操作

- Create
- Read all
- Read one
- Update
- Delete

将使用以下技术、框架创建应用程序:

- Express
- Sequelize
- Docker
- Postgres
- Docker compose
- Postman

## 项目结构

```bash
mkdir node-curd-api
cd node-curd-api
npm init -y
npm i express sequelize pg
mkdir controllers routes util models
code .
```

项目结构图如下：

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

## 创建、连接数据库

首先在 util 文件夹下新建 database.js 文件，用于连接数据库。这个文件将包含允许 Node.js 应用程序和运行的 Postgres 实例之间连接的内部配置。

```js
const Sequelize = require('sequelize')
const sequelize = new Sequelize(
  process.env.PG_DB,
  process.env.PG_USER,
  process.env.PG_PASSWORD,
  {
    host: process.env.PG_HOST,
    dialect: 'postgres'
  }
)
module.exports = sequelize
```

## 创建模型

在 models 文件夹下新建 user.js 文件，用于创建模型。这个文件将包含模型，在本例中是一个具有自动递增 id、name 和 email 的用户。

```js
const Sequelize = require('sequelize')
const db = require('../util/database')

const User = db.define('user', {
  id: {
    type: Sequelize.INTEGER,
    autoIncrement: true,
    allowNull: false,
    primaryKey: true
  },
  name: Sequelize.STRING,
  email: Sequelize.STRING
})
module.exports = User
```

## 创建控制器

在 controllers 文件夹下新建 user.js 文件，用于创建控制器。这个文件将包含控制器，用于处理请求。

```js
const User = require('../models/user')

// CRUD Controllers

//get all users
exports.getUsers = (req, res, next) => {
  User.findAll()
    .then((users) => {
      res.status(200).json({users: users})
    })
    .catch((err) => console.log(err))
}

//get user by id
exports.getUser = (req, res, next) => {
  const userId = req.params.userId
  User.findByPk(userId)
    .then((user) => {
      if (!user) {
        return res.status(404).json({message: 'User not found!'})
      }
      res.status(200).json({user: user})
    })
    .catch((err) => console.log(err))
}

//create user
exports.createUser = (req, res, next) => {
  const name = req.body.name
  const email = req.body.email
  User.create({
    name: name,
    email: email
  })
    .then((result) => {
      console.log('Created User')
      res.status(201).json({
        message: 'User created successfully!',
        user: result
      })
    })
    .catch((err) => {
      console.log(err)
    })
}

//update user
exports.updateUser = (req, res, next) => {
  const userId = req.params.userId
  const updatedName = req.body.name
  const updatedEmail = req.body.email
  User.findByPk(userId)
    .then((user) => {
      if (!user) {
        return res.status(404).json({message: 'User not found!'})
      }
      user.name = updatedName
      user.email = updatedEmail
      return user.save()
    })
    .then((result) => {
      res.status(200).json({message: 'User updated!', user: result})
    })
    .catch((err) => console.log(err))
}

//delete user
exports.deleteUser = (req, res, next) => {
  const userId = req.params.userId
  User.findByPk(userId)
    .then((user) => {
      if (!user) {
        return res.status(404).json({message: 'User not found!'})
      }
      return User.destroy({
        where: {
          id: userId
        }
      })
    })
    .then((result) => {
      res.status(200).json({message: 'User deleted!'})
    })
    .catch((err) => console.log(err))
}
```

## 创建路由

在 routes 文件夹下新建 user.js 文件，用于创建路由。这个文件将包含路由，用于处理请求。

```js
const controller = require('../controllers/users')
const router = require('express').Router()

// CRUD Routes /users
router.get('/', controller.getUsers) // /users
router.get('/:userId', controller.getUser) // /users/:userId
router.post('/', controller.createUser) // /users
router.put('/:userId', controller.updateUser) // /users/:userId
router.delete('/:userId', controller.deleteUser) // /users/:userId

module.exports = router
```

## 创建应用

在根目录下新建 index.js 文件，用于创建应用。这个文件将包含应用的主要配置。

```js
const express = require('express')
const bodyparser = require('body-parser')
const sequelize = require('./util/database')
const User = require('./models/user')

const app = express()

app.use(bodyparser.json())
app.use(bodyparser.urlencoded({extended: false}))

app.use((req, res, next) => {
  res.setHeader('Access-Control-Allow-Origin', '*')
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE')
  next()
})

//test route
app.get('/', (req, res, next) => {
  res.send('Hello World')
})

//CRUD routes
app.use('/users', require('./routes/users'))

//error handling
app.use((error, req, res, next) => {
  console.log(error)
  const status = error.statusCode || 500
  const message = error.message
  res.status(status).json({message: message})
})

//sync database
sequelize
  .sync()
  .then((result) => {
    console.log('Database connected')
    app.listen(3000)
  })
  .catch((err) => console.log(err))
```

## Docker 不分

在根目录下新建 Dockerfile、.dockerignore、docker-compoese.yml 文件，用于创建 Docker 镜像。

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

.dockerignore 文件写入以下内容

```
node_modules
```

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

Dockerfile 文件写入以下内容

```dockerfile
FROM node:14

# Create app directory
WORKDIR /app

COPY package*.json ./

RUN npm install

# Bundle app source
COPY . .

EXPOSE 3000

CMD [ "node", "index.js" ]
```

docker-compose.yaml，用于启动多容器服务

```yaml
version: '3.9'

services:
  node_app:
    container_name: node_app
    build: .
    image: francescoxx/node_live_app
    ports:
      - '3000:3000'
    environment:
      - PG_DB=node_live_db
      - PG_USER=francesco
      - PG_PASSWORD=12345
      - PG_HOST=node_db
    depends_on:
      - node_db

  node_db:
    container_name: node_db
    image: postgres:12
    ports:
      - '5432:5432'
    environment:
      - POSTGRES_DB=node_live_db
      - POSTGRES_USER=francesco
      - POSTGRES_PASSWORD=12345
    volumes:
      - node_db_data:/var/lib/postgresql/data

volumes:
  node_db_data: {}
```

## 打包镜像、运行服务

在根目录下打开终端，运行以下命令

```bash
docker-compose up --build node_db
```

查询日志：

```bash
docker-compose logs -f node_db
```

得到以下内容，如输出***database system is ready to accept connections***，表示数据库已经启动成功。

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

使用 TablePlus 连接数据库，创建数据库表，点击+按钮新建连接

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

从 docker-compose.yml 文件中获取数据库连接信息

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

打包镜像

```bash
docker compse build
```

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

运行镜像

```bash
docker compose up node_app
```

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

## 使用 Postman 测试

创建 GET 请求

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

请求 ***http://localhost:3000/users***

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

创建三个用户 aaa、bbb、ccc

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

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

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

再次请求 ***http://localhost:3000/users***，得到以下结果

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

请求单个用户 ***http://localhost:3000/users/2***

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

修改已存在的用户 ***http://localhost:3000/users/2***

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

删除已存在的用户 ***http://localhost:3000/users/3***

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

操作完成后同样可以在 TablePlus 中查看数据库表

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

## 总结

本文介绍了如何使用 Docker Compose 配置多容器服务，以及如何使用 Postman 测试 Node.js 服务。

源码地址：[https://github.com/FrancescoXX/crud-node-live](https://github.com/FrancescoXX/crud-node-live)
