js编码题总结 ​

for (var i = 0; i < 10; i++) {
    (function (i) {
        //闭包缓存
        setTimeout(() => {
            console.log(i);
        }, 0);
    })(i);
}

function _const(key, value) {
    const desc = {
        value,
        writable: false,
    };
    Object.defineProperty(window, key, desc);
}

_const("obj", { a: 1 }); //定义obj
obj.b = 2; //可以正常给obj的属性赋值
obj = {}; //抛出错误，提示对象read-only

function Lazyman(name) {
    return new _Lazyman(name);
}
class _Lazyman {
    constructor(name) {
        this.tasks = []; //设置任务队列
        let self = this;
        let task = (function (name) {
            return function () {
                console.log("Hello I'm " + name);
                self.next(); //因为没法for循环执行，所以只能console完就调用next来执行下一个
            };
        })(name); //闭包传参能缓存参数，最终返回函数，否则无法在next中向function传参
        this.tasks.push(task);
        //此时首次进入构造函数，tasks为[f]，调用方式为tasks[0]()
        //通过settimeout的方法，先执行链式调用和传参，最后才执行next()
        setTimeout(function () {
        self.next();
        }, 0);
    }
    next() {
        //取出一个任务并执行
        let task = this.tasks.shift();
        if (task) {
            task();
        }
    }
    eat(food) {
        let self = this;
        let task = (function (food) {
            return function () {
                console.log("Eat " + food);
                self.next();
            };
        })(food);
        this.tasks.push(task);
        return this; //链式调用
    }
    sleep(time) {
        let self = this;
        let task = (function (time) {
            return function () {
                setTimeout(function () {
                console.log("Wake up after " + time + " s!");
                self.next(); //setTimeout执行完才能执行下一个
                }, time * 1000);
            };
        })(time);
        this.tasks.push(task);
        return this;
    }
    sleepFirst(time) {
        let self = this;
        let task = (function (time) {
            return function () {
                setTimeout(function () {
                console.log("Wake up after " + time + " s!");
                self.next();
                }, time * 1000);
            };
        })(time);
        this.tasks.unshift(task); //函数最先执行，向队列头部插入函数
        return this;
    }
}
// Lazyman('Hank');
// Lazyman('Hank').sleep(5).eat('dinner');
// Lazyman('Hank').eat('dinner').eat('supper');
Lazyman("Hank").sleepFirst(5).eat("supper");

var person = {
    fullName: function (txt) {
    console.log(txt + this.firstName + " " + this.lastName);
    },
};
var person1 = {
    firstName: "John",
    lastName: "Doe",
};
person.fullName.call(person1, "Hello, ");
person.fullName.apply(person1, ["Hello, "]);
Function.prototype._apply = function (targetObject, argsArray) {
    // 是否传入执行上下文，若没有指定，则指向 window
    targetObject = targetObject || window;
    // 若是没有传递，则置为空数组
    argsArray = argsArray || [];
    // 利用Symbol的特性，设置为key
    const targetFnKey = Symbol("key");
    // 将调用_apply的函数赋值
    targetObject[targetFnKey] = this;
    // 执行函数，并在删除之后返回
    const result = targetObject[targetFnKey](...argsArray);
    delete targetObject[targetFnKey];
    return result;
};
Function.prototype._call = function (targetObject, ...argsArray) {
    // 是否传入执行上下文，若没有指定，则指向 window
    targetObject = targetObject || window;
    // 利用Symbol的特性，设置为key
    const targetFnKey = Symbol("key");
    // 将调用_call的函数赋值
    targetObject[targetFnKey] = this;
    // 执行函数，并在删除之后返回
    const result = targetObject[targetFnKey](...argsArray);
    delete targetObject[targetFnKey];
    return result;
};
//以下为es5版本
Function.prototype.myOwnCall = function (context) {
    context = context || window; //如果第一个参数传入的是null的情况下，this会指向window
    //防止与原对象方法重名
    var uniqueID = "00" + Math.random();
    while (context.hasOwnProperty(uniqueID)) {
        uniqueID = "00" + Math.random();
    }
    context[uniqueID] = this; //记录为调用的函数
    //Array.from(arguments).slice(1)
    var args = [];
    for (var i = 1; i < arguments.length; i++) {
        args.push("arguments[" + i + "]");
    }
    var result = eval("context[uniqueID](" + args + ")"); //传入参数，执行函数，处理函数返回值
    delete context[uniqueID]; //清除给原对象新增的方法
    return result;
};
Function.prototype.myOwnApply = function (context, arr) {
    context = context || window; //如果第一个参数传入的是null的情况下，this会指向window
    //防止与原对象方法重名
    var uniqueID = "00" + Math.random();
    while (context.hasOwnProperty(uniqueID)) {
        uniqueID = "00" + Math.random();
    }
    context[uniqueID] = this; //记录为调用的函数

    var args = [];
    var result = null;

    if (!arr) {
        result = context[uniqueID](); //没有第二个参数的情况
    } else {
        //有第二个参数的情况
        //Array.from(arguments).slice(1)
        for (var i = 0; i < arr.length; i++) {
            args.push("arr[" + i + "]");
        }
        result = eval("context[uniqueID](" + args + ")");
    }
    delete context[uniqueID]; //清除给原对象新增的方法
    return result;
};
person.fullName.myOwnCall(person1, "Hello, ");
person.fullName.myOwnApply(person1, ["Hello, "]);

