Linux命令ping


浅路由是在同一个路由中跳转，不会调用数据获取函数，比如：`getServerSideProps`、`getStaticProps`等。

启用浅路由的方式，在路由跳转中设置`shallow`为`true`

```jsx
import Router from 'next/router'
import Head from 'next/head'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <span
        onClick={() => Router.push('/?counter=1', undefined, {shallow: true})}
      >
        Reload
      </span>
      <br />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="Logo" />
    </>
  )
}

export async function getServerSideProps(context) {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}

export default HomePage
```

上面的代码仅接收路由的参数更新，且不会被替换。


浅路由是在同一个路由中跳转，不会调用数据获取函数。

Next.js - Shallow Routing


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

## 前置条件

- Centos 8/Ubuntu 18.04/Debain 10
- 域名 xxx.com
- 域名解析到对应服务器

## Centos 8 安装 Certbot

### 加入 EPEL 软件源

```bash
sudo yum install epel-release
sudo yum -y update
```

### 下载并安装特定于 Certbot 和 web 服务器的包

```bash
sudo curl -O https://dl.eff.org/certbot-auto
sudo mv certbot-auto /usr/local/bin/certbot-auto
chmod 0755 /usr/local/bin/certbot-auto
```

### 启动 Certbot

```bash
sudo /usr/local/bin/certbot-auto --nginx
```

### 启动 jenkins

```bash
sudo systemctl start jenkins
```

### 询问信息如下

```bash

# sudo /usr/local/bin/certbot-auto --nginx
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator nginx, Installer nginx
No names were found in your configuration files. Please enter in your domain
name(s) (comma and/or space separated)  (Enter 'c' to cancel): www.example.com
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for www.example.com
Waiting for verification...
Cleaning up challenges
Deploying Certificate to VirtualHost /etc/nginx/nginx.conf

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Redirecting all traffic on port 80 to ssl in /etc/nginx/nginx.conf

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
```

### 开启防火墙

```bash
sudo firewall-cmd --zone=public --permanent --add-service=https
sudo firewall-cmd --reload
```

## Ubuntu 18.04 安装 Certbot

### 安装 Certbot 和 web 服务器

```bash
sudo apt-get update
sudo add-apt-repository ppa:certbot/certbot
sudo apt-get install python-certbot-nginx
sudo certbot --nginx
```

### 开启防火墙

```bash
sudo systemctl start ufw && sudo systemctl enable ufw
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
```

## Debain 10 安装 Certbot

### 安装 Certbot 和 web 服务器

```bash
sudo apt install certbot python-certbot-nginx
sudo certbot --nginx
```

### 询问信息

```bash
# sudo certbot --nginx
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator nginx, Installer nginx
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): admin@example.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(A)gree/(C)ancel: A

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: N
No names were found in your configuration files. Please enter in your domain
name(s) (comma and/or space separated)  (Enter 'c' to cancel): www.rajie.wiki
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for www.example.com
Waiting for verification...
Cleaning up challenges
Deploying Certificate to VirtualHost /etc/nginx/sites-enabled/default

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Redirecting all traffic on port 80 to ssl in /etc/nginx/sites-enabled/default

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
```

### 开启防火墙

```bash
sudo systemctl start ufw && sudo systemctl enable ufw
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
```


安装Certbot


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

## 异步处理历史

- 异步 callbacks：callbacks 即是将函数作为参数传递，当同步代码运行结束，就调用函数参数继续运行。
- Promise：
- Generator：
- async/await：

优缺点对比：

| 发展史        | 优点                                       | 缺点                                                                                                  |
| ------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Callback      | 解决了同步问题                             | 回调地狱、可读性差、无法 try / catch 、无法 return                                                    |
| Promise       | 一定程度上解决了回调地狱的可读性           | 无法取消、任务多时，同样存在语义不清晰                                                                |
| Generator     | 可以控制函数的执行，可以配合 co 函数库使用 | 流程管理却不方便（即何时执行第一阶段、何时执行第二阶段                                                |
| async / await | 语义更清晰、简洁，内置执行器               | 认知不清晰可能会造成大量 await 阻塞（程序并不会等在原地，而是继续事件循环，等到响应后继续往下走）情况 |

## Promise

```js
let promise = new Promise(function (resolve, reject) {
  // code
})
promise
  .then(() => {
    // then
  })
  .catch((error) => {
    // console.log(error)
  })
  .finally((_) => {
    // finally
  })
```

