ES6片段

那些可能会忘记或不知所以然的点：

1、

2、

3、

4、

5、

6、

/*
    函数调用会在内存形成一个“调用记录”，又称调用帧，保存调用位置和内存变量等信息。
    如果在函数 A 的内部调用函数 B，那么在 A 的调用帧上方，会形成一个 B 的
    调用帧，等到 B 运行结束，将结果返回到 A，B 的调用帧才会消失。
    */

    function add(n) {
        if (n === 1) {
            return 1;
        }
        return n * add(n - 1);
    }

    add(3); // 6

    /*
    第一个入栈 add(3), return 3 * add(3 - 1) = 3 * add(2)
    第二个入栈 add(2), return 2 * add(2 - 1) = 2 * add(1)
    第三个入栈 add(1), return 1

    第三个出栈 add(1), return 1，将返回结果返回到第二个栈中，
    第二个出栈 add(2), return 2 * 1, 将返回结果返回到第一个栈中，
    第一个出栈 add(3), return 3 * 2 * 1
    */
   

7、

8、

9、

10、

function strMaptoObj (map) {
    let obj = Object.create(null);
    for (let [k, v] of map) {
      obj[k] = v;
    }
    return obj
  }

  let map = new Map([
    [2, "e"],
    [{f: 'bar'}, 323],
    [{g: 'foo'}, "后来的对象会把前面的覆盖"]
  ]);

  console.log(strMaptoObj(map)); // {2: 'e', [object Object]: '后来的对象会把前面的覆盖'}
  console.log(strMaptoObj(map)["[object Object]"]); // 后来的对象会把前面的覆盖

map

11、

proxy 章节延伸 prototype

<script>
    /*
    isPropertyOf：允许检查一个对象是否存在于另一个对象原型链上。
    Foo.prototype.isPrototypeOf(baz)：表示检查 baz 对象是否继承自 Foo 或者说 Foo.prototype 在 baz 的原型链上。
    */
    // Baz.prototype / Bar.prototype / Foo.prototype / Object.prototype 在 baz 对象的原型链上：

    function Foo() {}
    function Bar() {}
    function Baz() {}

    Bar.prototype = Object.create(Foo.prototype);
    Baz.prototype = Object.create(Bar.prototype);

    var baz = new Baz();

    console.log(Baz.prototype.isPrototypeOf(baz)); // true
    console.log(Bar.prototype.isPrototypeOf(baz)); // true
    console.log(Foo.prototype.isPrototypeOf(baz)); // true
    console.log(Object.prototype.isPrototypeOf(baz)); // true
</script>

prototype

12、promise 章节延伸执行机制

const promise = new Promise(function (resolve, reject) {
  resolve(2);
});

// 备注为 A
promise
    .then(value => {console.log(value); return value + s2; })
    .catch(error => console.log("error1:", error));

// 备注为 B
promise
  .then(value => { console.log(value); return value + 2 })
  .then(val => { console.log(val); return val + y; })
  .catch(error => console.log("error2: ", error));

/*
2
2
error1: ReferenceError: s2 is not defined
4
error2:  ReferenceError: y is not defined

说明： catch 捕捉第一个报错的 promise 实例，
A 中的 promise 实例链式里，出错的是第一个 then
B 中的 promise 实例链式里，出错的是第一个 then
*/

/*
第一轮循环：promise 的第一个 then 方法，then 方法后的 then 或 catch
同样是异步，整体的执行顺序是：
第一轮微任务
A: promise.then  // 打印 2
B: promise.then  // 打印 2

第二轮微任务
A: promise.then.catch  // 打印 error1: ReferenceError: s2 is not defined
B: promise.then.then   // 打印 4

第三轮微任务
B: promise.then.then.catch  // 打印 error2:  ReferenceError: y is not defined
*/

promise-then-then

13、allSettled —— 不设置 await 写法

14、try —— 匿名函数执行，其实第二个写法直接写成 new Promise(resolve => resolve(f()) 不成了吗~

15、const 声明数字类型不能再重新修改赋值。