window.color = 'red'
var o = {
    color:'blue'
}
function sayColor(color){
    console.log(this.color)
}
var objSayColor = sayColor.bind(o);
objSayColor(); //blue

Function.prototype.my_bind = function(context,...args) {
    var self = this;
    context = context || window;
    args = args || [];
    return function(...rest) {
        self.apply(context, args.concat(rest));
    }
}
//以下为es5
// 方法一，只可绑定，不可传参
Function.prototype.my_bind = function(context){
    var self = this;
    return function(){
        self.apply(context,arguments);
    }
}
Function.prototype.my_bind = function() {
    // 保存原函数
    var self = this,
    // 保存需要绑定的this上下文(获取传入的第一个参数),等价于 context = [].shift.call(arguments);
    context = Array.prototype.shift.call(arguments),
    // 剩余的参数转为数组
    args = Array.prototype.slice.call(arguments);
    // 返回一个新函数
    return function() {
        //处理a.my_bind(b, 7, 8)(9)多次传参的情况;
        //此处的arguments与上方的arguments，不是同一个arguments
        self.apply(context, Array.prototype.concat.call(args, Array.prototype.slice.call(arguments)));
    }
}

class a1{
  constructor(val){
    this.val = val
    this.a1 = function(){
      console.log(this.val)
    }
  }
  a2(){

  }
}
function a(val){
  this.val = val;
  this.a1 = function(){
    console.log(this.val)
  }
}
a.prototype.a2 = function(){}
let b = new a1(1);
let c = _new(a,1);//传a1会报错，es6的class必须new，否则apply报错:Uncaught TypeError: Class constructor a1 cannot be invoked without 'new'
console.log(b,c)

function _new() {
    let target = {};
    let [constructor, ...args] = [...arguments];
    console.log(constructor,args)
    target.__proto__ = constructor.prototype;
    let result = constructor.apply(target,args);
    if(result && (typeof result == 'object' || typeof result == 'function')) return result;
    return target;
}

function create(){
    //创建一个空对象
    let obj = new Object();
    //获取构造函数
    let fn = [].shift.call(arguments);
    //链接到原型
    obj.__proto__ = fn.prototype;
    //绑定this值
    let result = fn.apply(obj,arguments);//使用apply，将构造函数中的this指向新对象，这样新对象就可以访问构造函数中的属性和方法
    //返回新对象
    return typeof result === "object" ? result : obj;//如果返回值是一个对象就返回该对象，否则返回构造函数的一个实例对象
}

function instanceOf(left,right) {
    let proto = left.__proto__;
    let prototype = right.prototype;
    while(true) {
        if(proto === null) return false
        if(proto === prototype) return true
        proto = proto.__proto__;
    }
}

function _create(obj){
    function C(){}
    C.prototype = obj;
    return new C();
}

var obj1 = {name: "Lilei"};
var lilei = _create(obj1);
lilei; // {}
lilei.name; // "Lilei"

