forever_提拉米苏
forever_提拉米苏

手写promise思路

之前写过一篇关于promise的一些常规用法，以及promise与async/await关系的文章。但是我们知道，要想把一个知识点完全掌握，知其然而不知其所以然是远远不够的，那么接下来将要来探讨promise的原理，来分析分析promise的这种规则机制是如何实现的。我们通过手写promise的方式达到这个目的，同时来加深对primise的理解。

思路

手写promise之前，我们先来回忆一下promise的使用方式，便于整理思路。

const p1 = new Promise((resolve, reject)=>{
  console.log('此处同步执行');
  const a = 2;
  setTimeout(()=>{
  // 此处异步执行
  if(a>0){
    resolve('成功');
  }else{
    reject('失败原因');
  }
  },1000)
});
p1.then((res)=>{
  console.log(res);
},(err)=>{
  console.log(err);
})

从上面的代码可以看出，要想使用promise需要先通过new Promise(fn)生成一个实例p1，然后通过实例p1调用then()和catch()方法。因此可以得出以下几点结论：

  1. Promise本身是一个构造函数，其参数fn是一个同步执行的回调函数，该函数执行的参数也是两个函数resolve和reject。这两个参数的作用是等异步操作执行完成后，为后续方法的执行传参，如：then()和catch()。
  2. then()用两个函数作为参数，在实例p1中的resolve和reject方法中分别触发对应的函数，并把异步操作执行的结果传递给对应的函数。
  3. Promise有三种状态：pending、rejected和resolved，同步回调函数fn开始执行时状态为pending，执行了resolve和reject后会将其状态改为resolved和rejected。resolved和rejected只能执行一次，且Promise状态一旦被确定下来，那么就是不可更改的（锁定）。

通过观察Promise的使用方式得出的几点结论，书写promise的思路大致可以通过下面几个方面来完成：

  1. 定义Promise的三种状态；
  2. 创建构造函数，并为构造函数定义一个回调函数作为参数；
  3. 在构造函数内定义变量来保存Promise的状态，定义两个函数resolve和reject，并在构造函数中执行回调函数的时候将此传入；
  4. 函数resolve和reject目前的作用是改变Promise的状态，保存异步操作返回的值或者失败的原因；
  5. 为构造函数创建then()方法，then()方法的参数是两个函数onResolved、onRejected，这两个函数将被传入构造函数内定义的resolve和reject方法中执行。此时函数resolve和reject发挥了它的第二个作用，就是执行then()方法传递过来的回调函数。

实现

有了大致的思路，那么接下来就是如何去实现它。

  1. Promise构造函数的设计，对应思路1、2、3、4
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';
class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                this.status = PROMISE_STATUS_FULFILLED;
                this.value = value;
                console.log('resolve被调用');
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                this.status = PROMISE_STATUS_REJECTED;
                this.reason = reason;
                console.log('reject被调用');
            }
        };
        executor(resolve, reject);
    }
}
  1. 定义好构造函数，接下来的任务就是书写构造函数的方法了，对应5。修改上面的代码如下：
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';
class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                this.status = PROMISE_STATUS_FULFILLED;
                //* 定时器是一个宏任务，会放在下一次事件循环时使用
                queueMicrotask(() => {
                    this.value = value;
                    console.log('resolve被调用', this.value);
                    // * 执行then传入进来的第一个回调函数
                    this.onResolved(this.value);
                });
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                this.status = PROMISE_STATUS_REJECTED;
                queueMicrotask(() => {
                    this.reason = reason;
                    console.log('reject被调用', this.reason);
                    // * 执行then传入进来的第二个回调函数
                    this.onRejected(this.reason);
                });
            }
        };
        executor(resolve, reject);
    }
    // then方法
    then(onResolved, onRejected) {
        this.onResolved = onResolved;
        this.onRejected = onRejected;
    }
}

优化

完成以上代码已经搭建了一个具备基本功能的Promise，不防试一下，相信它会带给你满意的结果。

const promise = new myPromise((resolve, reject) => {
    console.log('状态pending');
    resolve('1111');
});
promise.then(
    res => {
        console.log('res:', res);
    },
    err => {
        console.log('err:', err);
    },
);

