Javascript - 基本引用类型


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


基于 centos 7.2

## 安装 java 环境

```bash
sudo yum install java-1.8.0-openjdk-devel
```

## 加入软件源

```bash
curl --silent --location http://pkg.jenkins-ci.org/redhat-stable/jenkins.repo | sudo tee /etc/yum.repos.d/jenkins.repo
```

## 加入软件 key

```bash
sudo rpm --import https://jenkins-ci.org/redhat/jenkins-ci.org.key
```

## 安装

```bash
sudo yum install jenkins
```

## 启动 jenkins

```bash
sudo systemctl start jenkins
```

## 检查 jenkins 状态

```bash
systemctl status jenkins
```

## 加入开机启动

```bash
sudo systemctl enable jenkins
```

## 访问

```bash
http://your_ip_or_domain:8080
```

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

```bash
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```

## 安装默认插件

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

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

## 注册用户

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

## 完成

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


安装jenkins


Swift 有三种循环：

- for
- while
- repeat

## for 循环

> 用来重复执行一系列语句直到达成特定条件，如下图：

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

```swift
// 语法
for init; condition; increment{
   // do something
}

// example
let albums = ["Red", "1989", "Reputation"]
for album in albums {
    print("\(album) is on Apple Music")
}
```

## while 循环

> while 循环从计算单一条件开始。如果条件为 true，会重复运行一系列语句，直到条件变为 false。

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

```swift
// 语法
while condition{
   // do something
}
// example
var number = 1

while number <= 20 {
    print(number)
    number += 1
}

print("Ready or not, here I come!")
```

## repeat 循环

> repeat...while 循环不像 for 和 while 循环在循环体开始执行前先判断条件语句，而是在循环执行结束时判断条件是否符合。 `repeat...while无论条件是否符合，循环会执行至少一次`

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

```swift
// 语法
repeat{
   statement(s);
}while( condition );

// example
var number = 1

repeat {
    print(number)
    number += 1
} while number <= 20

print("Ready or not, here I come!")
```

## 退出循环

使用`break`退出循环语句，比如在 while 循环中：

```swift
while countDown >= 0 {
    print(countDown)

    if countDown == 4 {
        print("I'm bored. Let's go now!")
		// 当countDown等于4的时候会退出循环
        break
    }

    countDown -= 1
}
```

## 退出多重循环

在嵌套循环中，想要同时打破内循环和外循环是很常见的。举个例子，我们可以编写一些代码来计算从 1 到 10 的乘法表，如下所示:

```swift
for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

如果需要退出这个双重循环，需要做两步，首先，给外循环加上 label:`outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

第二步，在内循环执行`break outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")

        if product == 50 {
            print("It's a bullseye!")
            break outerLoop
        }
    }
}
```

## 跳过条件 - continue

> `break`退出循环。但是，如果只想跳过当前条件，继续下一个条件，应该使用`continue`。比如如下跳过奇数：

```swift
for i in 1...10 {
    if i % 2 == 1 {
        continue
    }

    print(i)
}
```


Looping - 循环


`crypto`模块提供了加密功能，其中包括了用于 OpenSSL 散列、HMAC、加密、解密、签名、以及验证的函数的一整套封装。

几种常见的加密、解密算法：

- hash HMAC
- cipher
- decipher
- sign
- verify

## 什么是 hash

hash 是一种散列函数，用于生成一个唯一的值，用于比较两个值是否相同。

## 什么是 HMAC

HMAC 是一种基于 hash 的密钥的认证算法，它可以用于验证数据的完整性，以及防止被篡改。

```js
const {createHmac} = require('crypto')

const secret = 'abcdefg'
const hash = createHmac('sha256', secret)
  .update('I love cupcakes')
  .digest('hex')
console.log(hash)
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
```

使用`cipher`加密

```js
const crypto = require('crypto')
const cipher = crypto.createCipher('aes192', 'a password')

var encrypted = cipher.update('some clear text data', 'utf8', 'hex')
encrypted += cipher.final('hex')

console.log(encrypted)
```

使用`decipher`解密

```js
const crypto = require('crypto')
const decipher = crypto.createDecipher('aes192', 'a password')

var encrypted =
  'c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e'
var decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decipher)
```

使用`sign`签名

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})

const data = Buffer.from('I Love GeeksForGeeks')

const sign = crypto.sign('SHA256', data, privateKey)

const signature = sign.toString('base64')

console.log(`Signature:\n\n ${signature}`)
```

使用`verify`验证

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})
const algorithm = 'SHA256'

const data = Buffer.from('I Love GeeksForGeeks')

const signature = crypto.sign(algorithm, data, privateKey)

const isVerified = crypto.verify(algorithm, data, publicKey, signature)

console.log(`Is signature verified:${isVerified}`)
```


Node.js - Crypto


overflow 属性用于控制元素内容的溢出方式。当元素内容超出其指定的尺寸时，可以使用 overflow 属性来指定如何处理溢出内容。

overflow 属性有四个可能的值：

- visible（默认值）：内容超出元素尺寸时不进行剪切，可以继续显示在元素外面。这可能会导致元素之外的内容被覆盖。
- hidden：超出元素尺寸的内容将被剪切，不会被显示出来。这可以用于隐藏不想被用户看到的内容。
- scroll：超出元素尺寸的内容会被剪切，但会显示一个滚动条，用户可以使用滚动条来查看隐藏的内容。
- auto：与 scroll 值相似，超出元素尺寸的内容会被剪切，但只有在需要滚动时才会显示滚动条。

overflow 属性通常与 height 或 width 属性一起使用，以指定元素的尺寸和如何处理溢出内容。例如：

```css
div {
  width: 200px;
  height: 100px;
  overflow: scroll;
}
```

这个样式规则将创建一个宽度为 200 像素、高度为 100 像素的 div 元素，并使用 overflow: scroll 属性将超出这些尺寸的内容剪切并添加滚动条。


css - Overflow


在 Next.js 中，页面是一个 React Component，从 pages 目录导出。每个页面都基于其文件名与一个路由关联。

比如：

- `pages/index.js` 与 / 映射
- `pages/about.js` 与 /about 映射
- `pages/blog/[slug].js` 与 /blog/[slug] 映射

创建 posts 目录和 first.js

```js first.js
import Link from 'next/link'
export default function First() {
  return (
    <>
      <h1>My First Post</h1>
      <h2>
        <Link href="/">
          <a>Home</a>
        </Link>
      </h2>
    </>
  )
}
```

```js index.js
import Link from 'next/link'

function HomePage() {
  return (
    <>
      <div>Welcome to Next.js!</div>
      <Link href="/posts/first">
        <a>First Post</a>
      </Link>
    </>
  )
}

export default HomePage
```

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

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


在Next.js中，使用文件路由系统（pages）来管理页面。