function deepClone(obj, hash = new WeakMap()) {
    if (obj instanceof RegExp) return new RegExp(obj);
    if (obj instanceof Date) return new Date(obj);
    if (obj === null || typeof obj !== "object") return obj;
    if (hash.has(obj)) {
        return hash.get(obj);
    }
    //obj为Array，相当于new Array()
    //obj为Object，相当于new Object()
    let constr = new obj.constructor();
    hash.set(obj, constr);
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            constr[key] = deepClone(obj[key], hash);
        }
    }
    return constr;
}
var o1 = new Object();
var o2 = new Object();
o1.next = o2;
o2.next = o1;
var target = [
    0,
    null,
    undefined,
    NaN,
    [1, 2],
    { name: "a", obj: { a: 1 } },
    function a() {
    return 1;
    },
    new Date("2020-01-01"),
    new RegExp(/aaa/),
    o1,
];

function deepClone(obj) {
    return JSON.parse(JSON.stringify(obj));
}

function debounce(fn, wait, immediate) {
    let timer = null;
    let one = immediate;
    return function (...args) {
        if (one) {
            one = false;
            fn(...args);
        } else {
            if (timer !== null) {
                clearTimeout(timer);
            }
            timer = setTimeout(() => {
                fn(...args);
            }, wait);
        }
    };
}
var handle = debounce(function (val) {
    console.log("搜索了" + val);
}, 1000,true)
window.onclick = function () {
    handle(Math.random())
}

function throttle(fn, wait, isDate, ...args) {
    let previous = 0;
    let timer = null;

    return function () {
        if (isDate) {
            let now = new Date().getTime();
            if (now - previous > wait) {
                previous = now;
                fn(...args);
            }
        } else {
            if (timer === null) {
                timer = setTimeout(() => {
                    timer = null;
                    fn(...args);
                }, wait);
            }
        }
    };
}

function handle(...a) {
    console.log(a, Math.random());
}

window.addEventListener("click", throttle(handle, 1000, true, 1,2,3));

// 支持多参数传递
const curry = (fn, ...args) =>
    args.length < fn.length
    ? (...arguments) => curry(fn, ...args, ...arguments)
    : fn(...args);

function sumFn(a, b, c) {
    return a + b + c;
}
var sum = curry(sumFn);
sum(1, 2, 3);
sum(1)(2, 3);
sum(1)(2)(3);

function add() {
    // 第一次执行时，定义一个数组专门用来存储所有的参数
    var _args = Array.prototype.slice.call(arguments);
    console.log(1, arguments, _args);
    // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
    var _adder = function () {
    _args.push(...arguments);
    console.log(2, arguments, _args);
    return _adder;
    };

    // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
    _adder.toString = function () {
        console.log(3, _args);
        return _args.reduce(function (a, b) {
            console.log(4, _args, a, b);
            return a + b;
        });
    };
    console.log(5, _args);
    return _adder;
}

add(1)(2)(3) = 6;
add(1, 2, 3)(4) = 10;
add(1)(2)(3)(4)(5) = 15;
add(1, 2, 3)(4, 5)(6) = 21;
/*
1 Arguments(3) [1, 2, 3, callee: ƒ, Symbol(Symbol.iterator): ƒ] (3) [1, 2, 3]
5 (3) [1, 2, 3]
2 Arguments(2) [4, 5, callee: ƒ, Symbol(Symbol.iterator): ƒ] (5) [1, 2, 3, 4, 5]
2 Arguments [6, callee: ƒ, Symbol(Symbol.iterator): ƒ] (6) [1, 2, 3, 4, 5, 6]
3 (6) [1, 2, 3, 4, 5, 6]
4 (6) [1, 2, 3, 4, 5, 6] 1 2
4 (6) [1, 2, 3, 4, 5, 6] 3 3
4 (6) [1, 2, 3, 4, 5, 6] 6 4
4 (6) [1, 2, 3, 4, 5, 6] 10 5
4 (6) [1, 2, 3, 4, 5, 6] 15 6
ƒ 21
*/

