weixin_34077371
weixin_34077371

ES6-Promise 源码阅读

前言

此次阅读的 promise 实现是 ES6-Promise ，是 promise 的众多实现中较为完善的一个例子，从入口文件 lib/es6-promise/promise.js 开始阅读，可以看到 Promise 定义有如下的静态方法

Promise.all

Promise.race

Promise.resolve

Promise.reject

以及挂载在 Promise.protoype 上的方法

Promise.prototype.then

Promise.prototype.catch

Promise.prototype.finally

接下来会对其核心代码进行解读。

Promise的三种状态

Promise规范中定义了promise的三种状态，而且promise的状态更新只能是以下两种情况，一旦状态发生改变之后就不能再修改：

  • PENDING -> FULFILLED
  • PENDING -> REJECTED

ES6-Promise 内部中的定义如下：

// void 运算符 对表达式进行求值,结果都返回 undefined
// 可以防止undefined被重写，如：const undefined = xxx
const PENDING = void 0; // undefined
const FULFILLED = 1;
const REJECTED = 2;
复制代码

Promise的使用例子

我们来看一个Promise的使用例子，传入一个resolver函数，初始化一个promise实例。resolver函数会被立即执行，并且可以使用promise内部传入的两个参数 resolve 和 reject ，resolve 和 reject都是函数，接收一个参数， value 或者 reason，在resolver函数内部调用 resolve 或者 reject ，都会更新promise的状态 。

具体调用例子如：

const promise = new Promise(function(resolve, reject) {
  if (/* 异步操作成功 */){
    // 更新状态为 fulfilled 并缓存 value
    resolve(value);
  } else {
    // 更新状态为 rejected  并缓存 reason
    reject(error);
  }
});
复制代码

为了响应promise不同的状态(fulfilled 或 rejected)，可以通过实例的 then 方法绑定回调函数：

promise.then( 
    // resolver 中 resolve 的 value
    value => { /* pending -> fulfilled 时调用 */
    },
    // resolver 中 reject 的 resaon
    reason => { /* pending -> rejected 时调用 */
    }
)
复制代码

这样就完成了一个promise的基本使用。

Promise的构造函数

由上面的基本调用开始，先看看promise的构造方法：

class Promise {

  constructor(resolver) {

    // export const PROMISE_ID = Math.random().toString(36).substring(2); 
    // nextId() 返回一个自增的闭包变量
    // Promise实例的唯一标识
    this[PROMISE_ID] = nextId();

    // 初始化变量
    // _result 缓存 resolve 时的 value 或者 reject 时的 reason
    // _state  缓存 promise 的 当前状态 初始化为 pending
    this._result = this._state = undefined;
    // 订阅序列
    this._subscribers = [];

    // noop = ()=>{}  内部定义的一个空函数
    // 内部调用时： new Promise(noop) 不会经过下面的初始化过程

    // 外部调用时： 对传入参数进行检查
    if (noop !== resolver) {
      // 条件1：resolver 必须要是一个函数
      typeof resolver !== 'function' && needsResolver();
      // 条件2: 必须通过 new Promise() 初始化实例
      this instanceof Promise ? initializePromise(this, resolver) : needsNew();
      // 符合以上条件的进行初始化
      // initializePromise() 函数
    }
  }
复制代码

可以看到promise的构造方法完成了以下的工作：

  • 初始化变量

    [PROMISE_ID] : 该实例独一无二的ID

    result: 缓存value或者reason

    subscribers: 订阅promise状态变化的序列（后面会讲到）

  • 对入参 resolver 进行判断

    resolver === noop noop是内部定义的一个空函数，此时 promise 会初始化结束。

    resolver !==  noop resolver 必须是函数，同时必须是通过 new Promise() 初始化实例。满足以上两个条件的，就会调用 initializePromise ，对实例进一步初始化，其代码如下：

function initializePromise(promise, resolver) {
  try {
    // 立即执行 resolver函数 
    // 传入包装好的参数
    resolver(function resolvePromise(value) {
      resolve(promise, value);
    }, function rejectPromise(reason) {
      reject(promise, reason);
    });
  } catch (e) {
    // 代码发生异常 
    // 则直接更新 promise 的状态为 rejected
    reject(promise, e);
  }
}
复制代码

可以看到，resolver函数被立即执行了，而且在 resolver 函数中调用的 resolve 和 reject 就是 resolvePromise 和 rejectPromise 函数，这也是promise提供给resolver的两个入参，它们包装了内部实现的 resolve 和 reject 函数。

再来看看内部的 resolve和 reject 是如何对promise状态进行更新的。

内部的 reject 函数

reject函数较为简单：

/** 
 * pending => rejected
 */
function reject(promise, reason) {
  // 状态一旦改变就不可逆转
  if (promise._state !== PENDING) {
    return;
  }
  // 缓存处理结果 更新promise状态
  promise._state = REJECTED;
  promise._result = reason;
  // 注：asap 函数暂不详细解释 后面源码中多次用到 
  // asap(func,param) 可以理解为立即执行 func(param)
  // promise 的状态发生了改变 通知订阅者
  asap(publishRejection, promise);
}
复制代码

promise的状态更新为rejected后，会通过publishRejection向订阅序列发出通知，publishRejection函数代码如下，具体的publish函数封装了如何向订阅序列发出通知的逻辑，后续会说到：

function publishRejection(promise) {
  // ???
  // onError 好像一直都是null啊
  if (promise._onerror) {
    promise._onerror(promise._result);
  }
  // promise的状态发生了改变
  // 向订阅序列发出通知
  publish(promise);
}

复制代码

内部的 resolve 函数

resolve 则会对 value 的类型进行判断，情况有以下：

  • value是实例本身，更新promise的状态为 rejected，不允许resolve本身
  • value是对象或者函数，调用 handleMaybeThenable()方法进行特殊处理
  • 其他情况，调用 fulfill 方法更新状态

具体代码逻辑如下：

function resolve(promise, value) {
  if (promise === value) {
    // 1. 不允许 value 是 promise实例本身
    // 更新为 rejected 状态 
    reject(promise, selfFulfillment());
  } else if (objectOrFunction(value)) {
    // 2. value是对象或者函数 
    handleMaybeThenable(promise, value, getThen(value));
  } else {
    // 3. 其他数据类型
    fulfill(promise, value);
  }
}
复制代码

先看看 fulfill 方法，方法不难理解，就是更新promise的状态为 fulfilled 同时向订阅序列发出通知。

