内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift - 内存安全


Swift 中的错误处理是一种机制，用于在程序执行期间检测和处理错误。错误是指在程序执行期间发生的意外事件，例如网络连接中断、文件未找到等等。Swift 使用 try，catch 和 throw 语句来支持错误处理。

当一个函数可能会抛出错误时，需要在函数的定义中使用 throws 关键字来表示这一点。这告诉调用者，调用该函数可能会导致一个错误，并且必须用 try 语句调用该函数。

## 抛出错误

在 Swift 中，抛出错误使用 throw 关键字。如果一个函数、方法或初始化器可能出现错误，需要在声明中使用 throws 关键字来标识。例如：

```swift
enum MyError: Error {
  case invalidValue
}

func divide(_ x: Int, by y: Int) throws -> Int {
  if y == 0 {
    throw MyError.invalidValue
  }
  return x / y
}
```

在上述示例中，divide(\_:by:) 函数可能会抛出一个 MyError.invalidValue 类型的错误。

## 处理错误

当一个函数、方法或初始化器可能抛出错误时，调用者必须使用 try 关键字来调用该函数，否则会编译错误。例如：

```swift
do {
let result = try divide(10, by: 2)
  print(result)
} catch {
  print(error)
}
```

在上述示例中，使用 try 关键字调用了 divide(\_:by:) 函数，并使用 do-catch 语句捕获可能抛出的错误。如果函数调用成功，result 的值将被打印，否则将打印错误信息。

当调用一个可能抛出错误的函数时，可以使用多种方式来处理错误。例如，可以使用 do-catch 语句捕获错误、使用 try? 关键字将错误转换为可选值，或使用 try! 关键字表示该函数不会抛出错误。例如：

```swift
// 使用 try? 关键字将错误转换为可选值
let result1 = try? divide(10, by: 0)
print(result1)

// 使用 try! 关键字表示该函数不会抛出错误
let result2 = try! divide(10, by: 2)
print(result2)
```

在上述示例中，try? 关键字将错误转换为可选值，如果函数调用成功，则返回结果，否则返回 nil。try! 关键字表示该函数不会抛出错误，如果函数调用失败，程序将崩溃。

自定义错误类型
在 Swift 中，可以自定义错误类型来表示具体的错误信息。自定义的错误类型需要实现 Error 协议。例如：

```swift
enum MyError: Error {
  case invalidValue
  case networkError(String)
  case fileError(String, Int)
}
```

在上述示例中，定义了一个 MyError 类型，包含了三种错误情况：invalidValue 表示无效的数值，networkError 表示网络错误，fileError 表示文件错误，并且每种错误情况都包含了不同的错误信息。

例如，以下是一个可能会抛出错误的函数：

```swift
Copy code
func divide(_ dividend: Int, by divisor: Int) throws -> Int {
guard divisor != 0 else {
throw NSError(domain: "com.example", code: 0, userInfo: [
NSLocalizedDescriptionKey: "Cannot divide by zero"
])
}

    return dividend / divisor
}
```

在这个函数中，如果除数为零，就会抛出一个错误。我们可以使用 do 和 catch 语句来捕获和处理错误：

```swift
do {
  let result = try divide(10, by: 2)
  print(result) // Output: 5
} catch {
  print("Error: \(error)") // Output: Error: Cannot divide by zero
}
```

在上面的代码中，我们将 divide 函数的返回值存储在 result 变量中。如果 divide 函数抛出一个错误，那么程序将跳转到 catch 块，并打印错误信息。

除了使用 do 和 catch 语句来处理错误之外，还可以使用 try?和 try!语句来简化错误处理过程。try?语句将函数的返回值转换为一个可选类型，如果函数抛出错误，则返回 nil。try!语句则在函数抛出错误时直接崩溃程序。建议使用 try?和 try!语句的场景非常有限，因为它们会让程序在运行时变得不可预测。例如，以下是一个可能会抛出错误的函数：

```swift
func divide(_ dividend: Int, by divisor: Int) throws -> Int {
  guard divisor != 0 else {
    throw NSError(domain: "com.example", code: 0, userInfo: [
    NSLocalizedDescriptionKey: "Cannot divide by zero"
  ])
}

    return dividend / divisor
}
```

在这个函数中，如果除数为零，就会抛出一个错误。我们可以使用 do 和 catch 语句来捕获和处理错误：

```swift
do {
  let result = try divide(10, by: 2)
  print(result) // Output: 5
} catch {
  print("Error: \(error)") // Output: Error: Cannot divide by zero
}
```

在上面的代码中，我们将 divide 函数的返回值存储在 result 变量中。如果 divide 函数抛出一个错误，那么程序将跳转到 catch 块，并打印错误信息。