//es6
class injector{
    constructor(){
        this.hadinstance = true;
        console.log('实例化injector,只有hadinstance:',this.hadinstance);
    }
    A(){
        console.log('实例化A');
        return new A();
    }
    B(){
        console.log('实例化B');
        return new B();
    }
}
class myClass1{
    constructor(injector){
        this.myInjector = injector;
    }
}
class A{
    constructor(){
        this.a = 'a';
        this.say=function(){
            alert('A');
        }
    }
}
class B{
    constructor(){
        this.b = 'b';
        this.say=function(){
            alert('B');
        }
    }
}
let test = new myClass1(new injector());//实例化injector,只有hadinstance: true
Object.getOwnPropertyNames(test);//["myContainer"]
Object.getOwnPropertyNames(injector.prototype);//(3) ["constructor", "A", "B"]
Object.getOwnPropertyNames(new injector());//["hadinstance"]
Object.getOwnPropertyNames(new A());//(2) ["a", "say"]
test.myInjector.A().say();//实例化A
test.myInjector.B().b;//实例化B
//es5
function injector(){
    this.hadinstance = true;
    console.log('实例化injector,只有hadinstance:',this.hadinstance);
}
injector.prototype.A = function(){
    console.log('实例化A');
    return new A();
};
injector.prototype.B = function(){
    console.log('实例化B');
    return new B();
};
function myClass1(injector){
    this.myInjector = injector;
}
function A(){
    this.a = 'a';
    this.say=function(){
        alert('A');
    }
}
function B(){
    this.b = 'b';
    this.say=function(){
        alert('B');
    }
}

let test = new myClass1(new injector());//实例化injector,只有hadinstance: true
Object.getOwnPropertyNames(test);//["myContainer"]
Object.getOwnPropertyNames(injector.prototype);//(3) ["constructor", "A", "B"]
Object.getOwnPropertyNames(new injector());//["hadinstance"]
Object.getOwnPropertyNames(new A());//(2) ["a", "say"]
test.myInjector.A().say();//实例化A
test.myInjector.B().b;//实例化B

let Point = class Point {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }

    toString() {
        return '(' + this.x + ', ' + this.y + ')';
    }

    //属性名
    [methodName]() {

    }

    //不可继承的静态方法
    static classMethod() {
        return 'hello';
    }

    get prop() {
        return 'getter';
    }
    set prop(value) {
        console.log('setter: '+value);
    }
}

let ColorPoint = class ColorPoint extends Point {
    constructor(x, y, color) {
        super(x, y); // 调用父类的constructor(x, y),super后才能使用this
        this.color = color;
    }

    toString() {
        return this.color + ' ' + super.toString(); // 调用父类的toString()
    }
}

let colorPoint = new ColorPoint(1,2,'red');
console.log(colorPoint.toString());

function createObject(o){
    function fn(){}
    fn.prototype = o;
    return new fn();
}
function Son(){
    Father.call(this)
}
Son.prototype = createObject(Father.prototype)
Son.prototype.constructor = Son;
var son = new Son('son');
console.log(son.sleep()) // son正在睡觉
console.log(son.look('TV')) // son正在看TV

function createPerson(name, age) {
    var obj = {};
    obj.name = name;
    obj.age = age;
    obj.say = function () {
        console.log('hello' + this.name);
    }
    return obj;
}
var p1 = createPerson('aaa' , 26);
p1.say();

class People {
    constructor(name) {
        if (typeof People.instance === 'object') {
            return People.instance;
        }
        People.instance = this;
        this.name = name;
        return this;
    }
}
var a = new People('a');//People {name: "a"}
var b = new People('b');//People {name: "a"}
console.log(a===b);//true
//es5
function People(name) {
    this.name = name;
}

People.getInstance = function(name) {
    if (!this.instance) {
        this.instance = new People(name);
    }
    return this.instance;
}

var a = People.getInstance('a');//People{name: "a"}
var b = People.getInstance('b');//People{name: "a"}
console.log(a===b);//true

function Animal(name) {
    this.name = name
}

const AnimalSingle = (function () {
    let animalSingle = null

    return function (name) {
        if(animalSingle){
            return animalSingle
        }
        return animalSingle = new Animal(name)
    }
})();

const animal1 = new AnimalSingle('dog')
const animal2 = new AnimalSingle('cat')

console.log(animal1.name); // dog
console.log(animal2.name); // dog

class PubSub {
    constructor() {
        this.handles = {};
    }

    // 订阅事件
    on(eventType, handle) {
        if (!this.handles.hasOwnProperty(eventType)) {
            this.handles[eventType] = [];
        }
        if (typeof handle == 'function') {
            this.handles[eventType].push(handle);
        }
        else {
            throw new Error('缺少回调函数');
        }
        return this;
    }