 /**
 * pedding => fulfilled
 */
function fulfill(promise, value) {
  // promise状态不可逆
  if (promise._state !== PENDING) {
    return;
  }
  // 缓存处理结果 修改promise状态
  promise._result = value;
  promise._state = FULFILLED;
  // promise的状态发生了改变
  // 向订阅序列发出通知
  if (promise._subscribers.length !== 0) { 
    asap(publish, promise);
  }
}
复制代码

再来看看当 resolve 函数传入的value是对象或者函数，调用特殊处理的 handleMaybeThenable(promise,value,getThen(value))方法。其中getThen方法接收一个参数promise，用于尝试获取promise的then属性，会捕获错误，返回包装的错误对象。函数内部又对value进行了进一步划分。

handleMaybeThenable的具体代码如下：

function handleMaybeThenable(promise, maybeThenable, then) {
  if (
    maybeThenable.constructor === promise.constructor &&
    then === originalThen &&
    maybeThenable.constructor.resolve === originalResolve) {
    // 1. resolve的值是一个 promise 实例 
    // 即通过 new Promise() 新建的实例
    handleOwnThenable(promise, maybeThenable);
  } else {
    // 2. 获取 value 的 then 属性时发生错误
    // 更新 promise 的 状态为 rejected
    if (then === TRY_CATCH_ERROR) {
      reject(promise, TRY_CATCH_ERROR.error);
      TRY_CATCH_ERROR.error = null;
    } else if (then === undefined) {
      // 3. 虽然 resolve的值是 函数或者对象 但不存在 then 属性
      // 按照普通数据类型进行处理
      fulfill(promise, maybeThenable);
    } else if (isFunction(then)) {      
      // 4. resolve的值是一个 thenable 对象, 具有then属性,并且为函数
      handleForeignThenable(promise, maybeThenable, then);
    } else {
      // 5. then 是其他数据类型 直接进行处理
      fulfill(promise, maybeThenable);
    }
  }
}
复制代码

重新总结一下 resolve 的值分为以下情况：

  1. value为 promise 实例，调用handleOwnThenable方法进行处理
  2. value为 thenable 实例（一个具有then方法的对象），调用handleForeThenable方法进行处理
  3. 其他情况，直接调用 fulfill 方法处理值

第一种情况中，handleOwnThenable 具体代码如下：

/**
 * resolve 的值 value 是一个 promise 实例 
 * @param promise 当前的promise
 * @param thenable value
 */
function handleOwnThenable(promise, thenable) {
  // 检查 thenable 状态
  if (thenable._state === FULFILLED) {
    // FULFILLED 状态 
    // 使用 thenable 内部缓存的处理结果 
    // 作为 value 调用 fulfill 更新状态
    fulfill(promise, thenable._result);
  } else if (thenable._state === REJECTED) {
    // REJECTED  状态 
    // 使用 thenable 内部缓存的处理结果 
    // 作为 reason 调用 reject 更新状态
    reject(promise, thenable._result);
  } else {
    // pending 状态, 对 thenable 增加监听
    // 当 thenable 的状态改变时 
    // 用其结果缓存 更新 promise 的状态
    subscribe(thenable, undefined,
      value => resolve(promise, value),
      reason => reject(promise, reason))
  }
}
复制代码

也就是说，当resolve的value是一个promise时，原封不动地返回这个promise。

第二种情况，当为一个具有then属性并且then为函数的对象时：

// let thenable = {
//   then: function(resolve, reject) {
//     resolve(42);
//   }
// };
function handleForeignThenable(promise, thenable, then) {
  asap(promise => {
    // 用一个 sealed 保证只能调用一次    
    var sealed = false;

    // tryThen 方法
    // 1. 以 thenable 作为执行上下文 
    // 2. 传入 (value=>{} , reason=>{}) 参数
    // 3. 执行 then 函数
    // 
    var error = tryThen(then, thenable, value => {
      if (sealed) {
        return;
      }
      sealed = true;

      if (thenable !== value) {
        // 如果 resolve 的 value 不是原来的thenale对象
        // 进一步对value进行处理（有可能又是一个promise实例或者thenable对象，或者其他情况...）
        resolve(promise, value);
      } else {
        // 如果 resolve 的 value 还是原来的thenale对象
        // 则直接 fulfill 这个对象
        // 不再进一步通过 resolve 避免死循环 
        fulfill(promise, value);
      }
    }, reason => {
      if (sealed) {
        return;
      }
      sealed = true;
      // then 方法 reject（‘xx'）
      reject(promise, reason);
    }, 'Settle: ' + (promise._label || ' unknown promise'));


    // if error
    // rejected 状态
    if (!sealed && error) {
      sealed = true;
      reject(promise, error);
    }
  }, promise);
}

复制代码

也就是说，当resolve的值是一个thenable对象时，会执行其then方法，根据then方法中调用入参resolve或者reject时传入的value或reason来对promise的状态进行更新。

subscribe 订阅机制

之前有提到promise的订阅，在Promise初始化的时候，声明了一个内部变量，用来存储对promise的订阅序列。

// 订阅序列
this._subscribers = [];
复制代码

然后可以调用 subscribe 函数注册监听:

/**
 * @param {promise} parent         被订阅状态变化的Promise
 * @param {promise} child          订阅状态变化的Promise（可为undefined）
 * @param {function} onFulfillment 状态变化为 fulfilled 的订阅函数 
 * @param {function} onRejection   状态变化为 rejected  的订阅函数
 */
function subscribe(parent, child, onFulfillment, onRejection) {
  let { _subscribers  } = parent;
  let { length } = _subscribers;
  parent._onerror = null;
  // 每调用一次subscribe函数 订阅序列会增加三个元素
  _subscribers[length] = child;
  _subscribers[length + FULFILLED] = onFulfillment;
  _subscribers[length + REJECTED] = onRejection;

  // 有可能是在 parent 状态更新之后增加的订阅
  // 此时的订阅序列被清空 状态不再发生变化 则直接发出通知
  if (length === 0 && parent._state) {
    asap(publish, parent);
  }
}
复制代码

可以看到，对一个promise订阅其状态更新时，会在其订阅序列增加三个参数，子promise(可为空)，状态变为fulfilled时的回调，变为rejected时的回调。当一个promise状态更新之后，就会触发publish函数，发布修改，publish的具体代码逻辑如下：

/**
 * Promise状态更新 发出通知
 * @param {Promise} promise 
 */
function publish(promise) {
  // 所有订阅序列
  let subscribers = promise._subscribers;
  // promise的状态
  let settled = promise._state;
  // 订阅序列为空
  if (subscribers.length === 0) {
    return;
  } 
  /**
   * child:    订阅状态变化的promise
   * callback: 回调函数
   * detail:   value或者reason缓存
   */
  let child, callback,
    detail = promise._result; 
  // 每三个元素为一个订阅单位
  // 格式如： child + fufilled + rejected
  for (let i = 0; i < subscribers.length; i += 3) {
    // child === [object Promise]
    child = subscribers[i];
    // 根据 promsie 的状态获取相应的回调函数
    callback = subscribers[i + settled];
    // 情况1: 存在promise实例订阅
    if (child) {
      invokeCallback(settled, child, callback, detail);
    } else {
      // 情况2: 触发响应的回调函数
      callback(detail);
    }
  }
  // 清空监听数组 
    promise._subscribers.length = 0;
}
复制代码

每三个元素为一个单位，publish函数会依次判断订阅者：