运行以上代码，命令行会相继输出状态pending、resolve被调用 1111、res: 1111等，这代表着最基础版的Promise已经完成了。但是它仍然有很多问题，比如then()方法无法多次调用和链式调用、没有catch()方法等，所以接下来我们就要优化上面基础版的Promise，使它具备和官方基本一致的功能。

  1. 实现then()的多次调用
    then()多次调用就需要在构造函数里定义两个数组保存then()方法中传进来的回调，然后遍历这个数组，执行数组里的所有回调函数，修改代码如下:
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';
class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        this.onResolvedFns = [];
        this.onRejectedFns = [];
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                //* 定时器是一个宏任务，会放在下一次事件循环时使用
                queueMicrotask(() => {
                    this.status = PROMISE_STATUS_FULFILLED;
                    this.value = value;
                    console.log('resolve被调用', this.value);
                    // * 执行then传入进来的第一个回调函数
                    this.onResolvedFns.forEach(Fn => {
                        Fn(this.value);
                    });
                });
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                queueMicrotask(() => {
                    this.status = PROMISE_STATUS_REJECTED;
                    this.reason = reason;
                    console.log('reject被调用', this.reason);
                    // * 执行then传入进来的第二个回调函数
                    this.onRejectedFns.forEach(Fn => {
                        Fn(this.reason);
                    });
                });
            }
        };
        executor(resolve, reject);
    }
    // then方法
    then(onResolved, onRejected) {
        console.log(this.status);
        // 如果then方法调用的时候，状态已经确定下来了，应该直接执行的
        if (this.status === PROMISE_STATUS_FULFILLED && onResolved) {
            onResolved(this.value);
        } else if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
            onRejected(this.reason);
        } else {
            // 将成功回调和失败回调添加到数组中
            this.onResolvedFns.push(onResolved);
            this.onRejectedFns.push(onRejected);
        }
    }
}
  1. 实现then()的链式调用
    从上面的代码中可以清楚的看到then()方法是挂载在构造函数myPromise上的，所以为了实现链式调用，需要在then()方法里返回一个新的Promise对象，然后使用新的Promise对象的resolve方法去处理对应的回调函数的返回值。从代码的简洁度考虑，我们需要封装一个工具函数，用来处理异常和回调函数。
    与此同时，当回调函数executor的执行发生异常时，也许有执行reject|函数。因此，我们把代码调整如下：
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';

// 工具函数
function execFunctionWithCatchError(exeFn, value, resolve, reject) {
    try {
        let result = exeFn(value);
        resolve(result);
    } catch (err) {
        reject(err);
    }
}

class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        this.onResolvedFns = [];
        this.onRejectedFns = [];
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                // * 添加微任务
                //* 定时器是一个宏任务，会放在下一次事件循环时使用
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_FULFILLED;
                    this.value = value;
                    // console.log('resolve被调用', this.value);
                    // * 执行then传入进来的第一个回调函数
                    this.onResolvedFns.forEach(Fn => {
                        Fn(this.value);
                    });
                });
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                //  * 添加微任务
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_REJECTED;
                    this.reason = reason;
                    // console.log('reject被调用', this.reason);
                    // * 执行then传入进来的第二个回调函数
                    this.onRejectedFns.forEach(Fn => {
                        Fn(this.reason);
                    });
                });
            }
        };
        // * 在调用executor时判断里面是否抛出异常
        try {
            executor(resolve, reject);
        } catch (err) {
            reject(err);
        }
    }
    // then方法
    then(onResolved, onRejected) {
        return new myPromise((resolve, reject) => {
            // 如果then方法调用的时候，状态已经确定下来了，应该直接执行的
            if (this.status === PROMISE_STATUS_FULFILLED && onResolved) {
                // onResolved(this.value);
                execFunctionWithCatchError(onResolved, this.value, resolve, reject);
            } else if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
                // onRejected(this.reason);
                execFunctionWithCatchError(
                    onRejected,
                    this.reason,
                    resolve,
                    reject,
                );
            } else {
                // 将成功回调和失败回调添加到数组中
                this.onResolvedFns.push(() => {
                    execFunctionWithCatchError(
                        onResolved,
                        this.value,
                        resolve,
                        reject,
                    );
                });
                this.onRejectedFns.push(() => {
                    execFunctionWithCatchError(
                        onRejected,
                        this.reason,
                        resolve,
                        reject,
                    );
                });
            }
        });
    }
}
  1. catch()方法的实现
    我们知道，在官方提供的Promise中可不止then()一种方法，其中最常用的便是catch()方法了。
    catch()与then()方法不同，它只会接受一个onRejected的回调函数，catch()方法执行的其实是then()方法第二个参数的工作，then(null, function() {})就等同于catch(function() {})。但是用this.then(undefined,onRejected);来实现catch()方法显然是不可以的，因为这样做的话，catch()方法是针对新的Promise的rejected的状态，我们要解决的问题就是如何让catch()方法捕获原Promise对象的rejected状态。
    所以我们要对then()方法做一些改动，在方法内部前面判断第二个参数是否有值，如果没有值，就重新赋值为一个函数，函数内部抛出一个异常。这样在新的Promise就能捕获到原来的promise的rejected的状态了。具体实现方式如下：
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';

