ltinyho's Blog

 // 立即resolve的Promise在本轮事件循环的末尾执行的。

new Promise((resolve, reject) => {
  console.log(1);
  return resolve(2);
  console.log(3);
}).then((res) => {
  console.log(res);
});

new Promise((resolve, reject) => {
  resolve(new Promise((resolve1) => {
    setTimeout(() => {
      resolve1('resolve 1000');
    }, 1000);
  }));
}).then((res) => {
  console.log(res);
  return new Promise((resolve1) => {
    setTimeout(() => {
      resolve1('resolve 2000');
    }, 2000);
  });
}).then(res => {
  console.log(res);
});

// Promise.resolve

var pp1 = Promise.resolve({ a: '1' });
pp1.then(res => {
  console.log(res);
});
// 会调用对象的then方法，结果 先打印hahaah  在打印Promise.resolve+then,这是因为立即resolve的Promise会在本次事件循环末尾调用
var pp2 = Promise.resolve({
  a: '2', then(resolve) {
    resolve('Promise.resolve+then');
    console.log('hahaah');
  }
});
pp2.then(res => {
  console.log(res);
});

// 如果没有then方法，会直接传入then 方法的回调函数的参数

// Promise.try()  
// 实现方法
Promise.try = function (func) {
  return new this(function (resolve) {
    resolve(func());
  });
};

function MyPromise(executor) {
  var self = this;
  self.status = 'pending';
  self.data = null;
  self.onResolvedCallback = [];
  self.onRejectdCallback = [];

  function resolve(value) {
    if (value instanceof MyPromise) return value.then(resolve, reject);
    // 保证立即调用的resolve后面then方法添加的函数能够执行
    setTimeout(() => {
      if (self.status === 'pending') {
        self.status = 'fulfilled';
        self.data = value;
        for (var i = 0, len = self.onResolvedCallback.length; i < len; i++) {
          self.onResolvedCallback[i](value);
        }
      }
    }, 0);
  }

  function reject(reason) {
    setTimeout(() => {
      if (self.status === 'pending') {
        self.status = 'reject';
        self.data = reason;
        for (var i = 0, len = self.onRejectdCallback.length; i < len; i++) {
          self.onRejectdCallback[i](reason);
        }
      }
    }, 0);

  }

  try {
    executor(resolve, reject);
  } catch (e) {
    reject(e);
  }

}

function resolvePromise(promise2, x, resolve, reject) {
  var then;
  var thenCalledOrThrow = false; // 保证 resolve ,reject 只执行一次

  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected for promise!'));
  }

  if (x instanceof MyPromise) {
    if (x.status === 'pending') { //because x could resolved by a Promise Object
      x.then(function (v) {
        resolvePromise(promise2, v, resolve, reject);
      }, reject);
    } else { //but if it is resolved, it will never resolved by a Promise Object but a static value;
      x.then(resolve, reject);
    }
    return;
  }

  if ((x !== null) && ((typeof x === 'object') || (typeof x === 'function'))) {
    try {
      then = x.then; //because x.then could be a getter
      if (typeof then === 'function') {
        then.call(x, function rs(y) {
          if (thenCalledOrThrow) return;
          thenCalledOrThrow = true;
          return resolvePromise(promise2, y, resolve, reject);
        }, function rj(r) {
          if (thenCalledOrThrow) return;
          thenCalledOrThrow = true;
          return reject(r);
        });
      } else {
        resolve(x);
      }
    } catch (e) {
      if (thenCalledOrThrow) return;
      thenCalledOrThrow = true;
      return reject(e);
    }
  } else {
    resolve(x);
  }
}

MyPromise.prototype.then = function (onResolve, onRejectd) {
  var self = this;
  var promise2;
  onResolve = typeof onResolve === 'function' ? onResolve : function (value) {
    /*  解决值的穿透问题 MyPromise().then().then().then(res => {
     console.log(res);
     });*/
    return value;
  };
  onRejectd = typeof onRejectd === 'function' ? onRejectd : function (reason) {
    throw reason;
  };

  if (self.status === 'fulfilled') {
    return promise2 = new MyPromise(function (resolve, reject) {
      // 异步调用
      setTimeout(() => {
        try {
          var x = onResolve(self.data);
          resolvePromise(promise2, x, resolve, reject);
        } catch (reason) {
          reject(reason);
        }
      });
    });
  }
  if (self.status === 'reject') {
    return promise2 = new MyPromise(function (resolve, reject) {
      setTimeout(() => {
        try {
          var x = onRejectd(self.data);
          resolvePromise(promise2, x, resolve, reject);
        } catch (reason) {
          reject(reason);
        }
      });
    });
  }

  // 当pending时，不能确定调用 onResolve,还是 onRejectd
  if (self.status === 'pending') {
    return promise2 = new MyPromise(function (resolve, reject) {
      self.onResolvedCallback.push(function (value) {
        try {
          var x = onResolve(value);
          resolvePromise(promise2, x, resolve, reject);
        } catch (r) {
          reject(r);
        }
      });

      self.onRejectdCallback.push(function (reason) {
        try {
          var x = onRejectd(reason);
          resolvePromise(promise2, x, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });
    });
  }
};

MyPromise.prototype.catch = function (onRejectd) {
  return this.then(null, onRejectd);
};

// 将b的方法复制到a
function merge (a, b){
  if (a && b) {
    for (var key in b) {
      a[key] = b[key];
    }
  }
  return a;
};


// 链式调用
function My() {
  this.sum = 0;
}

My.prototype.add = function (a, b) {
  this.sum = a + b;
  return this;
};

My.prototype.sub = function (b, c) {
  this.sum -= b + c;
  return this;
};
var my           = new My();
console.log(my.add(1, 6).sub(3, 4).sum);


// 不调用new 实例化

function Person(options) {
  if(!(this instanceof Person)){
    return new Person(options)
  }
}

const express = require('express');
const app     = express();

app.use(function(req,res,next) {
  next()
})

var http = require('http');

function express() {
  var stack = []; // 中间件函数数组

  function app(req, res) {
    var i = 0;

    function next() {
      var handler = stack[i++]; 

      if (!handler) {
        return;
      }
      // 中间件函数调用,如果调用了next,相当于递归调用，下一个中间件函数就会执行
      handler(req, res, next);

    }

    next();
  }
  
  // 增加中间件
  app.use = function (middleware) {
    stack.push(middleware);
  };

  return app;
}

var app = express();
http.createServer(app).listen(3000);

app.use(function (req, res, next) {
  console.log('start1');
  next();
  console.log('next1');
});
app.use(function (req, res, next) {
  console.log('start2');
  next();
  console.log('next2');
});
app.use(function (req, res) {
  console.log('start3');
});
// 打印结果
// start1
// start2
// start3
// next2
// next1

setTimeout(()=>{
  console.log('start');
},0)
for (let i = 0; i < 100000; i++) {
  console.log(i);
}

console.log(1);
setTimeout(() => {
  console.log(2);
}, 0);
console.log(4);
process.nextTick(() => {
  console.log(5);
  process.nextTick(() => {
    console.log(6);
  });
});
setTimeout(() => {
  console.log(7);
}, 0);
setImmediate(() => {
  console.log(8);
}, 0);