  1. 订阅存在子promise，存在则再调用 invokeCallback 函数
  2. 订阅不存在，直接传入结果缓存value或者reason 调用相应的回调函数

第一种情况下：

/**
 * settled  :  被监听promise的状态
 * promise  :  订阅监听的promise
 * callback :  fullfled | rejected 
 * detial   :  value | reason
 */
function invokeCallback(settled, promise, callback, detail) {

  let hasCallback = isFunction(callback),
    value, error, succeeded, failed;

  if (hasCallback) {
    // 尝试执行回调函数
    // 发生错误时 则返回 TRY_CATCH_ERROR 对象
    value = tryCatch(callback, detail);

    // 执行cb函数时出错
    if (value === TRY_CATCH_ERROR) {
      // 获取error的值
      failed = true;
      error = value.error;
      value.error = null;
    } else {
      // 设置状态
      succeeded = true;
    }
    // 不允许回调函数返回了原有的promise实例
    if (promise === value) {
      reject(promise, cannotReturnOwn());
      return;
    }
  } else {
    // 不存在回调函数
    value = detail;
    succeeded = true;
  }

  // 更新 promise 的状态
  if (promise._state !== PENDING) {
    // noop
  } else if (hasCallback && succeeded) {   // 回调函数存在的情况
    // value 是回调函数的返回值
    resolve(promise, value);
  } else if (failed) {
   // error 是调用回调函数的错误时的原因
    reject(promise, error);
  } else if (settled === FULFILLED) {   // 回调函数不存在的情况
    // 直接使用父promise的value
    fulfill(promise, value);
  } else if (settled === REJECTED) {
   
    reject(promise, value);
  }
}
复制代码

总结一下，订阅一个promise 的状态变化，主要有两种情况：

  1. 一种是仅传入了回调函数，不存在子promise订阅，此时会promise的状态一旦变化，就会传入value或者reason，调用相应的回调函数。
  2. 另一种是订阅存在子promise，此时promise的状态一旦变化，又会分成回调函数有无两种情况， 有回调函数的话，传入value或者reason到相应的回调函数执行，回调函数的返回值作为结果缓存到子promise。 无回调函数的话，就直接使用value或者reason作为结果缓存。

Promise.prototype.then

方法传入两个函数参数，当promise的状态更新后，调用相应的回调函数，同时返回一个新的promise。

export default function then(onFulfillment, onRejection) {
  // 当前的 promise
  const parent = this;

  // 新建一个 promise
  // new pormise(()=>{})
  // [!] 通过此方式创建的 promise 不会进行 initializePromise 方法初始化
  // initializePromise 会执行传入的函数 空函数不需要执行 只需要初始化相关变量
  const child = new this.constructor(noop);

  // 仅初始化状态变量
  // promise[PROMISE_ID] = id++;
  // promise._state = undefined;
  // promise._result = undefined;
  // promise._subscribers = [];
  if (child[PROMISE_ID] === undefined) {
    makePromise(child);
  }

  // 获取当前 promise 的状态
  const { _state } = parent;

  // 当前的 promise 为 fullfied / rejected 
  // 直接处理
  if (_state) {
    // state = fullfied   ===> onFulfillment
    // state = rejected   ===> onRejection
    // 获取与状态对应的处理函数
    const callback = arguments[_state - 1];
    // 传入结果立即执行
    // 更新新建promise的状态
    asap(() => invokeCallback(_state, child, callback, parent._result));
  } else {
    // 当前的 promise 为 pending 
    // 将新建的 promise 绑定在 当前 promise 上
    // 当前的 pormise 状态改变之后 同步新建的 promise 状态
    subscribe(parent, child, onFulfillment, onRejection);
  }  
  // 返回新建的 promise
  return child;
}
复制代码

总结一下，首先 then 方法会返回一个新的promise，其状态和原来的 promise 同步，结果缓存则有以下的两种情况。

  1. 如果设置了回调函数（onFulfillment或onRejection)，会将原有promise的value或者reason传入回调函数，回调函数的返回结果缓存到新的promise实例中。
  2. 如果没有设置回调函数，会将原有的promise的value或者reason直接缓存给新的promise实例。

也就是下面的两种例子：

// 1. 第一种情况
let promise = new Promise((resolve,reject)=>{
    resolve('OK')
})
let child1 = promise.then((value)=>{
    return value + 'child1'
},()=>{})
// 此时child1的结果缓存是 'OKchild1'

// 2. 第二种情况
let child2 = promise.then().then().then().then().then( value =>{
    console.log(value) // 结果缓存还是最开始那个promise 也就是 'OK'
})
复制代码

Promise.protoype.catch

catch方法是then方法的语法糖，通常我们会这样设置回调：

let promise = new Promise((resolve,reject)=>{

    if(/* 异步OK*/){
        resolve('OK')
    }else{
        reject(new Error('something wrong'))
    }
}).then(value=>{
    // xxx
}).catch(err=>{
    // xxx
})

// 但实际上等同于
promise.then( value=>{},err=>{})
复制代码

其代码也很简单：

  /**
   * Promise.prototype.catch
   */
  catch (onRejection) {
    return this.then(null, onRejection);
  }
复制代码

Promise.prototype.finally

finally方法用于无论状态发生了什么改变（fulfilled或者rejected）都要执行的操作，来自ES2018的标准。 注意：代码中的Promise.resolve 可先看看下面关于此方法的解读。

  /**
   * Promise.prototype.finally
   */
  finally(callback) {
    // 当前 promise
    let promise = this;
    // Promise
    let constructor = promise.constructor;

    if (isFunction(callback)) {
      // Promise.resolve 包裹成一个promise,再调用其 then 方法返回一个新的promise
      return promise.then(
        // pending -> fulfilled
        value => constructor.resolve(callback()).then(() => value),
        // pending -> rejected
        reason => constructor.resolve(callback()).then(() => {
          throw reason;
        }));
    }
    // callback 不是函数
    return promise.then(callback, callback);
  }
复制代码

Promise.resolve

方法接收一个参数，返回一个Promise，可接受的输入情况有：


// 1. 传入的是一个 promise实例 
// 直接返回这个实例
Promise.resolve(promise);

// 2. 传入的是一个 thenable实例
// 执行 thenable  的 then 方法 
// 根据 方法内部 resolve 或者 reject 得到的 value 或者 resaon
// 设置为 promise 的状态和结果缓存
let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};
Promise.resolve(theanable);

// 3. 普通数据值 返回一个 fulfilled 状态的 promise
// 结果缓存为其 value
Promise.resolve(value);
复制代码

