如input、resize、scroll、intersection observer 等事件可能发生得非常频繁，例如每秒发生几次，因此调用一个动作，比如对每个事件发出读取请求，并不是一个明智的方法。

如何在 vue 中使用 Debounce、Throttle


Swift 中复杂类型包括：

- Array
- Set
- Tuple
- Dictionary
- Enums

### Array

> Swift 数组允许您存储相同类型的值，可以使用该值在数组中的位置来检索这些值。Swift 会强制检测元素类型，如果类型不同，会报错。

```swift
// 创建数组
var firstArray = ["hello","hello","world"]
var secondArray = ["swift","niubility"]

// 获取数组第一个元素
print(firstArray[0]) // hello

//添加数组
firstArray.append("manon")
firstArray+=["icu"]

// 循环数组
for item in firstArray{
	print(item) //hell hello world manon icu
}

// 修改数组元素
firstArray[0] = "swift"

// 合并数组
firstArray+secondArray

// 计算数组元素的个数
firstArray.count

// 判断数组是否为空
firstArray.isEmpty

// 删除数组元素
firstArray.remove(at: 0)
```

### Set

> 集合是用来存储类型相同且没有确定顺序的唯一的值，不允许插入已存在的值

```swift
// 创建集合
let firstSet = Set(["hello","world","manon","icu","swift"])
let secondSet = Set(["just","do","it"])

// 访问集合
for item in firstSet{
	print(item) //"hello","world","manon","icu","swift"
}

// 判断是否为空
firstSet.isEmpty // false

// 计算集合的长度
firstSet.count //5

// 判断是否包含某个元素
firstSet.contains("manon") //true

// 向集合添加元素
firstSet.insert("funny")

// 删除集合的元素
firstSet.remove("manon")

// 合并集合
firstSet.union(secondSet)
```

### Tuple

> Swift 中的 tuple 允许存储不同类型的固定数量的值。创建元组后，不能从该元组中添加或删除值。

```swift
// 创建tuple
let firstTuple = (name: "manon", level: 9000, Nationality: "china")

// 访问tuple
firstTuple.name // manon
```

### Dictionary

> Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。 Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。 Swift 字典的 key 没有类型限制可以是整型或字符串，但必须是唯一的。

```swift
// 创建字典
let firstDictionary = ["Gintama" : "Sakata Gintoki", "Haikyuu" : "Shoyo Hinata"]

// 访问字典
firstDictionary["Gintama"] // Sakata Gintoki

// 修改字典
firstDictionary.updateValue("manon",forKey:Gintama)
// 或
firstDictionary["Gintama"] = "manon"

// 删除字典元素
firstDictionary.removeValue("Gintama")

// 遍历字典
for (key,value) in firstDictionary{
	print("字典 key \(key) -  字典 value \(value)")
}

// 计算字典长度
firstDictionary.count

// 判断字典是否为空
firstDictionary.isEmpty
```

### Enums

> 根据 Swift 文档枚举的定义，它是“一组相关值的公共类型，使您能够在代码中以类型安全的方式处理这些值”。可以把它看作是一种特别用于 switch/conditions 的变量类型。

```swift
// 创建Enums
enum enumname {
   // 枚举定义放在这里
}

// 实例

import Cocoa

enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}

var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
switch weekDay{
	case .Sunday:
		print("星期天")
	case .Monday:
		print("星期一")
	case .TUESDAY:
		print("星期二")
	case .WEDNESDAY:
		print("星期三")
	case .THURSDAY:
		print("星期四")
	case .FRIDAY:
		print("星期五")
	case .Saturday:
		print("星期六")
}
```


Complex Types - 数组、字典、集合、枚举


## Promise

> 用于一个异步操作的最终完成或失败及其结果

## 状态

1. pending，初识状态
2. fulfilled，操作成功
3. rejected，操作失败

## 流程

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

## 语法

```js
new Promise((resolve, reject) => {
  /*executor*/
})
```

> Promise 执行时立即调用 executor 函数（通常是一些异步操作），resovle 将 Promise 的状态改为 fulfilled，reject 将 Promise 的状态改为 rejected，如果 catch 到了错误，将忽略 executor 内的返回值，Promise 的状态被改成 rejected

## 属性

1. Promise.length //1
2. Promise.prototype //Promise 的构造器的原型

## 方法

1. Promise.all //Promise.all 方法常被用于处理多个 promise 对象的状态集合
2. Promise.race //当 iterable 参数里的任意一个子 promise 被成功或失败后，父 promise 马上也会用子 promise 的成功返回值或失败详情作为参数调用父 promise 绑定的相应句柄，并返回该 promise 对象。
3. Promise.reject //返回一个状态为失败的 Promise 对象，并将给定的失败信息传递给对应的处理方法
4. Promise.resolve //返回的 Promise 对象状态为 fulfilled

## 原型