除了使用 do 和 catch 语句来处理错误之外，还可以使用 try?和 try!语句来简化错误处理过程。try?语句将函数的返回值转换为一个可选类型，如果函数抛出错误，则返回 nil。try!语句则在函数抛出错误时直接崩溃程序。建议使用 try?和 try!语句的场景非常有限，因为它们会让程序在运行时变得不可预测。


错误处理是一种处理程序运行过程中可能出现错误的机制。

Swift - 错误处理


## cli

`Next.js`提供了一个简单的命令行工具，可以帮助我们快速部署和管理应用。

```bash
npx next -h

#设置端口
npx next dev -p 4000 #开发模式
PORT=4000 npx next dev #开发模式

npx next start -p 4000 #生产模式
PORT=4000 next start #生产模式

next lint #检查代码规范

next build #构建静态资源
next export #导出静态资源
```

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

```bash
➜  demo npm run build

> demo@1.0.0 build
> next build

info  - Checking validity of types
warn  - No ESLint configuration detected. Run next lint to begin setup
info  - Creating an optimized production build
info  - Compiled successfully
info  - Collecting page data
info  - Generating static pages (3/3)
info  - Finalizing page optimization

Page                                       Size     First Load JS
┌ λ /                                      470 B          75.4 kB
├   /_app                                  0 B            74.9 kB
├ ○ /404                                   193 B          75.1 kB
├ λ /api                                   0 B            74.9 kB
└ ○ /posts/first                           2.75 kB        77.7 kB
    └ css/9871d7e98c5c71df.css             103 B
+ First Load JS shared by all              74.9 kB
  ├ chunks/framework-a87821de553db91d.js   45 kB
  ├ chunks/main-d8b1ff545a609496.js        28.6 kB
  ├ chunks/pages/_app-05a4472bc3e8727e.js  507 B
  ├ chunks/webpack-69bfa6990bb9e155.js     769 B
  └ css/5d2c4ba91281dd0f.css               175 B

λ  (Server)  server-side renders at runtime (uses getInitialProps or getServerSideProps)
○  (Static)  automatically rendered as static HTML (uses no initial props)
```

## deployment

通过`next build`构建静态资源，然后通过`next export`导出静态资源。

- `.next/static/chunks/pages`–此文件夹中的每个 JavaScript 文件都与具有相同名称的路由相关联。例如，.next/static/chunks/pages/about.js 将是在应用程序中查看/about 路由时加载的 JavaScript 文件
- `.next/static/media`–从 next/image 静态导入的图像在这里散列和复制
- `.next/static/css`–应用程序中所有页面的全局 CSS 文件
- `.next/server/pages`–从服务器预呈现的 HTML 和 JavaScript 入口点`.nft.json` 文件在启用输出文件跟踪时创建，并包含依赖于给定页面的所有文件路径。
- `.next/server/chunks`– 在整个应用程序的多个地方使用的共享 JavaScript 块
- `.next/cache`–从 Next.js 服务器输出构建缓存和缓存的图像、响应和页面。使用缓存有助于减少构建时间并提高加载图像的性能

部署方式

- Vercel
- netlify
- github pages
- firebase
- self-hosted
- node.js server
- docker

## SSG vs SSR