具体代码实现如下


export default function resolve(object) {
  // Promise.resolve = Resolve;
  // [ Promise ] 
  let Constructor = this;

  // 1. 传入一个 promise 实例
  // 则直接返回这个promise
  if (object 
    && typeof object === 'object' 
    && object.constructor === Constructor) {
    return object;
  }

  // 新建一个空的 promise
  // 不会经过 initialPromise() 方法的初始化
  let promise = new Constructor(noop);

  // 2. 可能是 thenable 对象
  //    或者是其他普通值
  _resolve(promise, object);
  // 返回 promise
  return promise;
}

复制代码

Promise.reject

方法较为简单，接收一个参数reason，直接返回一个状态为rejected的promise实例。

export default function reject(reason) {
  // Promise.reject
  // Promise
  let Constructor = this;
  // new Promise(()=>{})
  // 不会经过 initialPromise() 方法的初始化
  let promise = new Constructor(noop);
  // pending -> rejected
  _reject(promise, reason);
  // 返回promise
  return promise;
}
复制代码

Promise.race

方法传入一个 数组，一般传入多个promise，包装成一个promise返回，这个promise的状态和传入的多个promise中最先更新状态那一个promise同步。

export default function race(entries) {
  // Promise
  let Constructor = this;

  if (!isArray(entries)) {
    // 不是数组 返回一个状态为rejected的Promise实例
    return new Constructor((_, reject) => reject(new TypeError('You must pass an array to race.')));
  } else {
    // 返回一个新的 Promise 实例 
    return new Constructor((resolve, reject) => {
      let length = entries.length;
      for (let i = 0; i < length; i++) {
        // Promise.resolve(entries[i]).then(resolve,reject)
        // 遍历所有元素 用 Promise.resolve() 包装成 Promise实例
        // 最先的一个 Promise 更新了状态后 都会同步外层 Promise 
        Constructor.resolve(entries[i]).then(resolve, reject);
      }
    });
  }
}
复制代码

Promise.all

方法也是传入一个数组，一般传入多个promise，包装成一个promise返回，其状态有以下两种情况： 1 : 所有promise的状态都变成fulfilled时，返回的promise状态为fulfilled,结果是所有promise返回值的数组 2 : 有一个promise的状态率先变为rejected，返回的promise状态为rejected，结果是这个promise rejected的返回值

代码如下：

// Promise.all
export default function all(entries) {
  // 初始化一个 Enumerator 实例 返回其属性 promise
  return new Enumerator(this, entries).promise;
}
复制代码

Enumerator的具体代码如下：


export default class Enumerator {
  constructor(Constructor, input) {

    // Promise
    this._instanceConstructor = Constructor;

    // 新建一个空的promise 不会经过 initialPromise() 方法的初始化
    // Promise.all() 最后返回这个值
    this.promise = new Constructor(noop);

    // 初始化
    // promise[PROMISE_ID] = id++;
    // promise._state = undefined;
    // promise._result = undefined;
    // promise._subscribers = [];
    if (!this.promise[PROMISE_ID]) {
      makePromise(this.promise);
    }

    if (isArray(input)) {
      // 总长度
      this.length = input.length;
      // 剩余长度
      this._remaining = input.length;
      // 存放结果
      this._result = new Array(this.length);

      if (this.length === 0) {
        // 空数组
        // 返回一个状态为 fulfilled 的promise
        fulfill(this.promise, this._result);
      } else {
        this.length = this.length || 0;
        // 执行 _enumerate
        this._enumerate(input);

        if (this._remaining === 0) {
          // 剩余长度为0
          // 返回一个状态为 fulfilled 的promise
          fulfill(this.promise, this._result);
        }
      }
    } else {
      // 入参不是数组
      // 返回一个状态为r ejected 的promise
      reject(this.promise, validationError());
    }
  }
  _enumerate(input) {
    // 遍历执行所有状态为 pending 的 promise
    for (let i = 0; this._state === PENDING && i < input.length; i++) {
      this._eachEntry(input[i], i);
    }
  }

  _eachEntry(entry, i) {
    // Promise.all() 方法 传入的是 Promise 
    let c = this._instanceConstructor;
    //                     Promise.resolve
    let { resolve } = c;

    // Promise.resolve = Promise.resolve
    if (resolve === originalResolve) {
     
      // 尝试获取 entry 的 then 属性
      let then = getThen(entry);

      if (then === originalThen 
        && entry._state !== PENDING) {
        // then  === Promise.prototype.then
        // 情况1： entry是promise实例 同时 状态不为 pending        
        this._settledAt(entry._state, i, entry._result);
      } else if (typeof then !== 'function') {
        // then 不为函数 为普通值
        // 直接设置
        this._remaining--;
        this._result[i] = entry;
      } else if (c === Promise) {// true 在Promise.all() 中此处一直成立        
        let promise = new c(noop);
        // then 是一个函数      
        // 对 then 进行进一步检查 如果是一个 thenable 对象 
        // let thenable = {
        //       then: function(resolve,reject)=>{ resolve('66')} 
        // }
        // 则会执行 then 方法 获取相应的值后设置 promise 的状态
        handleMaybeThenable(promise, entry, then);
        // 设置监听
        this._willSettleAt(promise, i);
      } else {
        // 情况2： entry是promise实例 状态为 pending 
        // 绑定监听 待entry状态改变之后 再设置相应的值 
        this._willSettleAt(new c(resolve => resolve(entry)), i);
      }
    } else {
      // 其他情况  这里不作考虑  
      // 因为Promise.all 传入的是Promise  
      this._willSettleAt(resolve(entry), i);
    }
  }

  _settledAt(state, i, value) {
    let {
      promise
    } = this;

    if (promise._state === PENDING) {
      // 又完成了一个 Promise
      this._remaining--;

      if (state === REJECTED) {
        // 一旦有一个promise实例状态变为rejected
        // 更新状态为rejected
        reject(promise, value);
      } else {// fulfilled
        // 更新值
        this._result[i] = value;
      }
    }

    if (this._remaining === 0) {
      // 所有的元素都已经变为 fulfilled
      // 同步返回promise的状态
      fulfill(promise, this._result);
    }
  }

  _willSettleAt(promise, i) {
    let enumerator = this;
    // 绑定监听
    // promise的状态改变后 调用相应的函数
    subscribe(
      promise, undefined,
      value => enumerator._settledAt(FULFILLED, i, value),
      reason => enumerator._settledAt(REJECTED, i, reason)
    );
  }
};
复制代码

以上便是es6-promise核心代码的阅读。

最后

原文地址：链接

ES6-Promise仓库地址： 链接

转载于:https://juejin.im/post/5bac9e7ce51d450e827b5005

