一、抓取页面不适合高并发，不然容易被发现。每次只抓一个，处理完了再去抓下一个。

一、实现队列

1、forEach()

（1）

function queue(things) {
  let promise = Promise.resolve();
  things.forEach(thing => {
    promise = promise.then(() => {
      return new Promise(resolve => {
        doThing(thing, () => {
          resolve();
        });
      });
    });
  });
  return promise;
}
queue(['lots', 'of', 'things', ....]);

（2）常见错误：没有把.then()产生的新的promise实例赋给then,没有生成队列。

2、reduce()，数组的一端遍历到另一端。

（1）

function queue(things) {
  return things.reduce((promise, things) => {
    return promise.then(() => {
      return new Promise(resolve => {
        doThing(thing, () => {
          resolve();
        });
      });
    });
  }), Promise.resolve();
}
queue(['lots', 'of', 'things', ....]);

（2）常见错误：Promise实例创建之后，会立刻执行执行器代码，所以这个也无法达成队列的效果。

一、Promise.all()最常见的就是和.map()一起使用。

一、promise.all()：批量执行

1、Promise.all([p1, p2, p3,  …])用于将多个promise实例，包装成一个新的promise实例。

2、返回的实例就是普通promise

3、它接收一个数组作为参数。

4、数组里可以是promise对象，也可以是别的值，只有promise对象会等待状态改变。

5、当所有子promise都完成，该promise完成，返回值是全部值的数组。

6、有任何一个失败，该promise失败，返回值是第一个失败的子promise的结果。

一、.catch()之后.then()

catch也会返回一个promise实例，如果没有抛出错误，也会是fulfilled状态，会执行后面的then()。

二、强烈建议在所有队列最后都加上.catch()，以避免漏掉错误处理造成意想不到的问题。

doSomething()
  .doAnotherThing()
  .doMoreThing()
  .catch(err => {
    console.log(err);
  })

一、错误处理

1、promise会自动捕获内部异常，并交给rejected响应函数处理。

2、promise试图在现有的语言框架中解决异步回调带来的问题。在栈的语言基层运行池相关的问题就无法处理了，我们能捕获到的是异步完成回调之后的这部分栈信息，仍然无法确定是哪里导致的错误。

3、promise执行器如果发生错误，执行器状态就会被置为rejected，fulfilled状态就不会被执行。

二、错误处理的2中做法

1、reject(‘错误信息’).then(null, message => {});

2、throw new Error(‘错误信息’).catch(message => {});

推荐使用第二种，更加清晰好读，并且可以捕获前面的错误。

new Promise(resolve => {
  setTimeout(() => {
    throw new Error('bye');
  }, 1000);
})
  .then(value => {
    console.log(value + 'world');
  })
  .catch(error => { // 整体捕获错误的方法，可以捕获promise的错误，也可以捕获then中的错误
    console.log('Error:', error.message);
  })

六、问题四

then中接收2个函数作为参数，一个是fulfilled, 一个是rejected，这个就相当于传了1个函数，执行顺序就是doSomething, doSomethingElse, finalHandler。

五、问题三

1、doSomething和doSomethingElse是在同一个栈中。

2、doSomething完成后执行finalHanlder，doSomethingElse不在队列中。

四、问题二

1、第一个then的响应函数中并没有return，doSomethingElse返回了promise，但是这个promise并没有返回给then响应函数，这时候默认返回的是空。

2、doSomethingElse的值finalHandler也获取不到。

一、.then()里有.then()的情况：一个响应函数中又有链式调用

1、因为.then()返回的还是promise实例。

2、会等里面的.then()执行完，在执行外面的。

3、对于我们来说，此时最好将其展开，会更好读。

三、问题一

一、we have time with promise课程url:  http://fex.baidu.com/blog/2015/07/we-have-a-problem-with-promises/

二、下面4种promise的区别：doSomething和doSomethingElse返回的都是promise实例。

一、.then()

1、.then()接受两个函数作为参数，分别代表fulfilled和rejected。

2、.then()返回一个新的promise实例，所以它可以链式调用。

3、当前面的promise状态改变时，.then()根据其最终状态，选择特定的状态响应函数执行。

4、状态响应函数可以返回新的promise，或其他值，或不返回值。

5、如果返回新的promise，那么下一级.then()会在新promise状态改变之后执行。

6、如果返回其他任何值，则会立即执行下一级.then()

一、

new Promise(resolve => { // 执行1
  setTimeout(() => {
    resolve('hello');
  }, 1000);
})
  .then(value => {
    console.log(value);  // 执行2
    console.log('everyone');
    (function() { // 执行5。1、这段代码中没有返回新的值，下面一行返回的promise实际是在这个函数中返回的，不是在then的响应函数中返回的，then返回的promise实例就没有等待里面的这个promise完成。2、一直在等待执行，等最后的then返回之后，再执行这个函数。3、没有进入promise队列中，但是进程仍然是登它执行完成后才算是完成。
      return new Promise(resolve => { // 自己用自己的回调
        setTimeout(() => {
          console.log('mr');
          resolve('marry');
        }, 2000)
      });
    }());
    return false; // 执行3。1、false会直接传递到下一步，成为下一个then的value
  })
  .then(value => { // 执行4
    console.log(value + 'world'); // value = false;
  })

一、

promise队列的重要特性，在任何地方生成了一个promise队列之后，我们可以把它作为一个变量传递到其他地方，如果我们的操作是队列的状态，即先进先出的状态，就可以在后面追加任意多的then，不管之前的队列是完成还是没有完成，队列都会按照顺序完成。

二、

let promise = new Promise(resolve => {
  setTimeout(() => {
    console.log('the promise fulfilled');
    resolve('hello');
  }, 1000);
});
setTimeout(() => {
  promise.then(value => {
    console.log(value);
  })
})