From b0c33406ac8f30cec804fcb7d414a0db8f19a672 Mon Sep 17 00:00:00 2001
From: RainSun <zhaoyingbo@live.cn>
Date: Thu, 2 Apr 2020 18:34:42 +0800
Subject: [PATCH] update

---
 Miscellaneous/javascript2.md | 73 +++++++++++++++++++++++++++---------
 1 file changed, 55 insertions(+), 18 deletions(-)

diff --git a/Miscellaneous/javascript2.md b/Miscellaneous/javascript2.md
index c722187..11a46d4 100644
--- a/Miscellaneous/javascript2.md
+++ b/Miscellaneous/javascript2.md
@@ -117,35 +117,35 @@
 * 模块
   * `import` 和 `export` 必须在使用它们的最顶层作用域
   * 命名导出
-  ```
+  ```js
   // 方式一
   export var bar = [1,3,4]; export function foo() {}
   // 方式二
   var bar = []; function foo() {}; export {bar, foo}
   ```
   * 导出的是在模块内的最后的值
-  ```
+  ```js
   var a = 1
   export { a }
   a = 2
-  -> 最后导出的是2而不是1
+  // -> 最后导出的是2而不是1
   ```
   * 导出可以指定名称
-  ```
+  ```js
   var a = 1
   export { a as b }
-  -> 只有b可以被导入，a被隐藏
+  // -> 只有b可以被导入，a被隐藏
   ```
   * 导入不是赋值操作，而是类似指针一样的绑定
   * es6倾向于一个文件一个export，可以使import变得简单
   * 默认导出的两种形式
-  ```
-  export default function foo() {} -> 导出的是表达式的绑定
-  function foo() {} export default foo -> 同上,即`export default`接受的是一个表达式
-  function foo() {} export { foo as default } -> 导出的是标识符的绑定，也就是导出foo在文件中最后的值
+  ```js
+  export default function foo() {} // -> 导出的是表达式的绑定
+  function foo() {} export default foo // -> 同上,即`export default`接受的是一个表达式
+  function foo() {} export { foo as default } // -> 导出的是标识符的绑定，也就是导出foo在文件中最后的值
   ```
   * 一个模块只能有一个default
-  ```
+  ```js
   // 方式一
   export default function foo() {}
   export function bar() {}
@@ -155,7 +155,7 @@
   export { foo as default, bar }
   ```
   * 可以导出别的模块的导出 -> 感觉可以用来集成模块，，也没啥用
-  ```
+  ```js
   export { foo, bar } from 'baz'
   export { foo as FOO, bar as BAR } from 'baz'
   export * from 'baz'
@@ -170,7 +170,7 @@
   * 所有导入都会被提升，全局访问
 * 类
   * 使用`class`声明类，类名大写
-  ```
+  ```js
   class Foo {
     constructor(a, b) {
       this.x = a;
@@ -186,12 +186,12 @@
   * 声明一个class并没有创建一个同名的全局对象属性
   * class本身并不是一个实体，而是一个包裹着其他像函数和属性这样的具体实体并把它们组合到一起的元概念
   * class也可以是一个表达式
-  ```
-  var x = class Y {} -> 对于把类定义(严格说是构造器本身)作为函数参数传递，或者把它赋值给一个对象属性的时候特别管用
+  ```js
+  var x = class Y {} // -> 对于把类定义(严格说是构造器本身)作为函数参数传递，或者把它赋值给一个对象属性的时候特别管用
   ```
   * 把类理解为一个宏，用于自动产生一个prototype对象
   * 类对extends以及super提供语法糖
-  ```
+  ```js
   class Bar extends Foo {
     constructor(a, b, c) {
       super(a, b)
@@ -203,14 +203,14 @@
   }
   ```
   * 如果子类不定义构造函数就会
-  ```
+  ```js
   constructor(...args) {
     super(...args)
   }
   ```
   * 子类不在构造器中使用`super`是无法使用`this`的
   * 可以拓展原生类
-  ```
+  ```js
   class MyCoolArray extends Array {
     first() {return this[0]}
     last() {return this[this.length -1 ]}
@@ -220,4 +220,41 @@
   ```
   * `new.target`在构造器中访问new直接调用的构造器
 * Promise
-  * 
\ No newline at end of file
+  * 决议的结果只可能是完成或者拒绝，附带一个可选的单个值，如果拒绝，那么最终的值称为原因
+  * 只能被完成或者拒绝一次，之后完成或者拒绝的操作都会被忽略
+  * 创建一个Promise
+  ```js
+  var p = new Promise(function(resolve, reject) {
+    // 成功
+    resolve(arg)
+    // 采用另一个Promise的决议值
+    resolve(promise)
+    // 拒绝
+    reject(why)
+  })
+  // 调用
+  // then接受两个函数第一个是完成，第二个是拒绝时执行
+  p().then(
+    function fulfilled(res) {},
+    funcrion rejected(err){},
+  )
+  ```
+  * 不论是`.then`还是`.catch`都会返回一个Promise，可以用`.then`进行处理
+  * 只要是函数里边包含`then`方法都会被认为是一个`thenable`所以不要盲目信任自称是Promise的东西
+  * Promise API
+    * `Promise.resolve`
+    ```js
+    var p1 = Promise.resolve(42)
+    var p2 = new Promise(function pr(resolve){resolve(42)})
+    // p1 和 p2 的最终行为方式是相同的
+    ```
+    这个接口提供了一个规范化Promise的方法，可以将刚刚不可信任的thenable放进去规范化
+    * `Promise.reject`
+      * 和上边的一样创建一个立即被拒绝的promise，但是如果他的参数是Promise，它不会理会传进来得Promise的决议值
+    * `Promise.all([])`
+      * 接受一个或者多个值的数组，比如立即值、Promise、thenable，它返回一个promise，如果里边的所有值都是完成则决议结果是完成，其中某一个被拒绝这个Promise就立即被拒绝
+      * 是等待所有都完成或者第一个拒绝
+    * `Promise.rase([])`
+      * 等待第一个完成或者拒绝
+      * 也就是说返回第一个完成的决议值
+    *