你可能感兴趣的:(ES6-Promise 源码阅读)

  • 【Redis】一文带你快速入门Redis源码阅读 林炏 Redis源码阅读redis数据库缓存
    Redis是一个广泛使用的开源内存数据结构存储库，可用作数据库、缓存和消息代理。近年来，Redis变得越来越流行，对于开发人员来说，了解其整体架构非常重要。本文将为您提供一份全面的指南，介绍如何快速理解Redis源代码的整体架构。我们将概述Redis源代码及其数据结构、命令处理和内存管理。Redis源码的整体架构Redis的整体架构包括以下几个模块：事件处理模块：Redis使用事件驱动模型，事件处
  • Java多线程——ReentrantReadWriteLock源码阅读 6bdd3dcddb17
    之前讲了《AQS源码阅读》和《ReentrantLock源码阅读》，本次将延续阅读下ReentrantReadWriteLock，建议没看过之前两篇文章的，先大概了解下，有些内容会基于之前的基础上阅读。这个并不是ReentrantLock简单的升级，而是落地场景的优化，我们来详细了解下吧。背景JUC包里面已经有一个ReentrantLock了，为何还需要一个ReentrantReadWriteLo
  • ffmpeg音视频开发实战6，flutter开源项目商业化 2401_84408734 程序员ffmpegflutter开源
    正文Java集合：使用场景、源码阅读GC机制虚拟机对象内存分配要学好Android，必须要有扎实的Java基础（当然，现在还有Kotlin）。这里只列出了四点，但Java的体系非常庞大，重难点当然不只这些，列出来的是在实际项目和面试中常用或常见的。Android常用/重要类ActivityHandlerHandlerThreadAsyncTaskBinderAndroid这几个类在编程时是比较高频
  • 【iOS】源码阅读(六)——方法交换 名字不要太长 像我这样就好 ioscocoamacos开发语言objective-c
    文章目录方法交换什么是Method-Swizzling方法交换核心API**1.获取方法对象****2.添加/替换方法实现****3.交换方法实现****4.获取方法信息****5.修改方法实现****使用示例：完整的Method-Swizzling流程****注意事项**使用方法交换注意事项线程安全方法交换的影响范围方法交换什么是Method-Swizzling  Method-Swizzlin
  • 【Java源码阅读系列56】深度解读Java Constructor 类源码 ·云扬· 源码阅读系列之Javajava开发语言
    Java反射机制中，Constructor类是操作构造方法的核心入口。它封装了构造方法的元信息（如参数类型、修饰符）和实例化逻辑，是框架（如Spring、MyBatis）动态创建对象的关键工具。本文基于JDK1.8源码，从类结构、关键方法、设计模式、典型场景等维度，深入解析Constructor类的实现逻辑与设计思想。一、类结构与核心定位1.1类定义与继承关系Constructor类被声明为pub
  • vue 不同版本下v-model的底层实现
    下面把「底层实现」和「差异」拆开讲，先给代码级流程，再给一个对照表，面试或源码阅读都能直接用。一、底层实现（编译→运行时的两条链路）Vue2•编译阶段：模板编译器遇到v-model，根据元素类型生成不同的AST指令对象。•运行时指令：src/platforms/web/compiler/directives/model.js里的model()函数把指令对象转成原生标签addProp(el,'val
  • 第二十九章 Spring之假如让你来写事务——状态篇
    Spring源码阅读目录第一部分——IOC篇第一章Spring之最熟悉的陌生人——IOC第二章Spring之假如让你来写IOC容器——加载资源篇第三章Spring之假如让你来写IOC容器——解析配置文件篇第四章Spring之假如让你来写IOC容器——XML配置文件篇第五章Spring之假如让你来写IOC容器——BeanFactory和FactoryBean第六章Spring之假如让你来写IOC容器
  • 【Java源码阅读系列44】深度解读Java NIO ByteBuffer 源码 ·云扬· 源码阅读系列之Javajavanio开发语言
    JavaNIO（NewInput/Output）中的ByteBuffer是Buffer抽象类的具体子类，专门用于处理字节数据的高效读写。作为NIO的核心组件，ByteBuffer支持堆内存（Heap）和直接内存（Direct）两种存储方式，广泛应用于网络通信、文件IO等场景。本文将结合源码，深入解析ByteBuffer的核心机制、关键方法及设计模式的应用。一、ByteBuffer的核心特性与存储方
  • 【Java源码阅读系列33】深度解读Java FilterReader 源码 ·云扬· 源码阅读系列之Javajava开发语言
    FilterReader是JavaI/O体系中字符输入流的核心抽象类，位于java.io包下。它与FilterWriter（字符输出流）、FilterOutputStream（字节输出流）共同构成JavaI/O的「装饰器模式」基础框架，旨在通过动态组合扩展字符输入流的功能。本文将结合源码，从类结构、设计模式、核心方法实现等角度，深入解析FilterReader的设计思想。一、类定义与核心结构1.类
  • 【Java 源码阅读系列31】深度解读Java FilterOutputStream 源码
    FilterOutputStream是JavaI/O体系中一个关键的抽象类，位于java.io包下。它的核心作用是为所有「过滤输出流」提供基础实现，通过装饰器模式（DecoratorPattern）动态扩展输出流的功能。本文将从源码结构、设计模式、核心方法实现等角度，深入解析这个类的设计思想。一、类定义与核心结构1.类继承关系publicclassFilterOutputStreamextends
  • 【Java 源码阅读系列32】深度解读Java FilterWriter 源码 ·云扬· 源码阅读系列之Javajava开发语言
    FilterWriter是JavaI/O体系中字符输出流的核心抽象类，位于java.io包下。它与字节流体系中的FilterOutputStream形成对称设计，共同构成JavaI/O「装饰器模式」的基础框架。本文将结合源码，从类结构、设计模式、核心方法实现等角度，深入解析FilterWriter的设计思想。一、类定义与核心结构1.类继承关系与核心成员publicabstractclassFilt
  • 【React 源码阅读】Scheduler
    1背景React在18版本引入了Concurrent模式，而这个模式则是用Scheduler这个包实现的。在这篇文章里，我们来看下它的实现原理是什么。2前置知识在正式阅读源码之前，我们还是有一些前置的知识需要了解的，分别是：小顶堆：Scheduler内用来进行优先级排序的数据结构浏览器事件循环机制：Scheduler实现的底层原理2.1小顶堆堆是一棵完全二叉树，即除了最后一层外，所有层都完全填满，
  • 【Java源码阅读系列28】深度解读Java CompletableFuture 源码 ·云扬· 源码阅读系列之Javajava开发语言
    Java8引入的CompletableFuture是并发编程中处理异步任务的核心工具，它通过实现Future和CompletionStage接口，提供了链式调用、任务组合、异常处理等强大功能。本文将结合源码，深入解析其核心机制、设计模式，并给出常见使用场景与代码示例。一、核心架构：状态管理与依赖任务CompletableFuture的核心目标是将异步任务的完成状态与依赖操作解耦，允许通过链式调用定
  • 【Java源码阅读系列27】深度解读Java ThreadPoolExecutor 源码 ·云扬· 源码阅读系列之Javajava开发语言
    Java的ThreadPoolExecutor是并发编程中处理任务执行的核心类，广泛应用于异步任务调度、批量数据处理等场景。本文将从源码层面解析其核心机制，提炼设计模式，并结合实际场景给出使用示例。一、线程池核心架构：状态管理与核心参数1.1状态压缩与原子控制：ctl变量ThreadPoolExecutor通过一个原子整数ctl（类型为AtomicInteger）同时管理线程池状态（runStat
  • MyBatis源码深度解析：核心机制与实战应用指南 言宇程序 mybatisMyBatis源码深度解析核心
    MyBatis源码深度解析：核心机制与实战应用指南作为Java开发者，深入理解MyBatis源码能显著提升复杂场景下的技术决策能力。面对框架底层庞杂的模块设计，如何快速建立系统化的源码认知体系？本文将从实际应用场景出发，拆解核心源码实现逻辑。一、源码阅读的价值与技术突破点配置陷阱规避通过分析XML配置加载流程，掌握MappedStatement注册机制与typeAliases的优先级陷阱性能调优依
  • 【Java源码阅读系列19】深度解读Java AtomicReference 源码 ·云扬· 源码阅读系列之Javajava开发语言jvm
    AtomicReference是Javajava.util.concurrent.atomic包中的核心类之一，用于在多线程环境下实现线程安全的对象引用原子操作。本文将结合JDK8源码，从底层实现、核心方法、设计模式等角度深入解析其原理。一、类定义与核心字段1.类泛型与继承AtomicReference是泛型类（表示引用对象的类型），实现了java.io.Serializable（支持序列化）：p
  • 面试必问的Redis命令实现原理：从网络到存储，手把手拆解执行全流程 码里看花‌ 面试redis职场和发展
    Redis的命令实现原理几乎是每个候选人都会被追问的考点。无论是"GET/SET命令底层如何操作内存"，还是"为什么单线程还能支撑高并发"，这些问题背后都藏着Redis设计的核心智慧。今天这篇文章，我会结合自己五年开发中踩过的坑和源码阅读经验，带你从网络接收到存储落盘，完整拆解一条Redis命令的执行全流程。一、前置认知：Redis的"三层架构"要理解命令执行，首先得明确Redis的整体架构。它采
  • 学习日记-spring-day33-6.19 永日45670 学习日记学习
    知识点：1.Spring课程概述知识点核心内容重点Spring框架概述轻量级容器框架，封装复杂逻辑，需理解IOC、AOP等核心机制容器框架vs普通框架、封装带来的理解门槛学习难点动态代理、反射、注解、IO操作、XML解析、容器（如ConcurrentHashMap）的综合应用动态代理实现原理、反射与注解的协同机制课程设计亮点通过手动实现Spring底层机制（如IOC、AOP）加深理解，避免源码阅读
  • 7种方法提高源码阅读技巧 学会了没 源码阅读编程技巧
    Readingsourcecodeisinthejobdescriptionofasoftwaredeveloper.However,thisexperienceisnotalwayspleasant.Noteveryonewouldliketoreadsomeoneelse’scodebecausetheyfinditboring,sometimesfrustrating.Therearecas
  • Cartographer源码阅读---MapBuilder的声明与构造 虾眠不觉晓, cartographerCartographerSLAM
    前面已经谈到了Cartographer中添加轨迹的方法和传感器的数据流动走向。我们注意到，在添加轨迹的时候，除了添加位姿估计器还有采样器，订阅回调函数之外，最重要的是通过map_builder_bridge添加了一条轨迹，其他的都是为它服务的。咱们这节详细看看MapBuilder这个Cartographer的核心。开始一条轨迹添加轨迹是开启Cartographer的大门.顾名思义,添加轨迹就是Ad
  • 【Java源码阅读系列5】深度解析StringBuilder与StringBuffer源码 ·云扬· 源码阅读系列之Javajavapython开发语言
    在Java中处理字符串拼接时，StringBuilder与StringBuffer是最常用的工具类。它们的核心作用都是可变字符序列的高效操作，但二者的设计定位却有本质差异。本文将从源码层面深入解析两者的实现逻辑，并总结其适用场景。一、类继承关系与核心设计1.1共同父类：AbstractStringBuilderStringBuilder与StringBuffer均继承自抽象类AbstractStr
  • create-vite 源码阅读 AI_boom javascript前端html
    前言create-vite主要是用于创建一个项目并根据用户选择配置的template将模板文件写入当前创建的目录中。vite提供了多个模板及其ts版本。重要插件使用minimist解析命令行参数使用prompts包来实现命令行指引配置的功能。使用kolorist包实现不同颜色的关键词。来看一下这些包的简单使用，方便后续查看create-vite中的源码。minimist通过process.argv
  • 【Web应用】若依框架：基础篇14 源码阅读-后端代码分析-课程管理模块前后端代码分析 JosieBook #Java全栈前端
    文章目录一、课程管理模块前端代码截图二、前端代码及分析index.vuecourse.js三、前端执行流程1.组件初始化2.查询操作3.列表操作4.对话框操作5.API请求6.执行流程总结关键点四、课程管理模块后端代码截图五、后端代码块CourseControllerICourseServiceCourseMapperCourse六、后端执行逻辑1.`Course`类2.`CourseMapper
  • RT-Thread源码阅读(3)——内核对象管理 无聊到发博客的菜鸟 RTOS嵌入式RTTRT-Thread单片机物联网STM32
    _object_container对象容器数组在RT-Thread操作系统中，_object_container数组的作用是按类型分类管理内核对象，提供高效的类型检查、资源管理和统计功能structrt_list_node{structrt_list_node*next;/**next=l->prev=l;}rt_object_allocate（用于动态创建对象）rt_object_allocat
  • RT-Thread源码阅读(4)——定时器管理 无聊到发博客的菜鸟 RTOS嵌入式RTTRT-Thread单片机物联网STM32
    RT-Thread的定时器有硬件定时器和软件定时器之分：硬件定时器：在systick中断服务函数中判断超时并执行定时函数软件定时器：单独起一个高优先级的线程，在线程中判断超时并执行定时函数通过是否定义宏RT_USING_TIMER_SOFT来决定启用软件定时器，默认不启用定时器的使用staticrt_timer_ttimer1;/***@"timer1"是定时器名称*@test_timer_cal
  • java 优先队列源码阅读 最近减肥 java源码学习优先队列源码阅读
    JavaPriorityQueue阅读优先队列使用最大或者最小堆来实现，使用数组来储存元素，将数组当做完全二叉树来处理，节点node的左右孩子节点为（2node+1和2node+2）数组扩容：newCapacity=oldCapacity+((oldCapacity>1));当newCapacity>Integer.MAX_VALUE-8时，由privatestaticinthugeCapacit
  • String 类及源码阅读、面试题详解 努力的白小胖 java基础进阶java字符串jvm
    String源码解读在了解String类之前，先给大家总结一句话：“所有对String类进行过改变操作的方法，所返回的结果都是一个新的String对象，因为String字符串是不可变的！！！”由于包子是刚开始写文章，所以对于一些语言描述可能不是特别的通俗易懂，在以后小编会尽量学习使用通俗易懂的语言来为大家解释。对于上边的总结，我们通过下边的内容能够更容易理解。String类java.lang.St
  • pytorch 源码阅读(1)——torch.complie 哦豁灬 备忘pytorchpytorch人工智能pythonpytorch源码
    0torch.complie(model,fullgraph,dynamic,backend,mode,options,disable)，使用TorchDynamo和指定的后端优化给定的模型/函数torch.compiler是一个命名空间，通过它可以将一些内部编译器方法公开给用户使用。此命名空间中的主要函数和功能是torch.compile。torch.compile是PyTorch2.x中引入的
  • 阿里p7是如何提升技术能力的 DKPT 话题与杂谈笔记java学习数据库mysql
    一、技术能力的深度与广度构建技术体系需形成网状知识结构，例如围绕MySQL不仅掌握基础操作，还需深入理解其架构、锁机制、主从复制等底层原理。技术广度需覆盖分布式系统、微服务、高并发、中间件（如Redis、Kafka）等核心领域，并具备跨技术栈整合能力。关键点：通过源码阅读（如Spring、Docker）和原理分析（如JVM内存管理、网络协议）提升技术深度。系统设计与架构能力能独立设计复杂系统的架构
  • C-libev学习笔记-事件库源码阅读6-API-ev_default_loop(),ev_init() 虚知道 Libevc++
    ev_default_loop()声明：EV_API_DECLstructev_loop*ev_default_loop(unsignedintflagsEV_CPP(=0))EV_THROW;EV_API_DECLintev_default_loop(unsignedintflagsEV_CPP(=0))EV_THROW;/*returnstruewhensuccessful*/作者的注释：/*
  • jQuery 跨域访问的三种方式 No 'Access-Control-Allow-Origin' header is present on the reque qiaolevip 每天进步一点点学习永无止境跨域众观千象
    XMLHttpRequest cannot load http://v.xxx.com. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:63342' is therefore not allowed access. test.html:1
  • mysql 分区查询优化 annan211 java分区优化mysql
    分区查询优化 引入分区可以给查询带来一定的优势，但同时也会引入一些bug. 分区最大的优点就是优化器可以根据分区函数来过滤掉一些分区，通过分区过滤可以让查询扫描更少的数据。 所以，对于访问分区表来说，很重要的一点是要在where 条件中带入分区，让优化器过滤掉无需访问的分区。 可以通过查看explain执行计划，是否携带 partitions
  • MYSQL存储过程中使用游标 chicony Mysql存储过程
    DELIMITER $$ DROP PROCEDURE IF EXISTS getUserInfo $$ CREATE PROCEDURE getUserInfo(in date_day datetime)-- -- 实例-- 存储过程名为：getUserInfo-- 参数为：date_day日期格式:2008-03-08--    BEGINdecla
  • mysql 和 sqlite 区别 Array_06 sqlite
    转载： http://www.cnblogs.com/ygm900/p/3460663.html mysql 和 sqlite 区别 SQLITE是单机数据库。功能简约，小型化，追求最大磁盘效率 MYSQL是完善的服务器数据库。功能全面，综合化，追求最大并发效率 MYSQL、Sybase、Oracle等这些都是试用于服务器数据量大功能多需要安装，例如网站访问量比较大的。而sq
  • pinyin4j使用 oloz pinyin4j
    首先需要pinyin4j的jar包支持；jar包已上传至附件内 方法一:把汉字转换为拼音；例如：编程转换后则为biancheng      /** * 将汉字转换为全拼 * @param src 你的需要转换的汉字 * @param isUPPERCASE 是否转换为大写的拼音； true:转换为大写；fal
  • 微博发送私信 随意而生 微博
    在前面文章中说了如和获取登陆时候所需要的cookie，现在只要拿到最后登陆所需要的cookie，然后抓包分析一下微博私信发送界面 http://weibo.com/message/history?uid=****&name=**** 可以发现其发送提交的Post请求和其中的数据， 让后用程序模拟发送POST请求中的数据，带着cookie发送到私信的接入口，就可以实现发私信的功能了。
  • jsp 香水浓 jsp
    JSP初始化     容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。如果您需要执行自定义的JSP初始化任务，复写jspInit()方法就行了 JSP执行     这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。     当JSP网页完成初始化后
  • 在 Windows 上安装 SVN Subversion 服务端 AdyZhang SVN
    在 Windows 上安装 SVN Subversion 服务端2009-09-16高宏伟哈尔滨市道里区通达街291号   最佳阅读效果请访问原地址：http://blog.donews.com/dukejoe/archive/2009/09/16/1560917.aspx   现在的Subversion已经足够稳定，而且已经进入了它的黄金时段。我们看到大量的项目都在使
  • android开发中如何使用 alertDialog从listView中删除数据？ aijuans android
    我现在使用listView展示了很多的配置信息，我现在想在点击其中一条的时候填出 alertDialog,点击确认后就删除该条数据，（ ArrayAdapter ，ArrayList，listView 全部删除），我知道在 下面的onItemLongClick 方法中 参数 arg2  是选中的序号，但是我不知道如何继续处理下去 1 2 3
  • jdk-6u26-linux-x64.bin 安装 baalwolf linux
    1.上传安装文件(jdk-6u26-linux-x64.bin) 2.修改权限 [root@localhost ~]# ls -l /usr/local/jdk-6u26-linux-x64.bin 3.执行安装文件 [root@localhost ~]# cd /usr/local [root@localhost local]# ./jdk-6u26-linux-x64.bin&nbs
  • MongoDB经典面试题集锦 BigBird2012 mongodb
    1.什么是NoSQL数据库？NoSQL和RDBMS有什么区别？在哪些情况下使用和不使用NoSQL数据库？ NoSQL是非关系型数据库，NoSQL = Not Only SQL。 关系型数据库采用的结构化的数据，NoSQL采用的是键值对的方式存储数据。 在处理非结构化/半结构化的大数据时；在水平方向上进行扩展时；随时应对动态增加的数据项时可以优先考虑使用NoSQL数据库。 在考虑数据库的成熟
  • JavaScript异步编程Promise模式的6个特性 bijian1013 JavaScriptPromise
            Promise是一个非常有价值的构造器，能够帮助你避免使用镶套匿名方法，而使用更具有可读性的方式组装异步代码。这里我们将介绍6个最简单的特性。         在我们开始正式介绍之前，我们想看看Javascript Promise的样子： var p = new Promise(function(r
  • [Zookeeper学习笔记之八]Zookeeper源代码分析之Zookeeper.ZKWatchManager bit1129 zookeeper
    ClientWatchManager接口 //接口的唯一方法materialize用于确定那些Watcher需要被通知 //确定Watcher需要三方面的因素1.事件状态 2.事件类型 3.znode的path public interface ClientWatchManager { /** * Return a set of watchers that should
  • 【Scala十五】Scala核心九：隐式转换之二 bit1129 scala
    隐式转换存在的必要性，   在Java Swing中，按钮点击事件的处理，转换为Scala的的写法如下：   val button = new JButton button.addActionListener( new ActionListener { def actionPerformed(event: ActionEvent) {
  • Android JSON数据的解析与封装小Demo ronin47
    转自：http://www.open-open.com/lib/view/open1420529336406.html package com.example.jsondemo; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject;    impor
  • [设计]字体创意设计方法谈 brotherlamp UIui自学ui视频ui教程ui资料
      从古至今，文字在我们的生活中是必不可少的事物，我们不能想象没有文字的世界将会是怎样。在平面设计中，UI设计师在文字上所花的心思和功夫最多，因为文字能直观地表达UI设计师所的意念。在文字上的创造设计，直接反映出平面作品的主题。 如设计一幅戴尔笔记本电脑的广告海报，假设海报上没有出现“戴尔”两个文字，即使放上所有戴尔笔记本电脑的图片都不能让人们得知这些电脑是什么品牌。只要写上“戴尔笔
  • 单调队列-用一个长度为k的窗在整数数列上移动，求窗里面所包含的数的最大值 bylijinnan java算法面试题
    import java.util.LinkedList; /* 单调队列 滑动窗口 单调队列是这样的一个队列：队列里面的元素是有序的，是递增或者递减 题目：给定一个长度为N的整数数列a(i),i=0,1,...,N-1和窗长度k. 要求：f(i) = max{a(i-k+1),a(i-k+2),..., a(i)},i = 0,1,...,N-1 问题的另一种描述就
  • struts2处理一个form多个submit chiangfai struts2
    web应用中，为完成不同工作，一个jsp的form标签可能有多个submit。如下代码： <s:form action="submit" method="post" namespace="/my"> <s:textfield name="msg" label="叙述：">
  • shell查找上个月，陷阱及野路子 chenchao051 shell
    date -d "-1 month" +%F     以上这段代码，假如在2012/10/31执行，结果并不会出现你预计的9月份，而是会出现八月份，原因是10月份有31天，9月份30天，所以-1 month在10月份看来要减去31天，所以直接到了8月31日这天，这不靠谱。     野路子解决：假设当天日期大于15号
  • mysql导出数据中文乱码问题 daizj mysql中文乱码导数据
    解决mysql导入导出数据乱码问题方法： １、进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+----------------------------------------+ | Variable_name&nbs
  • SAE部署Smarty出现：Uncaught exception 'SmartyException' with message 'unable to write dcj3sjt126com PHPsmartysae
      对于SAE出现的问题：Uncaught exception 'SmartyException' with message 'unable to write file...。 官方给出了详细的FAQ：http://sae.sina.com.cn/?m=faqs&catId=11#show_213 解决方案为：   01 $path 
  • 《教父》系列台词 dcj3sjt126com
    Your love is also your weak point. 你的所爱同时也是你的弱点。   If anything in this life is certain, if history has taught us anything, it is that you can kill anyone.   不顾家的人永远不可能成为一个真正的男人。 &
  • mongodb安装与使用 dyy_gusi mongo
    一.MongoDB安装和启动,widndows和linux基本相同 1.下载数据库,     linux:mongodb-linux-x86_64-ubuntu1404-3.0.3.tgz 2.解压文件,并且放置到合适的位置     tar -vxf mongodb-linux-x86_64-ubun
  • Git排除目录 geeksun git
    在Git的版本控制中，可能有些文件是不需要加入控制的，那我们在提交代码时就需要忽略这些文件，下面讲讲应该怎么给Git配置一些忽略规则。   有三种方法可以忽略掉这些文件，这三种方法都能达到目的，只不过适用情景不一样。 1.  针对单一工程排除文件 这种方式会让这个工程的所有修改者在克隆代码的同时，也能克隆到过滤规则，而不用自己再写一份，这就能保证所有修改者应用的都是同一
  • Ubuntu 创建开机自启动脚本的方法 hongtoushizi ubuntu
    转载自： http://rongjih.blog.163.com/blog/static/33574461201111504843245/ Ubuntu 创建开机自启动脚本的步骤如下： 1) 将你的启动脚本复制到 /etc/init.d目录下 以下假设你的脚本文件名为 test。   2) 设置脚本文件的权限 $ sudo chmod 755
  • 第八章 流量复制/AB测试/协程 jinnianshilongnian nginxluacoroutine
    流量复制 在实际开发中经常涉及到项目的升级，而该升级不能简单的上线就完事了，需要验证该升级是否兼容老的上线，因此可能需要并行运行两个项目一段时间进行数据比对和校验，待没问题后再进行上线。这其实就需要进行流量复制，把流量复制到其他服务器上，一种方式是使用如tcpcopy引流；另外我们还可以使用nginx的HttpLuaModule模块中的ngx.location.capture_multi进行并发
  • 电商系统商品表设计 lkl
    DROP TABLE IF EXISTS `category`; -- 类目表 /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `category` ( `id` int(11) NOT NUL
  • 修改phpMyAdmin导入SQL文件的大小限制 pda158 sqlmysql
    　用phpMyAdmin导入mysql数据库时，我的10M的 数据库不能导入，提示mysql数据库最大只能导入2M。 　　 phpMyAdmin数据库导入出错： 　　You probably tried to upload too large file. Please refer to documentation for ways to workaround this limit.
  • Tomcat性能调优方案 Sobfist apachejvmtomcat应用服务器
    一、操作系统调优 对于操作系统优化来说，是尽可能的增大可使用的内存容量、提高CPU的频率，保证文件系统的读写速率等。经过压力测试验证，在并发连接很多的情况下，CPU的处理能力越强，系统运行速度越快。。 【适用场景】 任何项目。 二、Java虚拟机调优 应该选择SUN的JVM，在满足项目需要的前提下，尽量选用版本较高的JVM，一般来说高版本产品在速度和效率上比低版本会有改进。 J
  • SQLServer学习笔记 vipbooks 数据结构xml
    1、create database school 创建数据库school 2、drop database school 删除数据库school 3、use school 连接到school数据库，使其成为当前数据库 4、create table class(classID int primary key identity not null) 创建一个名为class的表，其有一
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他