Postgresql - Select


## 浏览器插件类型

通过浏览器插件可以实现一些自定义功能，比如：自定义背景、字体、浏览模式等。

在所有浏览器中，chrome 是最具扩展性，firefox、edge 等也不错。而且有些插件通用兼容 firefox 和 edge。

主题插件：[【All Chrome Themes】](https://chrome.google.com/webstore/category/themes?hl=en-GB)

新窗口插件：比如[daily.dev](https://daily.dev/) [【Some new tab extension on chrome】](https://chrome.google.com/webstore/category/collection/customize_your_new_tab_page)

弹窗插件：

- [Lighthouse](https://chrome.google.com/webstore/detail/lighthouse/blipmdconlkpinefehnmjammfjpmpbjk)
- [Developer toolbar](https://chrome.google.com/webstore/detail/web-developer/bfbameneiokkgbdmiekhjnmfkcnldhhm)
- [Metamask](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn)

以下是 Lighthouse 弹窗插件界面
![rxfcjO](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/rxfcjO.jpg)

页面注入插件

- [Redux devtools](https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd)
- [Black magic](https://chrome.google.com/webstore/detail/blackmagicso-extension/efnjehgfpbogpclnkikafpbgbahaflfd)
- [JSON viewer](https://chrome.google.com/webstore/detail/json-viewer/gbmdgpbipfallnflgajpaliibnhdgobh)

开发者工具插件

这可能是开发者接触的比较多的插件，比如：

- [React devtools](https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi)
- [Polymer devtools](https://chrome.google.com/webstore/detail/polymer-devtools-extensio/mmpfaamodhhlbadloaibpocmcomledcg)
- [Ember inspector](https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi)


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

Chrome插件开发 - 插件介绍


在本教程中，我们将使用 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)


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


**mkdir**命令用于创建目录，如果在目录名的前面没有加任何路径名，则在当前目录下创建由 dirname 指定的目录；如果给出了一个已经存在的路径，将会在该目录下创建一个指定的目录。在创建目录时，应保证新建的目录与它所在目录下的文件没有重名。

## 使用方法

```bash
#创建单个文件
mkdir folder

#创建多个文件
mkdir folder1 folder2

#使用-p参数创建文件夹，如果不存在即创建，如果不加-p，而且folder不存在，将会报错
mkdir -p folder/data
```


用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计

Linux命令mkdir


在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。

子类可以重写(override)父类的属性和方法，也可以添加新的属性和方法。子类还可以继续被其他类继承，从而形成类的层次结构。

在 Swift 中，继承可以通过在类的定义中使用冒号(:)来实现。例如：

```swift
class Animal {
var name: String = ""

    func makeSound() {
        // 产生动物叫声
    }
}

class Dog: Animal {
var breed: String = ""

    override func makeSound() {
        // 产生狗叫声
    }
}
```

在上面的示例中，我们定义了两个类 Animal 和 Dog。Dog 继承自 Animal，并添加了一个名为 breed 的属性。Dog 还重写了 Animal 的 makeSound() 方法。

通过继承，Dog 类获得了 Animal 类中的所有属性和方法。这意味着，我们可以在 Dog 类中使用 Animal 类中定义的属性和方法，而不必重复编写相同的代码。此外，通过重写 makeSound() 方法，我们可以根据需要修改 Dog 类的行为。

在 Swift 中，我们还可以使用关键字 final 来防止子类重写父类的属性或方法。例如：

```swift
class Animal {
final var name: String = ""

    final func makeSound() {
        // 产生动物叫声
    }
}

class Dog: Animal {
// 无法重写 name 或 makeSound 方法
}
```

在上面的示例中，我们使用关键字 final 来标记 name 和 makeSound() 方法，从而防止子类重写这些属性和方法。

继承是 Swift 语言中强大而灵活的功能之一。通过继承，我们可以轻松地扩展现有类的功能，从而构建出更复杂和强大的程序。同时，继承也需要谨慎使用，以避免出现代码的复杂性和耦合度过高等问题。


在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。

Swift - 继承


React components 由一组元素构成。

基本函数组件的编写方式与常规 `JavaScript` 函数类似，但有几个不同之处。

- 组件名称必须以大写字母开头（即 MyComponent，而不是 myComponent）。
- 与 `JavaScript` 函数不同，组件必须返回 JSX。

以下是 `React` 函数组件的基本语法：

```jsx
function App() {
  return <div>Hello world!</div>
}
```


React是一个JavaScript库，致力于使UI开发变得简单

React Components


`JavaScript`没有二进制数据类型，`buffer`是`Node.js`提供的专门用来存放二进制数据的缓存区。

## 创建 buffer

```js
// 创建10字节的未启动的缓存区
var buf = Buffer.alloc(10)

// 从数组创建缓存区
var buf = Buffer.from([10, 20, 30, 40, 50])

// 从字符串创建缓存区
var buf = Buffer.from('Node.js', 'utf-8')
```

## 写入 buffer

语法：`buf.write(string[, offset[, length]][, encoding])`

```js
var buf = Buffer.alloc(256)
len = buf.write('Node.js')
console.log(len) // 7
```

## 读取 buffer

语法：`buf.toString(encoding,start,end)`

- `encoding`：使用编码，默认`utf-8`
- `start`：读取初始索引位置
- `end`：读取结束位置

```js
buf = Buffer.alloc(26)
for (var i = 0; i < 26; i++) {
  buf[i] = i + 97
}

console.log(buf.toString('ascii')) // 输出: abcdefghijklmnopqrstuvwxyz
console.log(buf.toString('ascii', 0, 5)) //使用 'ascii' 编码, 并输出: abcde
console.log(buf.toString('utf8', 0, 5)) // 使用 'utf8' 编码, 并输出: abcde
console.log(buf.toString(undefined, 0, 5)) // 使用默认的 'utf8' 编码, 并输出: abcde
```

## 将 buffer 转换为 json 对象

语法：`buf.toJson`

```js
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json)

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ? Buffer.from(value.data) : value
})

// 输出: <Buffer 01 02 03 04 05>
console.log(copy)
```

## buffer 合并

语法：`Buffer.contact(list,totalLength)`

- `list`：用于合并的`Buffer`对象数组列表
- `totalLength`：合并后`Buffer`对象的总长度

```js
var buf1 = Buffer.from('Hello')
var buf2 = Buffer.from(' World!')
var buf3 = Buffer.concat([buf1, buf2])

console.log(buf3) //<Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64 21>
```

## buffer 比较

语法：`buf.compare(..)`

返回数字，0 表示相同，小于 0 表示 buf 在 bufToCompare 之前，大于 0 则相反

```js
var buf = Buffer.from('Hello')
var bufToCompare = Buffer.from('hello')

var result = buf.compare(bufToCompare)
console.log(result) // -1
```

## buffer 拷贝

语法：`buf.copy(target,targetStart,sourceStart,sourceEnd)`

- `target`：要拷贝的`Buffer`对象
- `targetStart`：默认 0
- `sourceStart`：默认 0
- `sourceEnd`：默认 0

```js
var buf = Buffer.from('Hello')
var bufToCopy = Buffer.from('World')

bufToCopy.copy(buf, 2)
console.log(buf.toString()) //HeWor
```

## buffer 切片

语法：`buf.slice(start,end)`

- `start`：切片初始位置，默认 0
- `end`：切片结束位置，默认为`buffer.length`

```js
var buf = Buffer.from('Hello World')
var result = buf.slice(0, 5)
console.log(result.toString()) //Hello
```

[入门教程](http://nodejs.cn/learn/nodejs-buffers)
[Node.js 文档](http://nodejs.cn/api/buffer.html)


buffer是Node.js提供用来存放二进制数据的缓存区