// 工具函数
function execFunctionWithCatchError(exeFn, value, resolve, reject) {
    try {
        let result = exeFn(value);
        resolve(result);
    } catch (err) {
        reject(err);
    }
}

class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        this.onResolvedFns = [];
        this.onRejectedFns = [];
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                // * 添加微任务
                //* 定时器是一个宏任务，会放在下一次事件循环时使用
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_FULFILLED;
                    this.value = value;
                    // console.log('resolve被调用', this.value);
                    // * 执行then传入进来的第一个回调函数
                    this.onResolvedFns.forEach(Fn => {
                        Fn(this.value);
                    });
                });
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                //  * 添加微任务
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_REJECTED;
                    this.reason = reason;
                    // console.log('reject被调用', this.reason);
                    // * 执行then传入进来的第二个回调函数
                    this.onRejectedFns.forEach(Fn => {
                        Fn(this.reason);
                    });
                });
            }
        };
        // * 在调用executor时判断里面是否抛出异常
        try {
            executor(resolve, reject);
        } catch (err) {
            reject(err);
        }
    }
    // then方法
    then(onResolved, onRejected) {
        onRejected =
            onRejected ||
            (err => {
                throw err;
            });
        return new myPromise((resolve, reject) => {
            // 如果then方法调用的时候，状态已经确定下来了，应该直接执行的
            if (this.status === PROMISE_STATUS_FULFILLED && onResolved) {
                // onResolved(this.value);
                execFunctionWithCatchError(onResolved, this.value, resolve, reject);
            } else if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
                // onRejected(this.reason);
                execFunctionWithCatchError(
                    onRejected,
                    this.reason,
                    resolve,
                    reject,
                );
            } else {
                // 将成功回调和失败回调添加到数组中
                if (onResolved)
                    this.onResolvedFns.push(() => {
                        execFunctionWithCatchError(
                            onResolved,
                            this.value,
                            resolve,
                            reject,
                        );
                    });
                if (onRejected)
                    this.onRejectedFns.push(() => {
                        execFunctionWithCatchError(
                            onRejected,
                            this.reason,
                            resolve,
                            reject,
                        );
                    });
            }
        });
    }
    // * catch方法
    catch(onRejected) {
        this.then(undefined, onRejected);
    }
}
  1. finally()方法的实现
    前面讲到的then()和catch()都是Promise的实例方法，也可以称为对象方法，除此之外，Promise还有一个实例方法，那就是finally()。finally()方法大致可以概括如下：
  • finally是ES9（ES2018）新增的一个特性：表示无论Promise的状态变为resolved还是reject，最终都会被执行的代码。
  • finally方法是不接收参数的，因为无论前面是resolved状态，还是reject状态，它都会执行。
  • finally其实也是返回一个Promise对象，但是其实很少人会用它。
    因此，finally方法的实现也很简单，只需要在Promise构造函数中定义一个方法，无论promise的状态是什么。代码实现如下：
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';

// 工具函数
function execFunctionWithCatchError(exeFn, value, resolve, reject) {
    try {
        let result = exeFn(value);
        resolve(result);
    } catch (err) {
        reject(err);
    }
}

