promise

// resolve()会触发then要领第一个回调, reject()会触发then要领第二个回调或catch要领
let p = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (Math.random() > 0.5) {
      resolve("胜利操纵");
    } else {
      reject("失利操纵");
    }
  });
});

p.then(
  res => {
    console.log(res);
  },
  err => {
    console.log(err);
  }
);

generator

// yield会停止fn()的实行,须要next()要领触发fn()向下实行
function* fn(x) {
  yield x[0];
  yield x[1];
  yield x[2];
}

let res;
let t = fn([1, 2, 3]);
do {
  res = t.next();
  console.log(res);
} while (!res.done);

// 实行效果
// { value: 1, done: false }
// { value: 2, done: false }
// { value: 3, done: false }
// { value: undefined, done: true }

完成promise

// Promise的参数是一个函数async,async()有resolve和reject两个参数
function Promise(async) {
  // 回调函数中this会指向window,须要保留才会指向Promise实例对象
  let _this = this;
  // Promise三种状况,分别为pending,resolved,rejected.状况只能从pending变成resolved或许rejected
  _this.status = "pending";
  _this.val = undefined;
  // 胜利回调要领鸠合
  _this.onResolvedCallbacks = [];
  // 失利回调要领鸠合
  _this.onRejectedCallbacks = [];
  // 触发resolve()要领异步状况改变成胜利, 将会实行胜利回调鸠合中的要领
  function resolve(val) {
    if (_this.status === "pending") {
      _this.status = "resolved";
      _this.val = val;
      _this.onResolvedCallbacks.forEach(item => item(val));
    }
  }
  // 触发reject()要领异步状况改变成失利, 将会实行失利回调鸠合中的要领
  function reject(val) {
    if (_this.status === "pending") {
      _this.status = "rejected";
      _this.val = val;
      _this.onRejectedCallbacks.forEach(item => item(val));
    }
  }
  // 非常捕捉
  try {
    async(resolve, reject);
  } catch (err) {
    reject(err);
  }
}
// then要领有两个参数, 第一个异步胜利后实行的函数, 第二个是异步出非常后实行的函数
Promise.prototype.then = function(resolved, rejected) {
  let _this = this;
  if (_this.status === "pending") {
    // 将一切then要实行的要领push到回调函数鸠合中,在状况改成resolved实行个中的要领
    _this.onResolvedCallbacks.push(resolved);
    // 将一切then要实行的要领push到回调函数鸠合中,在状况改成rejected实行个中的要领
    _this.onRejectedCallbacks.push(rejected);
  }
  if (_this.status === "resolved") {
    resolved(_this.val);
  }
  if (_this.status === "rejected") {
    rejected(_this.val);
  }
};

完成generator

// 生成器
function fn(val) {
  let i = 0;
  return {
    next() {
      let done = i === val.length;
      let value = val[i++];
      return {
        value,
        done
      };
    }
  };
}

// 迭代器
let it = fn([1, 2, 3]);
let result;
do {
  result = it.next();
  console.log(result);
} while (!result.done);