`code`处是用于执行的代码，当`new Promise`创建时，自动执行。

`then`是定义在`Promise.prototype`上的用来处理状态改变时的回调函数。

参数`resolve`和`reject`是 JavaScript 自身提供的回调函数。当`code`呗执行后应该调用`resolve`或`reject`

- `resolve` 任务成功返回 value
- `reject` 任务失败返回`error`

当`promise`被`reject`的时候或者运行代码抛出错误异常如：`throw new Error('Whoops!')`，`catch`负责处理错误

`finaylly`是`promise`结束时，无论结果是`fulfilled`还是`rejected`都会执行的回调函数

内部属性：

- `state` 初始值`pending`，`resolve`的时候为`fullfilled`，`reject`的时候为`rejected`
- `result` 初始值`undefined`，`resolve`的时候为`value`，`reject`的时候为`error`对象

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

### Promise.all

执行多个 promise，并等待所有 promise 准备就绪，任意一个 promise 被 reject，都会立即出发 Promise.all 的 reject 并且返回该 promise 的 error

```js
let promise = Promise.all([
  /*promises*/
])

// 例子
let urls = [
  'https://api.github.com/users/iliakan',
  'https://api.github.com/users/remy',
  'https://api.github.com/users/jeresig'
]

// 将每个 url 映射（map）到 fetch 的 promise 中
let requests = urls.map((url) => fetch(url))

// Promise.all 等待所有任务都 resolved
Promise.all(requests).then((responses) =>
  responses.forEach((response) => alert(`${response.url}: ${response.status}`))
)
```

### Promise.allSettled

与 Promise.all 不同的是，Promise.allSettled 会等待所有 promise 完成，无论成功失败。

- `{status:"fulfilled", value:result}` 对于成功的响应
- `{status:"rejected", reason:error}` 对于 error。

### Promise.race

只要有一个准备就绪就返回其结果或者错误

```js
Promise.race([
  new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
  new Promise((resolve, reject) =>
    setTimeout(() => reject(new Error('Whoops!')), 2000)
  ),
  new Promise((resolve, reject) => setTimeout(() => resolve(3), 3000))
]).then(alert) // 1
```

### Promise.any

与 Promise.race 类似，Promise.any 等待的是第一个`fulfilled`，如果都`rejected`，则返回一个 error 数组

## async/await

Async/await 是以更舒适的方式使用 promise 的一种特殊语法，同时它也非常易于理解和使用。

async 会将其后面的函数的返回值封装成一个`Promise`对象，而 await 会等待这个`Promise`完成，并将其结果返回。

```js
async function hello() {
  return (greeting = await Promise.resolve('Hello'))
}

hello().then(alert)
```

错误处理