1. Promise.prototype.constructor //返回被创建的实例函数. 默认为 Promise 函数.
2. Promise.prototype.catch //添加一个拒绝(rejection) 回调到当前 promise, 返回一个新的 promise
3. Promise.prototype.then //添加解决(fulfillment)和拒绝(rejection)回调到当前 promise, 返回一个新的 promise, 将以回调的返回值来 resolve.
4. Promise.prototype.finally //添加一个事件处理回调于当前 promise 对象，并且在原 promise 对象解析完毕后，返回一个新的 promise 对象。回调会在当前 promise 运行完毕后被调用，无论当前 promise 的状态是完成(fulfilled)还是失败(rejected)

## 使用

```js
const P=new Promise((resolve,reject)=>{
    if(/*success*/){
        resolve()
    }else{
        reject()
    }
})
```


Promise


## 简介

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

## 应用场景

- Web 应用的自动化打包和发布。
- 自动化测试和持续集成、发布。
- 在服务型环境中部署和调整数据库或其他的后台应用。
- 从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

## 优点

- 快速，一致地交付您的应用程序
- 响应式部署和扩展
- 在同一硬件上运行更多工作负载

## 目录

- [x] [Docker 镜像](./Docker镜像)
- [x] [Docker 容器](./Docker容器)
- [x] [Dockerfiles](./Dockerfiles)
- [x] [Docker 更新容器](./Docker更新容器)
- [x] [Docker 更新镜像](./Docker更新镜像)
- [ ] [How to access files outside a Docker image]()
- [ ] [Sharing Docker Images on Docker Hub]()
- [ ] [Working with Docker Images from the command line]()
- [ ] [Working with Docker Containers from the command line]()
- [ ] [What to do if a Docker container immediately exits]()
- [ ] [Create a simple Node.js Hello World Docker Container from scratch]()
- [ ] [Using Docker Desktop to manage a Container]()
- [ ] [First steps with Docker after the installation]()
- [x] [Macos 安装 Docker](./Macos安装Docker)


Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

Docker入门


## 隐式类型转换

**布尔值**

以下值会被转换为 `false`：

- undefined, null
- false
- -0,+0,NaN
- ''

其他值都将被转换成`true`。

**字符串**

字符串的隐式类型转换是指，当一个值被赋值给一个字符串类型的变量时，会被转换成一个字符串。例如：加号（`+`）符号会被转换成字符串，因此，`1 + 2` 会被转换成 `'1+2'`。

```js
var x = '5'
x + 1 // '51'
```

**对象**

只有在需要用到数字或者字符串的时候，对象才会被转换。

当需要将对象转换成数字或者字符串时，会调用对象的 `valueOf()` 方法。具体步骤如下：

- 调用`valueOf()`方法，如果返回值是一个数字，则直接返回该数字。
- 否则，调用`toString()`方法，如果返回值是一个字符串，则直接返回该字符串。
- 否则，抛出一个 `TypeError` 异常。

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


强制类型转换


打开终端，输入以下命令：

```shell
docker run hello-world

# Unable to find image 'hello-world:latest' locally
# latest: Pulling from library/hello-world
# 0e03bdcc26d7: Pull complete 
# Digest: sha256:4cf9c47f86df71d48364001ede3a4fcd85ae80ce02ebad74156906caff5378bc
# Status: Downloaded newer image for hello-world:latest
# 
# Hello from Docker!
# This message shows that your installation appears to be working correctly.
# 
# To generate this message, Docker took the following steps:
#  1. The Docker client contacted the Docker daemon.
#  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
#     (amd64)
#  3. The Docker daemon created a new container from that image which runs the
#     executable that produces the output you are currently reading.
#  4. The Docker daemon streamed that output to the Docker client, which sent it
#     to your terminal.
#
# To try something more ambitious, you can run an Ubuntu container with:
#  $ docker run -it ubuntu bash
# 
# Share images, automate workflows, and more with a free Docker ID:
#  https://hub.docker.com/
#
# For more examples and ideas, visit:
#  https://docs.docker.com/get-started/
```

hello-world 是一个测试镜像，它会在终端输出一段文字，说明 docker 安装成功。

现在在终端输入以下命令：

```shell
docker ps -a
# CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
# 128ec8ceab71        hello-world         "/hello"            14 seconds ago      Exited (0) 13 seconds ago                      exciting_chebyshev
```

可以看到，docker 会自动创建一个容器，容器名为 exciting_chebyshev，容器 ID 为 128ec8ceab71。


Hello world in docker


```bash
npm install @next/bundle-analyzer -D
```

修改`next.config.js`

```js
const withBundleAnalyzer = require('@next/bundle-analyzer')({
  enabled: process.env.ANALYZE === 'true'
})

module.exports = withBundleAnalyzer({
  //...other config
})
```

```bash
ANALYZE=true npm run build
```

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

修改`package.json`

```json
{
  "scripts": {
    "analyze": "ANALYZE=true next build"
  }
}
```

`npm run analyze`
