事件循环
js是有两个任务队列的
Macrotask Queue(Task Queue)：进行一些比较大型的工作，常见的有setTimeout,setInterval,用户交互操作，UI渲染等
Microtask Queue：进行一些比较小型的工作，常见的有Promise,process.nextTick(nodejs)
事件循环机制：
1.检查Macrotask 队列是否为空,若不为空，则进行下一步，若为空，则跳到3
2.从Macrotask队列中取队首(在队列时间最长)的任务进去执行栈中执行(仅仅一个)，执行完后进入下一步
3.检查Microtask队列是否为空，若不为空，则进入下一步，否则，跳到1（开始新的事件循环）
4.从Microtask队列中取队首(在队列时间最长)的任务进去事件队列执行,执行完后，跳到3
e.g.
console.log(1)
setTimeout(function() {
//settimeout1
console.log(2)
}, 0);
const intervalId = setInterval(function() {
//setinterval1
console.log(3)
}, 0)
setTimeout(function() {
//settimeout2
console.log(10)
new Promise(function(resolve) {
//promise1
console.log(11)
resolve()
})
.then(function() {
console.log(12)
})
.then(function() {
console.log(13)
clearInterval(intervalId)
})
}, 0);
//promise2
Promise.resolve()
.then(function() {
console.log(7)
})
.then(function() {
console.log(8)
})
console.log(9)
//控制台输出：1 9 7 8 2 3 10 11 12 13
Promise
1.promise 运用例子
var promise = new Promise（function（resolve,reject){
var a = 1;
resolve(a);
var b= 2;
reject(b);
})
promise.then(function1 (a){}, function2 (b){} );
function1为resolve回调函数，function2为reject回调函数
2.当resolve函数的参数为一个promise时。
var p1 = new Promise(function (resolve, reject) {
// ...
});
var p2 = new Promise(function (resolve, reject) {
// ...
resolve(p1);
})
这时p1的状态就会传递给p2，也就是说，p1的状态决定了p2的状态。如果p1的状态是pending，那么p2的回调函数就会等待p1的状态改变；如果p1的状态已经是resolved或者rejected，那么p2的回调函数将会立刻执行。
3.形成回调结果链状使用,promise.then(), promise.catch()
var promise = new Promise(function(resolve, reject){
var a = 1;
resolve(a);
});
promise.then(function(b){
return new Promise(function(resolve, reject){
b++;
console.log(b);
resolve(b);
})
}).then(function(c){
c++;
console.log(c);
return c
}).catch(function(err){
console.log(err);
});
promise.then(),promise.catch()都会返回一个promise对象，因此下面可以接着连接.then() .catch().
promise.catch()
如果promise对象状态变为rejected，就会调用catch方法指定的回调函数，处理这个错误。reject()中传入的参数，会传递给catch方法
then方法指定的回调函数，如果运行中抛出错误，也会被catch方法捕获。
在多个.then( ).then( ).then( ).catch( )链中，中间某个then（）报错，则后面的then( )函数不会执行，错误由catch捕获。避免错误不会统一处理的方法，给then（resolve, reject）加上第二个回调函数reject。
4.promise.all()
var p = Promise.all([p1, p2, p3]);
上面代码中，Promise.all方法接受一个数组作为参数，p1、p2、p3都是 Promise 实例，如果不是，，将参数转为 Promise 实例，再进一步处理。（Promise.all方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。）
p的状态由p1、p2、p3决定，分成两种情况。
（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。
（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数
// 生成一个Promise对象的数组
var promises = [2, 3, 5, 7, 11, 13].map(function (id) {
return getJSON('/post/' + id + ".json");
});
Promise.all(promises).then(function (posts) {
// ...
}).catch(function(reason){
// ...
});
上面代码中，promises是包含6个 Promise 实例的数组，只有这6个实例的状态都变成fulfilled，或者其中有一个变为rejected，才会调用Promise.all方法后面的回调函数。
5.promise.race()
var p = Promise.race([p1, p2, p3]);
上面代码中，只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。
6.promise.resolve()将现有对象转为Promise对象
（1）参数是一个Promise实例
如果参数是Promise实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。
（2）参数是一个thenable对象
thenable对象指的是具有then方法的对象，比如下面这个对象。
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
Promise.resolve方法会将这个对象转为Promise对象，然后就立即执行thenable对象的then方法。
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
let p1 = Promise.resolve(thenable);
p1.then(function(value) {
console.log(value); // 42
});
上面代码中，thenable对象的then方法执行后，对象p1的状态就变为resolved，从而立即执行最后那个then方法指定的回调函数，输出42。
（3）参数不是具有then方法的对象，或根本就不是对象
如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的Promise对象，状态为resolved。
var p = Promise.resolve('Hello');
p.then(function (s){
console.log(s)
});
// Hello
上面代码生成一个新的Promise对象的实例p。由于字符串Hello不属于异步操作（判断方法是字符串对象不具有then方法），返回Promise实例的状态从一生成就是resolved，所以回调函数会立即执行。Promise.resolve方法的参数，会同时传给回调函数。
（4）不带有任何参数
Promise.resolve方法允许调用时不带参数，直接返回一个resolved状态的Promise对象。
所以，如果希望得到一个Promise对象，比较方便的方法就是直接调用Promise.resolve方法。
var p = Promise.resolve();
p.then(function () {
// ...
});
上面代码的变量p就是一个Promise对象。
需要注意的是，立即resolve的Promise对象，是在本轮“事件循环”（event loop）的结束时，而不是在下一轮“事件循环”的开始时。