    // 发布事件
    emit(eventType, ...args) {
        if (this.handles.hasOwnProperty(eventType)) {
            this.handles[eventType].forEach((item, key, arr) => {
                item.apply(null, args);
            })
        }
        else {
            throw new Error(`"${eventType}"事件未注册`);
        }
        return this;
    }

    // 删除事件
    off(eventType, handle) {
        if (!this.handles.hasOwnProperty(eventType)) {
            throw new Error(`"${eventType}"事件未注册`);
        }
        else if (typeof handle != 'function') {
            throw new Error('缺少回调函数');
        }
        else {
            this.handles[eventType].forEach((item, key, arr) => {
                if (item == handle) {
                    arr.splice(key, 1);
                }
            })
        }
        return this; // 实现链式操作
    }
}

let callback = function () {
    console.log('you are so nice');
}

let pubsub = new PubSub();
pubsub.on('completed', (...args) => {
    console.log(args.join(' '));
}).on('completed', callback);

pubsub.emit('completed', '1', '2', '3');
pubsub.off('completed', callback);
pubsub.emit('completed', '4', '5');

const EventEmit = function() {
    this.events = {};
    this.on = function(name, cb) {
        if (this.events[name]) {
            this.events[name].push(cb);
        } else {
            this.events[name] = [cb];
        }
    };
    this.trigger = function(name, ...arg) {
        if (this.events[name]) {
            this.events[name].forEach(eventListener => {
                eventListener(...arg);
            });
        }
    };
};
//业务
let event = new EventEmit();
event.trigger('success');
MessageCenter.fetch() {
    event.on('success', () => {
        console.log('更新消息中心');
    });
}
Order.update() {
    event.on('success', () => {
        console.log('更新订单信息');
    });
}
Checker.alert() {
    event.on('success', () => {
        console.log('通知管理员');
    });
}

class Promise {
    constructor(executor) {
    this.status = "pending"; // 初始化状态
    this.value = undefined; // 初始化成功返回的值
    this.reason = undefined; // 初始化失败返回的原因

    // 解决处理异步的resolve
    this.onResolvedCallbacks = []; // 存放所有成功的resolve
    this.onRejectedCallbacks = []; // 存放所有失败的reject

    /**
    * @param {*} value 成功返回值
    * 定义resolve方法
    * 注意：状态只能从pending->fulfilled和pending->rejected两个
    */
    const resolve = (value) => {
        if (this.status === "pending") {
            this.status = "fulfilled"; // 成功时将状态转换为成功态fulfilled
            this.value = value; // 将成功返回的值赋值给promise
            // 为了解决异步resolve以及返回多层promise
            this.onResolvedCallbacks.forEach((fn) => {
                fn(); // 当状态变为成功态依次执行所有的resolve函数
            });
        }
    };
    const reject = (reason) => {
        if (this.status === "pending") {
            this.status = "rejected"; // 失败时将状态转换为成功态失败态rejected
            this.reason = reason; // 将失败返回的原因赋值给promise
            this.onRejectedCallbacks.forEach((fn) => {
                fn(); // 当状态变为失败态依次执行所有的reject函数
            });
        }
    };
    executor(resolve, reject); // 执行promise传的回调函数
    }
    /**
    * 定义promise的then方法
    * @param {*} onFulfilled 成功的回调
    * @param {*} onRejected 失败的回调
    */
    then(onFulfilled, onRejected) {
    // 为了解决then方法返回Promise的情况
    const promise2 = new Promise((resolve, reject) => {
        if (this.status === "fulfilled") {
            // 如果状态为fulfilled时则将值传给这个成功的回调
            setTimeout(() => {
                const x = onFulfilled(this.value); // x的值有可能为 promise || 123 || '123'...
                // 注意：此时调用promise2时还没有返回值，要用setTimeout模拟进入第二次事件循环；先有鸡先有蛋
                resolvePromise(promise2, x, resolve, reject);
            }, 0);
        }
        if (this.status === "rejected") {
            setTimeout(() => {
                const x = onRejected(this.reason); // 如果状态为rejected时则将视频的原因传给失败的回调
                resolvePromise(promise2, x, resolve, reject);
            }, 0);
        }
        if (this.status === "pending") {
            // 记录-》解决异步
            this.onResolvedCallbacks.push(() => {
                setTimeout(() => {
                const x = onFulfilled(this.value);
                resolvePromise(promise2, x, resolve, reject);
                }, 0);
            });
            this.onRejectedCallbacks.push(() => {
                setTimeout(() => {
                const x = onRejected(this.reason);
                resolvePromise(promise2, x, resolve, reject);
                }, 0);
            });
        }
    });
    return promise2; // 解决多次链式调用的问题
    }
}