[SSG vs SSR](https://blog.logrocket.com/ssg-vs-ssr-in-next-js/)


Next.js - CLI & Deployment


## 函数的定义

函数的定义是一个特殊的可复用的代码块，它的第一行必须是函数的声明，第二行开始是函数的实现。

```python
#定义函数
def sumcount(n):
    '''
    Returns the sum of the first n integers
    '''
    total = 0
    while n > 0:
        total += n
        n -= 1
    return total
#调用函数
a = sumcount(100)
```

## 标准函数

python 中的标准函数是一些内置的函数，通过`import`调用。

```python
import math
x = math.sqrt(10)

import urllib.request
u = urllib.request.urlopen('http://www.python.org/')
data = u.read()
```

## 错误和异常

错误和异常是 python 中的两个主要概念，错误是指程序运行过程中发生的错误，异常是指程序运行过程中抛出的异常。例如：

```python
>>> int('N/A')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'N/A'
>>>
```

## 捕获、处理异常

异常可以通过`try`和`except`来捕获，也可以通过`try`和`finally`来处理。

```python
for line in f:
    fields = line.split()
    try:
        shares = int(fields[1])
    except ValueError:
        print("Couldn't parse", line)
    ...
```


随着程序的不断更新，我们会发现，函数的定义和调用是一致的。

Functions - 函数


## 变量

变量是一种使用方便的占位符，用于引用计算机内存地址。

swift 每个变量指定了特定的类型，类型决定变量占用内存的大小，也决定可存储值的范围。

变量名可以由字母、数字和下划线组成，以字母或下划线开始，且区分大小写。

变量名也可以使用简单的 Unicode 字符

变量和常量可以使用 print 函数输出，在字符串中可以使用括号与反斜线插入变量

```swift
// 变量声明
var variableName = <initial value>

//实例
import Cocoa

var a = 42
print(a) //输出42

var b:float
b = 3.1415926
print(b) //输出3.1415926

var _var = "hello swift"
var 你好 = "世界"
print(_var) // hello swift
print(你好) //世界

var name = "manon"

print("\(name)") //manon
```

标准 Swift 字符串使用双引号，但不能包含换行符，如果您想要多行字符串，使用三个双引号开始和结束，如下所示：

```swift
var str1 = """
This goes
over multiple
lines
"""
print(str1) // "This goes\nover multiple\nlines"
```

如果不希望显示`\`，应该如下写：

```swift
var str2 = """
This goes \
over multiple \
lines
"""
print(str2) //"This goes nover multiple nlines"
```

## 浮点和布尔值

Swift 中的另外两种基本数据类型是双精度和布尔值。

```swift
var pi = 3.141
var awesome = true
```

## 字符串插值

> 将变量放置在字符串中

```swift
var score = 85
var str = "Your score was \(score)"

var results = "The test results are here: \(str)"
```

## 常量

> 常量一旦赋值，不能再次赋值，否则会报错。

```swift
//声明
let _const = <initial value>
let _const:Float = 3.1415926

// 命名
和变量命名相同
// 输出
和变量命名相同
```

## 类型声明

在创建变量或常量的时候可以声明数据类型，如果没有，swift 将推导其数据类型，如下：

```swift
let str = "Hello, playground" //swift推导str为String

// 主动声明类型
let album: String = "Reputation"
let year: Int = 1989
let height: Double = 1.78
let taylorRocks: Bool = true
```

## 扩展

字符串是一系列字符的集合，比如`hello world`，它的数据类型为 String

```swift
import Cocoa
//创建字符串
var str1 = "hello world"
print(str1)

//空字符串
var str2 = ""
var str3 = " manon"
if str2.isEmpty() {
	print("str2 是空字符串")
}else{
	print("str2 不是空字符串")
}

// 连接字符串

var str4 = str1 + str3
print(str4) //"hello world manon"
print('str1和str3连接：\(str4)')

// 字符串长度
print(str4.count)

// 字符串比较
if str1==str2{
	print("\(str1) 与 \(str2)是相等的")
}else{
	print("\(str1) 与 \(str2)是不相等的")
}
```

字符串函数及运算符

- `isEmpty` 判断字符串是否为空，返回布尔值
- `hasPrefix` 检查字符串是否有特定的前缀
- `hasSuffix` 检查字符串是否有特定的后缀
- `Int` 转换字符串数字为整型
- `count` 计算字符串的长度
- `utf8、utf16` 遍历 String 的 utf8 属性访问 utf8、utf16 编码
- `unicodeScalars` 遍历 String 的 unicodeScalars 属性访问 Unicode 标量编码
- `+、+=、==、<、！=` 字符串操作符


swift 提供的数据类型包括：整形 Int、浮点数 Double 和 Float、布尔类型 Bool 以及字符串类型 String、Optional、Array、Dictionary、Struct、Class 等。

Simple Types - 变量、基本数据类型、字符串插值


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


JavaScript 中的 null 值表示没有值或空引用。它是语言中的基本值之一，其他基本值还有 undefined、true 和 false。

你可以这样将 null 值赋给变量：

```js
let x = null
```

null 经常用来表示对象值的缺失。例如，你可以使用 null 来表示函数的结果缺失：

```js
function getUser(id) {
  let user = database.get(id)
  if (!user) {
    return null
  }
  return user
}

let user = getUser(123)
if (user === null) {
  console.log('用户未找到')
} else {
  console.log(user.name)
}
```

在上面的例子中，如果在数据库中未找到用户，函数 getUser() 将返回 null。

请注意，null 与 undefined 不同，undefined 表示没有值。在 JavaScript 中，未初始化的变量的默认值是 undefined，而 null 是可以赋值给变量的值。

你还可以使用 null 值将对象重置为初始状态：

```js
let obj = {a: 1, b: 2}
obj = null // obj 现在为 null
```

最后，你可以使用 typeof 运算符来检查一个值是否为 null。typeof 运算符对于 null 值会返回字符串 "object"：

```js
console.log(typeof null) // "object"
```

但是，这种行为被视为语言中的 bug，不会改变。建议只在对象值的上下文中使用 null
