代码输出题总结：异步/事件循环/this指向/原型和继承

目录

Promise部分总结

This指向

原型和继承 

---

Promise部分总结

1. Promise 状态与输出：
当使用 .then() 或 await 时，如果没有返回新的 Promise，而当前的 Promise 仍然处于 pending 状态，则后续的输出将被忽略，因为程序会在该位置阻塞，等待 Promise 被解决（resolve 或 reject）。

2. 显示 Pending 状态：
如果在 .then() 后直接输出一个 Promise，并且该 Promise 处于 pending 状态，输出将显示为 Promise { <pending> }，表示该 Promise 仍在等待解决。

3. finally 的行为：
finally 中的返回值不会改变 Promise 的最终状态，除非返回一个错误。在这种情况下，该错误会被后续的 .catch() 捕获。否则，finally 返回的值会被忽略，并且前面的 .then() 的结果会被视为 undefined。如果 finally 返回的是最近的 .then() 的状态，该状态仍会传递到后续的 .then() 中。

4. Promise.resolve().then() 中的错误处理：
在 Promise.resolve().then() 中，如果你返回一个 Error 对象，例如 return new Error('xxx')，这个错误会被自动包装成 Promise 的 rejected 状态，因此可以在后续的 .catch() 中捕获。

5. async/await 中的错误处理：
在 async/await 中，如果 await 的 Promise 产生了未捕获的错误，后续的代码将被忽略。此时，可以通过 try...catch 语句捕获错误，从而防止后续代码被忽略。
 

function runAsync (x) {
  const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))
  return p
}
function runReject (x) {
  const p = new Promise((res, rej) => setTimeout(() => rej(`Error: ${x}`, console.log(x)), 1000 * x))
  return p
}
Promise.all([runAsync(1), runReject(4), runAsync(3), runReject(2)])
       .then(res => console.log(res))
       .catch(err => console.log(err))

（15）：all和race里如果遇到一个reject就直接返回，但是异步函数会继续执行

allsettled会按照输入的顺序等他们全执行

Promise.resolve().then(() => {
    console.log('1');
    throw 'Error';
}).then(() => {
    console.log('2');
}).catch(() => {
    console.log('3');
    throw 'Error';
}).then(() => {
    console.log('4');
}).catch(() => {
    console.log('5');
}).then(() => {
    console.log('6');
});

catch后的then也会执行

 

This指向

(10 )

var a = 1;
function printA(){
  console.log(this.a);
}
var obj={
  a:2,
  foo:printA,
  bar:function(){
    printA();
  }
}

obj.foo(); // 2
obj.bar(); // 1
var foo = obj.foo;
foo(); // 1

 printA在bar方法中执行，所以此时printA的this指向的是window，所以会输出1；

var a = 10; 
 var obt = { 
   a: 20, 
   fn: function(){ 
     var a = 30; 
     console.log(this.a)
   } 
 }
 obt.fn();  // 20
 obt.fn.call(); // 10
 (obt.fn)(); // 20 这不是立即执行匿名函数啊

原型和继承 

function Foo() {
            getName = function () {
                console.log(1);
            }
            return this;
        }
        // b
        Foo.getName = function () {
            console.log(2);
        }
        // c
        Foo.prototype.getName = function () {
            console.log(3);
        }
        // d
        var getName = function () {
            console.log(4);
        }
        // e
        function getName() {
            console.log(5);
        }

        Foo.getName();           // 2
        getName();               // 4
        Foo().getName();         // 1
        getName();               // 1 
        new Foo.getName();       // 2
        new Foo().getName();     // 3
        new new Foo().getName(); // 3

(2): new Foo.getName();       // 2 这部分相当于先执行Foo.getName() 再创建这个新实例

new 绑定是比隐式绑定优先级高，new绑定 > 显式绑定 > 隐式绑定 > 默认绑定

题目来自：https://juejin.cn/post/6959043611161952269#heading-50