1. 使用`try...catch`捕获 async/await 运行程序中抛出的错误
2. **[await-to-js](https://www.npmjs.com/package/await-to-js)**，使用类 go 语言的方式处理（属于 1 的封装）


Async & Promise


`child_process` 模块使我们在一个运行良好的子进程内运行一些能够进入操作系统的命令

## spawn

`spawn`创建一个子进程

语法：`spawn(command, [args], [options])`

```js
const {spawn} = require('child_process')
const fs = require('fs')

for (var i = 0; i < 3; i++) {
  var workerProcess = spawn('node', ['support.js', i])
  workerProcess.stdout.on('data', function (data) {
    console.log('stdout: ' + data)
  })
  workerProcess.stderr.on('data', function (data) {
    console.log('stderr: ' + data)
  })
  workerProcess.on('close', function (code) {
    console.log('child process exited with code ' + code)
  })
}
```

## exec

`exec`使用子进程执行命令，不缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回

语法：`exec(command, [options], callback)`

```js support.js
console.log('进程 ' + process.argv[2] + ' 执行。')
```

```js master.js
const fs = require('fs')
const child_process = require('child_process')

for (var i = 0; i < 3; i++) {
  var workerProcess = child_process.exec(
    'node support.js ' + i,
    function (error, stdout, stderr) {
      if (error) {
        console.log(error.stack)
        console.log('Error code: ' + error.code)
        console.log('Signal received: ' + error.signal)
      }
      console.log('stdout: ' + stdout)
      console.log('stderr: ' + stderr)
    }
  )

  workerProcess.on('exit', function (code) {
    console.log('子进程已退出，退出码 ' + code)
  })
}
```

## fork

`fork`创建一个子进程，并在父进程中继续执行

语法：`fork(modulePath, [args], [options])`

```js support.js
console.log('进程 ' + process.argv[2] + ' 执行。')
```

```js master.js
const fs = require('fs')
const child_process = require('child_process')

for (var i = 0; i < 3; i++) {
  var worker_process = child_process.fork('support.js', [i])

  worker_process.on('close', function (code) {
    console.log('子进程已退出，退出码 ' + code)
  })
}
```

[Node.js 文档](http://nodejs.cn/api/child_process.html)


child_process 模块使我们在一个运行良好的子进程内运行一些能够进入操作系统的命令

Node.js - Child Process


![集合引用类型](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/集合引用类型.png)

## Object

> 任何非原始类型的值（字符串，数字，布尔值，符号，null 或未定义）都是对象，数组和函数也不例外。

内置属性

1. Object.length=1
2. Object.prototype

静态方法

1. Object.assign() **_ES2015_** //通过复制一个或多个对象来创建一个新的对象。
2. Object.create() //使用指定的原型对象和属性创建一个新对象。
3. Object.defineProperty() //给对象添加一个属性并指定该属性的配置。
4. Object.defineProperties() //给对象添加多个属性并分别指定它们的配置。
5. Object.entries() **_ES2017_** //返回给定对象自身可枚举属性的 [key, value] 数组。
6. Object.freeze() //冻结对象：其他代码不能删除或更改任何属性。
7. Object.getOwnPropertyDescriptor() //返回对象指定的属性配置。
8. Object.getOwnPropertyNames() //返回一个数组，它包含了指定对象所有的可枚举或不可枚举的属性名。
9. Object.getOwnPropertySymbols() //返回一个数组，它包含了指定对象自身所有的符号属性。
10. Object.getPrototypeOf() //返回指定对象的原型对象。
11. Object.is() **_ES2015_** //比较两个值是否相同。所有 NaN 值都相等（这与==和===不同）。
12. Object.isExtensible() //判断对象是否可扩展。
13. Object.isFrozen() //判断对象是否已经冻结。
14. Object.isSealed() //判断对象是否已经密封。
15. Object.keys() //返回一个包含所有给定对象自身可枚举属性名称的数组。
16. Object.preventExtensions() //防止对象的任何扩展。
17. Object.seal() //防止其他代码删除对象的属性。
18. Object.setPrototypeOf() **_ES2015_** //设置对象的原型（即内部 [[Prototype]] 属性）。
19. Object.values() //返回给定对象自身可枚举值的数组。

Object 实例和 Object 原型对象

> JavaScript 中的所有对象都来自 Object；所有对象从 Object.prototype 继承方法和属性，尽管它们可能被覆盖。

```js
Object.prototype.constructor //特定的函数，用于创建一个对象的原型。
```

实例方法

1. Object.prototype.hasOwnProperty() //返回一个布尔值 ，表示某个对象是否含有指定的属性，而且此属性非原型链继承的。
2. Object.prototype.isPrototypeOf() //返回一个布尔值，表示指定的对象是否在本对象的原型链中。
3. Object.prototype.propertyIsEnumerable() //判断指定属性是否可枚举，内部属性设置参见 ECMAScript [[Enumerable]] attribute 。
4. Object.prototype.toLocaleString() //直接调用 toString()方法。
5. Object.prototype.toString() //返回对象的字符串表示。
6. Object.prototype.valueOf() //返回指定对象的原始值。

创建对象

```js
const person = {}
typeof person //object
```

### 使用 Object 全局函数

```js
const person = Object()
typeof person //object
```

### 使用 Object 构造器

```js
const person = new Object()
typeof person //object
```

### 使用 Object.create()

```js
const car = Object.create()
```

```js
const person = {
  age: 36,
  name: 'funny',
  speak: () => {
    //speak
  }
}

const person = Object({
  age: 36,
  name: 'funny',
  speak: () => {
    //speak
  }
})

const person = new Object({
  age: 36,
  name: 'funny',
  speak: () => {
    //speak
  }
})
```

### Object.assign

```js
const copied = Object.assign({}, target1, target2, ...target)
```

> Object.assign-将一个或多个对象的所有可枚举属性复制到另一个对象中。浅拷贝，复制对象引用而非对象本身。

```js
const original = {
  name: 'Fiesta',
  car: {
    color: 'blue'
  }
}
const copied = Object.assign({}, original)

original.name = 'Focus'
original.car.color = 'yellow'

copied.name //Fiesta
copied.car.color //yellow
```

### Object.create

```js
const newObject = Object.create(prototype)

const newObject = Object.create(prototype, newProperties)
```

> 使用指定原型创建新的对象，可以指定第二个参数来向对象添加新属性

```js
const animal = {}
const dog = Object.create(animal)

const animal = {}
const dog = Object.create(animal, {
  breed: {
    value: 'Siberian Husky'
  }
})
console.log(dog.breed) //'Siberian Husky'
```

### Object.defineProperty

> 直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象

```js
const dog = {}
Object.defineProperty(dog, 'breed', {
  value: 'Siberian Husky'
})
console.log(dog.breed) //'Siberian Husky'
```

扩展：[vue 原理之-神奇的 Object.defineProperty]("https://zhuanlan.zhihu.com/p/29066270")

### Object.defineProperties

> 直接在一个对象上定义新的属性或修改现有属性，并返回该对象

```js
const dog = {}
Object.defineProperties(dog, {
  breed: {
    value: 'Siberian Husky'
  }
})
console.log(dog.breed) //'Siberian Husky'
```

### Object.entries()

> ES2017,返回自身可枚举属性的键值对数组

```js
const person = {name: 'Fred', age: 87}
Object.entries(person) // [['name', 'Fred'], ['age', 87]]

const people = ['Fred', 'Tony']
Object.entries(people) // [['0', 'Fred'], ['1', 'Tony']]
```

### Object.freeze()

> 冻结对象，冻结后不能再添加或修改

```js
const dog = {}
dog.breed = 'Siberian Husky'
const myDog = Object.freeze(dog)

Object.isFrozen(dog) //true
Object.isFrozen(myDog) //true
dog === myDog //true

dog.name = 'Roger' //TypeError: 无法添加name属性，dog是不可扩展的
```

### Object.getOwnPropertyDescriptor()

> 返回自由属性描述符

```js
const dog = {}
Object.defineProperties(dog, {
  breed: {
    value: 'Siberian Husky'
  }
})
Object.getOwnPropertyDescriptor(dog, 'breed')
/*
{
  value: 'Siberian Husky',
  writable: false,
  enumerable: false,
  configurable: false
}
*/
```

### Object.getOwnPropertyNames()

> 返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括 Symbol 值作为名称的属性）组成的数组

```js
const dog = {}
dog.breed = 'Siberian Husky'
dog.name = 'Roger'

Object.getOwnPropertyNames(dog) //[ 'breed', 'name' ]
```

### Object.getOwnPropertySymbols()

> 返回一个给定对象自身的所有 Symbol 属性的数

```js
const dog = {}
const r = Symbol('Roger')
const s = Symbol('Syd')
dog[r] = {
  name: 'Roger',
  age: 6
}
dog[s] = {
  name: 'Syd',
  age: 5
}

Object.getOwnPropertySymbols(dog) //[ Symbol(Roger), Symbol(Syd) ]
```

### Object.getPrototypeOf()

> 返回指定对象的原型（内部[[Prototype]]属性的

```js
const animal = {}
const dog = Object.create(animal)
const prot = Object.getPrototypeOf(dog)

animal === prot //true

//如果对象没有原型，将返回null
Object.prototype //{}
Object.getPrototypeOf(Object.prototype) //null
```

### Object.is()

> 判断两个值是否相等

- 两个值都是 undefined
- 两个值都是 null
- 两个值都是 true 或者都是 false
- 两个值是由相同个数的字符按照相同的顺序组成的字符串
- 两个值指向同一个对象
- 两个值都是数字并且
  - 都是正零 +0
  - 都是负零 -0
  - 都是 NaN
  - 都是除零和 NaN 外的其它同一个数字

```js
Object.is(a, b)
```

### Object.isExtensible()

> 判断一个对象是否是可扩展的，返回布尔值。任何对象都是可扩展，除非使用了 Object.freeze()、Object.seal()、Object.preventExtensions()

### Object.isFrozen()

> 判断一个对象是否被冻结，返回布尔值

```js
const dog = {}
dog.breed = 'Siberian Husky'
const myDog = Object.freeze(dog)
Object.isFrozen(dog) //true
Object.isFrozen(myDog) //true
dog === myDog //true
```

### Object.isSealed()

> 判断一个对象是否被密封，返回布尔值

```js
const dog = {}
dog.breed = 'Siberian Husky'
const myDog = Object.seal(dog)
Object.isSealed(dog) //true
Object.isSealed(myDog) //true
dog === myDog //true
```

### Object.keys()

> 返回对象的自身可枚举属性组成的数组

```js
const car = {
  color: 'Blue',
  brand: 'Ford',
  model: 'Fiesta'
}

Object.keys(car) //[ 'color', 'brand', 'model' ]
```

### Object.preventExtensions()

> 阻止对象扩展，但可以删除属性

```js
const dog = {}
dog.breed = 'Siberian Husky'
Object.preventExtensions(dog)

dog.name = 'Roger' //TypeError: Cannot add property name, object is not extensible

delete dog.name
dog //{ breed: 'Siberian Husky' }
```

### Object.seal()

> 与 Object.freeze（）类似，但不会使属性不可写。仅阻止添加或删除属性。与 Object.preventExtensions（）类似，但也不允许删除属性：

```js
const dog = {}
dog.breed = 'Siberian Husky'
Object.seal(dog)
dog.breed = 'Pug'
dog.name = 'Roger' //TypeError: Cannot add property name, object is not extensible
```

### Object.values()

> 对象自身的所有可枚举属性值的数组

```js
const person = {name: 'Fred', age: 87}
Object.values(person) // ['Fred', 87]

const people = ['Fred', 'Tony']
Object.values(people) // ['Fred', 'Tony']
```

### Object.hasOwnProperty()

> 判断对象自身是否有某个值，返回布尔值

```js
const person = {name: 'Fred', age: 87}
person.hasOwnProperty('name') //true
person.hasOwnProperty('job') //false
```

### Object.isPrototypeOf()

> 测试一个对象是否存在于另一个对象的原型链上

```js
const Animal = {
  isAnimal: true
}

const Mammal = Object.create(Animal)
Mammal.isMammal = true

Animal.isPrototypeOf(Mammal) //true

const dog = Object.create(Animal)
Object.setPrototypeOf(dog, Mammal)

Animal.isPrototypeOf(dog) //true
Mammal.isPrototypeOf(dog) //true
```

### Object.propertyIsEnumerable()

> 判断对象的属性是否可枚举，返回布尔值

```js
const person = {name: 'Fred'}

Object.defineProperty(person, 'age', {
  value: 87,
  enumerable: false
})

person.propertyIsEnumerable('name') //true
person.propertyIsEnumerable('age') //false
```

### Object.toLocaleString()

```js
const person = {name: 'Fred'}
person.toLocaleString() //[object Object]
```

### Object.toString()

```js
const person = {name: 'Fred'}
person.toString() //[object Object]
```

### Object.valueOf()

> 返回指定对象的原始值

```js
const person = {name: 'Fred'}
person.valueOf() //{ name: 'Fred' }
```

## Array

属性

1. Array.length - 静态属性，值为 1
2. Array.prototype - 数组的原型对象

方法

1. Array.from - 从类数组对象或者可迭代对象中创建一个新的数组实例
2. Array.of - 根据一组参数来创建新的数组实例，支持任意的参数数量和类型
3. Array.isArray - 判断是否为数组

### 实例属性

1. Array.prototype.length - 空数组，值为 0
2. Array.prototype.constructor - 所有的数组实例都继承了这个属性，值为 Array

### 实例方法

#### 修改器方法 - 改变调用它们的对象自身的值

- Array.prototype.copyWithin //将数组 copy 到另一个数组，并覆盖原值
- Array.prototype.fill //填充数组
- Array.prototype.pop //删除数组最后一个值，并返回该值
- Array.prototype.push //向数组最后添加一个新的元素或多个元素，并返回数组的长度
- Array.prototype.reverse //颠倒数组
- Array.prototype.shift //删除数组第一个元素并返回该元素
- Array.prototype.sort //排序
- Array.prototype.splice //在数组任意位置添加或删除元素
- Array.prototype.unshift //在数组开头添加一个或多个元素并返回数组长度

#### 访问方法 - 不会改变调用它们的对象自身的值，只会返回新数组或期望值

- Array.prototype.concat //返回当前数组和其他数组的组合
- Array.prototype.includes //数组是否包含某个值，返回 true/false
- Array.prototype.join //返回数组所有元素组成的字符串
- Array.prototype.slice //截取数组的某一段
- Array.prototype.toString //转换成字符串
- Array.prototype.toLocalString //转换成本地字符串
- Array.prototype.indexOf //返回数组中第一个与指定值相等的索引
- Array.prototype.lastIndexOf //返回数组中最后一个与指定值相等的索引

#### 迭代方法

- Array.prototype.forEach //为数组中每个元素执行一次回调函数
- Array.prototype.entries //返回数组元素的键值对
- Array.prototype.every //如果每个元素都满足回调函数就返回 true，否则返回 false
- Array.prototype.some //如果数组中元素至少有一个满足回调函数就返回 true，否则返回 false
- Array.prototype.filter //过滤数组中满足回调函数的元素
- Array.prototype.find //查找数组中满足回调函数的元素，如果没有则返回 undefined
- Array.prototype.findIndex //返回数组中满足回调函数的索引，没有则返回-1
- Array.prototype.keys //返回数组中的键
- Array.prototype.map //返回一个由回调函数组成的新数组
- Array.prototype.reduce //从右向左为每个元素执行一次回调函数，并将上次回调函数的返回值暂存，然后传递给下一个回调函数
- Array.prototype.reduceRight //与 reduce 相反方向
- Array.prototype.values //返回数组中的值

### 四种合并数组的方法

1. 循环

```js
function push(fromArray, toArray) {
  for (let i = 0, len = fromArray.length; i < len; i++) {
    toArray.push(fromArray[i])
  }
  return toArray
}

var array1 = [1, 2, 3, 4, 5]
var array2 = [6, 7, 8, 9, 10]
var array3 = []
push(array1, array3)
push(array2, array3)
```

2. 解构

```js
var array1 = [1, 2, 3, 4, 5]
var array2 = [6, 7, 8, 9, 10]
var array3 = [...array1, ...array2]
var array3 = Array.of(...array2, ...array1)
array3 // [1,2,3,4,5,6,7,8,9,10];
```

3. concat

```js
var array1 = [1, 2, 3, 4, 5]
var array2 = [6, 7, 8, 9, 10]

var array3 = array1.concat(array2)
// or
var array3 = [].concat(array1, array2)
```

4. reduce

```js
var array1 = [1,2,3,4,5];
var array2 = [6,7,8,9,10];
var array3 = array2.reduce((newArray, item) => {
          newArray.push(item);
          return newArray;
 ), array1);
```

## 定型数组

## Map、WeakMap

## Set、WeakSet

## 迭代、扩展操作


Javascript - 集合引用类型


使用 `Postgresql IN` 检索查询是否与列表中的任何值相匹配。

## 语法

```sql
value IN (value1, value2, ...)
```

如果匹配，则返回 `TRUE`，否则返回 `FALSE`。

```sql
value IN (SELECT column_name FROM table_name)
```

## 示例

```sql
SELECT customer_id,
	rental_id,
	return_date
FROM
	rental
WHERE
	customer_id IN (1, 2)
ORDER BY
	return_date DESC;
```

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

以上代码用`=`和`OR`可以这样写

```sql
SELECT customer_id,
  rental_id,
  return_date
FROM
  rental
WHERE
  customer_id = 1 OR customer_id = 2
ORDER BY
  return_date DESC;
```

使用`IN`运算符的查询比使用`=`和`OR`运算符的查询更快，更具可读性。

## NOT IN

查询返回的结果不包含列表中的任何值。

```sql
SELECT customer_id,
  rental_id,
  return_date
FROM
  rental
WHERE
  customer_id NOT IN (1, 2)
```

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

同样以上代码可以使用`<>`和`AND`运算符

```sql
SELECT customer_id
FROM rental
WHERE CAST (return_date AS DATE) = '2005-05-27'
ORDER BY customer_id;
```

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

```sql
SELECT
	customer_id,
	first_name,
	last_name
FROM
	customer
WHERE
	customer_id IN (
		SELECT customer_id
		FROM rental
		WHERE CAST (return_date AS DATE) = '2005-05-27'
	)
ORDER BY customer_id;
```

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


使用 Postgresql IN 检索查询是否与列表中的任何值相匹配。