class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        this.onResolvedFns = [];
        this.onRejectedFns = [];
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                // * 添加微任务
                //* 定时器是一个宏任务，会放在下一次事件循环时使用
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_FULFILLED;
                    this.value = value;
                    // console.log('resolve被调用', this.value);
                    // * 执行then传入进来的第一个回调函数
                    this.onResolvedFns.forEach(Fn => {
                        Fn(this.value);
                    });
                });
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                //  * 添加微任务
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_REJECTED;
                    this.reason = reason;
                    // console.log('reject被调用', this.reason);
                    // * 执行then传入进来的第二个回调函数
                    this.onRejectedFns.forEach(Fn => {
                        Fn(this.reason);
                    });
                });
            }
        };
        // * 在调用executor时判断里面是否抛出异常
        try {
            executor(resolve, reject);
        } catch (err) {
            reject(err);
        }
    }
    // then方法
    then(onResolved, onRejected) {
        onRejected =
            onRejected ||
            (err => {
                throw err;
            });
        return new myPromise((resolve, reject) => {
            // 如果then方法调用的时候，状态已经确定下来了，应该直接执行的
            if (this.status === PROMISE_STATUS_FULFILLED && onResolved) {
                // onResolved(this.value);
                execFunctionWithCatchError(onResolved, this.value, resolve, reject);
            } else if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
                // onRejected(this.reason);
                execFunctionWithCatchError(
                    onRejected,
                    this.reason,
                    resolve,
                    reject,
                );
            } else {
                // 将成功回调和失败回调添加到数组中
                if (onResolved)
                    this.onResolvedFns.push(() => {
                        execFunctionWithCatchError(
                            onResolved,
                            this.value,
                            resolve,
                            reject,
                        );
                    });
                if (onRejected)
                    this.onRejectedFns.push(() => {
                        execFunctionWithCatchError(
                            onRejected,
                            this.reason,
                            resolve,
                            reject,
                        );
                    });
            }
        });
    }
    // * catch方法
    catch(onRejected) {
        this.then(undefined, onRejected);
    }
    // finally方法
    finally(onFinally) {
        return this.then(
            () => {
                onFinally();
            },
            () => {
                onFinally();
            },
        );
    }
}
  1. Promise的类方法的实现
    前面说到的then、catch、finally方法都属于Promise的实例方法，都是存放在Promise的prototype上的。下面我们将学习类方法。
  • Promise.resolve()方法：有时候我们已经有一个现成的内容，希望将其转成Promise来使用，这个时候我们可以使用Promise.resolve()方法来完成，所以Promise.resolve()相当于new Promise，并且执行resolve操作。
  • Promise.reject()方法：reject方法类似于resolve方法，只是会将Promise对象的状态设置为rejected状态，所以Promise.reject无论传过来的参数是什么状态，都会直接作为reject的参数传递到catch的。
  • Promise.all()方法：Promise.all()我们在上一篇中讲过，对于用法这里不再多做阐述，大致可以归纳为只有当所有的promise都变成resolved状态时，原promise才会变成resolved状态，相反当任意一个promise变成rejected状态时，原promise就会变成rejected状态，并且仍然处于pending状态的promise将不会获取到结果。不明白的同学请自行查阅Promise 与async/await。
  • Promise.allSettled()方法：Promise.allSettled是ES11（ES2020）中新添加的API，它用于解决Promise.all()方法的一个缺陷（也是其特征）：当有一个Promise变成rejected状态时，新Promise就会立即变成对应的rejected状态。 Promise.allSettled方法会在所有的Promise都有结果时，无论是resolved，还是rejected，才会有最终的状态，并且这个Promise的结果一定是resolved`。
  • Promise.race()方法：Promise.race()方法同样在上一篇中讲过，大致可以归纳为:数组中的其中一个promise返回状态时，无论此状态是resolved或者rejected，它都将会成为原promise的状态，即先到先得。
  • Promise.any()方法：Promise.any()方法是ES12中新增的方法，和Promise.race()方法是类似的。Promise.any()方法会等到一个resolved状态，才会决定新Promise的状态，就算所有的Promise都是rejected的，那么也会等到所有的Promise都变成rejected状态，err信息为：AggregateError: All promises were rejected。
    看完所有Promise类方法的使用，接下来我们就开下怎么来实现他们吧。
const PROMISE_STATUS_PENDING = 'pending';
const PROMISE_STATUS_FULFILLED = 'fulfilled';
const PROMISE_STATUS_REJECTED = 'rejected';

// 工具函数
function execFunctionWithCatchError(exeFn, value, resolve, reject) {
    try {
        const result = exeFn(value);
        resolve(result);
    } catch (err) {
        reject(err);
    }
}

class myPromise {
    // * 记录状态
    constructor(executor) {
        // * 保存Promise的状态
        this.status = PROMISE_STATUS_PENDING;
        // * 保存传入的值
        this.value = undefined;
        this.reason = undefined;
        this.onResolvedFns = [];
        this.onRejectedFns = [];
        const resolve = value => {
            if (this.status == PROMISE_STATUS_PENDING) {
                // * 添加微任务
                //* 定时器是一个宏任务，会放在下一次事件循环时使用
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_FULFILLED;
                    this.value = value;
                    // console.log('resolve被调用', this.value);
                    // * 执行then传入进来的第一个回调函数
                    this.onResolvedFns.forEach(Fn => {
                        Fn(this.value);
                    });
                });
            }
        };
        const reject = reason => {
            if (this.status == PROMISE_STATUS_PENDING) {
                //  * 添加微任务
                queueMicrotask(() => {
                    if (this.status !== PROMISE_STATUS_PENDING) return;
                    this.status = PROMISE_STATUS_REJECTED;
                    this.reason = reason;
                    // console.log('reject被调用', this.reason);
                    // * 执行then传入进来的第二个回调函数
                    this.onRejectedFns.forEach(Fn => {
                        Fn(this.reason);
                    });
                });
            }
        };
        // * 在调用executor时判断里面是否抛出异常
        try {
            executor(resolve, reject);
        } catch (err) {
            reject(err);
        }
    }
    // then方法
    then(onResolved, onRejected) {
        onRejected =
            onRejected ||
            (err => {
                throw err;
            });
        return new myPromise((resolve, reject) => {
            // 如果then方法调用的时候，状态已经确定下来了，应该直接执行的
            if (this.status === PROMISE_STATUS_FULFILLED && onResolved) {
                // onResolved(this.value);
                execFunctionWithCatchError(onResolved, this.value, resolve, reject);
            } else if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
                // onRejected(this.reason);
                execFunctionWithCatchError(
                    onRejected,
                    this.reason,
                    resolve,
                    reject,
                );
            } else {
                // 将成功回调和失败回调添加到数组中
                if (onResolved)
                    this.onResolvedFns.push(() => {
                        execFunctionWithCatchError(
                            onResolved,
                            this.value,
                            resolve,
                            reject,
                        );
                    });
                if (onRejected)
                    this.onRejectedFns.push(() => {
                        execFunctionWithCatchError(
                            onRejected,
                            this.reason,
                            resolve,
                            reject,
                        );
                    });
            }
        });
    }
    // * catch方法
    catch(onRejected) {
        this.then(undefined, onRejected);
    }
    // finally方法
    finally(onFinally) {
        return this.then(
            () => {
                onFinally();
            },
            () => {
                onFinally();
            },
        );
    }
    // 类方法resolve
    static resolve(value) {
        return new myPromise((resolve, reject) => {
            resolve(value);
        });
    }
    // 类方法reject
    static reject(reason) {
        return new myPromise((resolve, reject) => {
            reject(reason);
        });
    }
    // 类方法all
    static all(promises) {
        // * 问题关键：什么时候执行resolve，什么时候执行reject
        return new myPromise((resolve, reject) => {
            let values = [];
            promises.forEach(promise => {
                promise
                    .then(res => {
                        values.push(res);
                        if (values.length == promises.length) resolve(values);
                    })
                    .catch(err => {
                        reject(err);
                    });
            });
        });
    }
    // 类方法allSettled
    static allSettled(promises) {
        return new myPromise((resolve, reject) => {
            let results = [];
            promises.forEach(promise => {
                promise
                    .then(res => {
                        results.push({ status: PROMISE_STATUS_FULFILLED, value: res });
                        if (results.length == promises.length) resolve(results);
                    })
                    .catch(err => {
                        results.push({ status: PROMISE_STATUS_REJECTED, value: err });
                        if (results.length == promises.length) resolve(results);
                    });
            });
        });
    }
    // 类方法race
    static race(promises) {
        return new myPromise((resolve, reject) => {
            promises.forEach(promise => {
                // promise.then(res=>{
                //  resolve(res);
                // }).catch(err=>{
                //  reject(err);
                // })
                promise.then(resolve, reject);
            });
        });
    }
    // 类方法any
    static any(promises) {
        // * resolve 必须等待有一个成功的结果
        // * reject 所有的都失败才执行 reject
        return new myPromise((resolve, reject) => {
            let reasons = [];
            promises.forEach(promise => {
                promise
                    .then(res => {
                        resolve(res);
                    })
                    .catch(err => {
                        reasons.push(err);
                        if (reasons.length == promises.length) {
                            reject(
                                new AggregateError(
                                    reasons,
                                    ' AggregateError: All promises were rejected',
                                ),
                            );
                        }
                    });
            });
        });
    }
}

说了这么多，最后放上一张Promise的知识点关系图作为结束。

promise.png

参考文献：https://www.jianshu.com/p/e91ce318d7ad

你可能感兴趣的:(手写promise思路)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • 【六】阿伟开始搭建Kafka学习环境 能源恒观 中间件学习kafkaspring
    阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
  • 不要偷走他人的声音 天天_27d6
    朱会利焦点讲师班五期洛阳坚持分享第634天《来访者才是主角》2018.08.02今天的中级班课堂上，老师再一次给我们强调了咨询目标的建立过程中，作为咨询师一定要明白，我们只是在协助来访者解决他自身的问题，所以一切以来访者为主，他想解决的问题才是咨询的目标。所以如果在谈话的过程中，出现了我们感觉不是我们想要的答案的时候，我们不是再极力去引导来访者按照我们的思路走，而是觉察自己的预设并且进行调整，谨言
  • xilinx vivado PULLMODE 设置思路 坚持每天写程序 fpga开发
    1.xilinx引脚分类XilinxIO的分类：以XC7A100TFGG484为例，其引脚分类如下：1.UserIO(用户IO)：用户使用的普通IO1.1专用(Dedicated)IO：命名为IO_LXXY_#、IO_XX_#的引脚，有固定的特定用途，多为底层特定功能的直接实现，如差分对信号、关键控制信号等，不能随意变更。1.2多功能(Multi-Function)IO：命名为IO_LXXY_ZZ
  • C语言 判断回文数 Y雨何时停T c语言学习
    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 5分钟说透AppStore审核原理，让你拥有上架新思路！ Q仔本人噢
    在AppStore上架是越来越难了!相信非常多公司的技术人员都为此困扰，然而外包团队水平又层次不齐，容易遇坑，实在是内忧外患。是什么原因导致审核机制频繁调整？又是什么原因使得审核变得越发严格？那么接下来听小Q分解，马上给各位带来解答!首先看一下近一年的上下架的情况：近一年上架情况近一年下架情况通过数据我们发现越是马甲包产量权重高的分类里被下架的app数量越多，苹果此举可谓是上有政策，下有对策。通过
  • 计算机木马详细编写思路 小熊同学哦 php开发语言木马木马思路
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
  • Day777--【这届年轻人很懒，“但在你面前，我可以多受些麻烦。”】 卖小妞的饼干
    图片发自App中学时期，会因为朋友一句误会，手写三页信件解释来龙去脉，必须每天一起上学放学吃饭上洗手间，永远腻在一起才能彰显关系密切。而现在，相比每段关系都闹得轰轰烈烈，我们更喜欢顺其自然。懒得耗费大量时间去维护一段关系，懒得在与朋友产生矛盾后去辩解，懒得因为朋友做出背叛友谊的行为而愤怒诘问。不再把目光放在朋友的数量上，更在乎每一个还在身边的人是否饱含真心。我们都在期待着更舒服自然没有杂质的关系，
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • 孩子强迫症，厌学叛逆，家长怎么办？ 扶禾心理
    01最近，我们的公众号后台收到了很多家长的私信，很多家长说，孩子在进入青春期后，不知不觉竟然有强迫行为，特别容易钻牛角尖，沉迷网络，厌学，顶撞父母。他们为此很苦恼，不知道怎么办。强迫症正在成为儿童和青少年中常见的精神障碍之一。强迫症是一种长期逐步形成的心理问题，是一种慢性、难治性心理疾病。在这里，我们分享一些咨询实践及思路供家长参考，希望对更多的家长和孩子有帮助。一位家长私信我们说，她儿子14岁，
  • 代码随想录Day 41|动态规划之买卖股票问题，leetcode题目121. 买卖股票的最佳时机、122. 买卖股票的最佳时机Ⅱ、123. 买卖股票的最佳时机Ⅲ LluckyYH 动态规划leetcode算法数据结构
    提示：DDU，供自己复习使用。欢迎大家前来讨论~文章目录买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机解题思路：题目二：122.买卖股票的最佳时机II解题思路：题目三：123.买卖股票的最佳时机III解题思路总结买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机[[121.买卖股票的最佳时机](https://leetcode.cn/problems/combination
  • python爬取微信小程序数据,python爬取小程序数据 2301_81900439 前端
    大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换 让开，我要吃人了 OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
  • HarmonyOS Next鸿蒙扫一扫功能实现 JohnLiu_ HarmonyOSNextharmonyos华为扫一扫鸿蒙
    直接使用的是华为官方提供的api，封装成一个工具类方便调用。import{common}from'@kit.AbilityKit';import{scanBarcode,scanCore}from'@kit.ScanKit';exportnamespaceScanUtil{exportasyncfunctionstartScan(context:common.Context):Promise{if
  • C语言---程序设计练习题目及学习方法1 Wanyu677 C语言c语言学习方法算法
    学习方法要多练习在这些题目中的代码和题目自己动手去敲练习也是在熟悉语法，写代码第一步就是熟悉语法练习是在锻炼编程思维，把实际问题转换为代码的能力学会画图画图去理解内存，理解指针这些比较难懂的知识画图可以更好的理清思路辅助理解，强化理解学会调试借助调试，更好的理解代码和感知代码找出代码中的bug和程序逻辑（1）自增自减运算符inta=5,b,c,i=10;b=a++;c=++b;printf("a=
  • leetcode刷题day19|二叉树Part07（235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点） 小冉在学习 leetcode算法数据结构
    235.二叉搜索树的最近公共祖先思路：二叉搜索树首先考虑中序遍历。根据二叉搜索树的特性，如果p,q分别在中间节点的左右两边，该中间节点一定是最近公共祖先，如果在同一侧，则递归这一侧即可。递归三部曲：1、传入参数：根节点，p，q，返回节点。2、终止条件：因为p,q一定存在，所以不会遍历到树的最底层，因此可以不写终止条件3、递归逻辑：如果p,q均小于root的值，递归调用左子树；如果p,q均大于roo
  • Leetcode 3286. Find a Safe Walk Through a Grid Espresso Macchiato leetcode笔记leetcode3286leetcodemeidumleetcode双周赛139bfs最优路径
    Leetcode3286.FindaSafeWalkThroughaGrid1.解题思路2.代码实现题目链接：3286.FindaSafeWalkThroughaGrid1.解题思路这一题的话思路上就是一个宽度优先遍历，我们按照health进行排序进行宽度优先遍历，看看在health被消耗完之前是否可能走到终点即可。2.代码实现给出python代码实现如下：classSolution:deffin
  • uniapp实现动态标记效果详细步骤【前端开发】 2401_85123349 uni-app
    第二个点在于实现将已经被用户标记的内容在下一次获取后刷新它的状态为已标记。这是什么意思呢？比如说上面gif图中的这些人物对象，有一些已被该用户添加为关心，那么当用户下一次进入该页面时，这些已经被添加关心的对象需要以“红心”状态显现出来。这个点的难度还不算大，只需要在每一次获取后端的内容后对标记对象进行状态更新即可。II.动态标记效果实现思路和步骤首先，整体的思路是利用动态类名对不同的元素进行选择。
  • 2024年华为杯数学建模研赛C题思路代码+论文助攻 DS数模 2024华为杯数学建模华为2024华为杯2024研究生数学建模2024研赛
    2024年华为杯研究生数学建模竞赛（以下简研赛）将于9月21日上午8时正式开始。下文包含：2024研赛思路解析、研赛参赛时间及规则信息说明、好用的数模技巧及如何备战数学建模竞赛C君将会第一时间发布选题建议、所有题目的思路解析、相关代码、参考文献、参考论文等多项资料，帮助大家取得好成绩。2024年研赛将于9月21日上午8时正式开始这里有些资料，大家可以看看：【2024最全国赛研赛数模资料包】C君珍贵
  • 嵌入式单片机中数码管基本实现方法 嵌入式开发星球 单片机项目实战操作之优秀单片机
    1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
  • leetcode刷题day13|二叉树Part01（递归遍历、迭代遍历、统一迭代、层序遍历） 小冉在学习 leetcode算法职场和发展
    递归遍历思路：使用递归的方式比较简单。1、递归函数的传参：因为最后输出一个数组，所以需要传入根节点和一个容器，本来想写数组，但发现长度不能确定，所以选择list。2、终止条件：当访问的节点为空时，return3、递归函数的逻辑：先访问一个节点，递归访问其他节点144.二叉树的前序遍历代码如下：classSolution{publicListpreorderTraversal(TreeNoderoo
  • 关于日更的思考 暖益
    日更也有10天了，习惯还在养成的过程中，遇到一些问题。日更确实让我觉得有一些成长和思考，感觉也非常棒。但是最近日更遇到一些问题，一个是内容，一个是时间。【日更内容】想要写的内容其实很多，但是需要整理思路，花更多的时间思考，才能提高输出文章的质量。日更内容可通过得到的听书，日常的电影，或者学习获取。记得之前看过的《暗时间》，其中有一个方法就很适合用在此处，往头脑中放一个问题，有事没事拿出来思考或者找
  • Codeforces Round 972 (Div. 2) A-C 题解 AKDreamer_HeXY Codeforces比赛题解c++算法动态规划数据结构贪心算法
    本来以为B2难度会1900什么的，结果感觉1200还没有，先做的B1，后悔了QwQ关于我现场没切出C这件事……现场排名：A.SimplePalindrome题意构造一个长度为nnn的字符串，只包含aeiou五种字母，需要使得构造出来的字符串所包含的回文子序列数量最小思路当n≤5n\le5n≤5时，只要555个字母不重复出现都是最优情况当n>5n>5n>5时，可以证明：把相同字母放在一起是最优情况：
  • 学会这招！用python爬取微博评论（无重复数据） Python白白白白
    python爬取微博评论（无重复数据）前言一、整体思路二、获取微博地址1、获取ajax地址2、解析页面中的微博地址3、获取指定用户微博地址三、获取主评论四、获取子评论1、解析子评论2、获取子评论五、主函数调用1、导入相关库2、主函数执行3、结果写在最后Tip:本文仅供学习与交流，切勿用于非法用途！！！前言前段时间微博上关于某日记的评论出现了严重的两极分化，出于好奇的我想对其中的评论以及相关用户做一
  • 2021-10-03 虫虫新生111
    今天放假的第3天感觉过得好快，总体来说数学做了25道题，里边有几道题还是弄得不清楚，仍然不懂怎么做，不过整体感觉思路比去年要清晰很多，因为有去年的基础，今年还是比较轻松一些。逻辑做了有几道题，6题，错2，有些概念总的是模糊不清，还是要反复的再整理一下概念，以及回头看一下讲的基础知识，把基础的公式弄懂才可以。现在困了睡觉，明天早点起床。
  • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
    一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
  • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
    Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
  • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
    spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
  • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                            一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
  • java unix时间戳转换 g21121 java
    把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
  • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
    说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
  • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
    # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
  • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
    Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
  • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
    #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
  • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
    List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
  • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
    在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
  • http请求测试实例（采用fastjson解析） bijian1013 http测试
            在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
  • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
    RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
  • 【日志分析】日志分析工具 bit1129 日志分析
    1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
  • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
    　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
  • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
    思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
  • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
    Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
  • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
         如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
  • 软件专利如何申请 cuiyadll 软件专利申请
    软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
  • Android学习笔记 darrenzhu android
    1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
  • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
    现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
  • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
    速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
  • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
    转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
  • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
    一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
  • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
    使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
  • overrided方法编译错误 kane_xie override
    问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
  • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
    推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
  • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
    当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
  • C++中三种new的用法 _荆棘鸟_ C++new
    转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
  • Ruby深入研究笔记1 wudixiaotie Ruby
    module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他