const resolvePromise = (promise2, x, resolve, reject) => {
    // console.log(promise2, x, resolve, reject)
    if (promise2 === x) {
    // 如果返回的值与then方法返回的值相同时
    throw TypeError("循环引用");
    }
    // 判断x是不是promise;注意：null的typeof也是object要排除
    if (typeof x === "function" || (typeof x === "object" && x !== null)) {
        try {
            const then = x.then; // 获取返回值x上的then方法；注意方法会报错要捕获异常；原因111
            if (typeof then === "function") {
                // 就认为是promise
                then.call(
                    x,
                    (y) => {
                    // resolve(y)
                    // 递归解析 ; 有可能返回多个嵌套的promise
                    resolvePromise(promise2, y, resolve, reject);
                    },
                    (r) => {
                    reject(r);
                    }
                );
            }
        } catch (e) {
            reject(e);
        }
    } else {
        resolve(x);
    }
};
module.exports = Promise;

Promise.resolve = function(value) {
    // 如果是 Promsie，则直接输出它
    if(value instanceof Promise){
        return value
    }
    return new Promise(resolve => resolve(value))
}

Promise.reject = function(reason) {
    return new Promise((resolve, reject) => reject(reason))
}

Promise.all = function (promises) {
    //省略参数合法性检查
    return new Promise((resolve, reject) => {
        promises = Array.from(promises);
        if (promises.length === 0) {
            resolve([]);
        } else {
            let result = [];
            let index = 0;
            for (let i = 0; i < promises.length; i++) {
                Promise.resolve(promises[i]).then(
                    (data) => {
                        result[i] = data;
                        if (++index === promises.length) {
                            resolve(result);
                        }
                    },
                    (err) => {
                        reject(err);
                        return;
                    }
                );
            }
        }
    });
};
var p = Promise.all([1, 2, 3]);
// Promise {<resolved>: Array(3)}
// __proto__: Promise
// [[PromiseStatus]]: "resolved"
// [[PromiseValue]]: Array(3)
// 0: 1
// 1: 2
// 2: 3
// length: 3
// __proto__: Array(0)
var p2 = Promise.all([1, 2, 3, Promise.resolve(444)]);
// Promise {<resolved>: Array(4)}
// __proto__: Promise
// [[PromiseStatus]]: "resolved"
// [[PromiseValue]]: Array(4)
var p3 = Promise.all([1, 2, 3, Promise.reject(555)]);
// Promise {<rejected>: 555}
// __proto__: Promise
// [[PromiseStatus]]: "rejected"
// [[PromiseValue]]: 555

Promise.ra_ce = function (promises) {
    promises = Array.from(promises);
    return new Promise((resolve, reject) => {
        if (promises.length === 0) {
            return;
        } else {
        for (let i = 0; i < promises.length; i++) {
            Promise.resolve(promises[i]).then(
                (data) => {
                    resolve(data);
                    return;
                },
                (err) => {
                    reject(err);
                    return;
                }
            );
        }
        }
    });
};

Promise.prototype.finally = function (callback) {
    return this.then(
        (value) => {
            return Promise.resolve(callback()).then(() => {
                return value;
            });
        },
        (err) => {
            return Promise.resolve(callback()).then(() => {
                throw err;
            });
        }
    );
};

Promise.allSettled = function(promises) {
    let count = 0
    let result = []
    return new Promise((resolve, reject) => {
        promises.forEach((promise, index) => {
            Promise.resolve(promise).then(res => {
                result[index] = {
                    value: res,
                    reason: null,
                }
            }, err => {
                result[index] = {
                    value: null,
                    reason: err,
                }
            }).finally(() => {
                count++
                if (count === promises.length) {
                    resolve(result)
                }
            })
        })
    })
}