SOURCE

// promise allsettled
function allSettled(promises) {
    return new Promise(resolve => {
      const data = [], len = promises.length;
      let count = len;
      for (let i = 0; i < len; i += 1) {
        const promise = promises[i];
        promise.then(res => {
          data[i] = { status: 'fulfilled', value: res };
        }, error => {
          data[i] = { status: 'rejected', reason: error };
        }).finally(() => { // promise has been settled
          if (!--count) {
            resolve(data);
          }
        });
      }
    });
}

// Promise.all
function all(promises) {
    let len = promises.length, res = []
    if (len) {
        return new Promise(function (resolve, reject) {
            for(let i=0; i<len; i++) {
                let promise = promises[i];
                promise.then(response => {
                    res[i] = response
                    // 当返回结果为最后一个时
                    if (res.length === len) {
                        resolve(res)
                    }
                }, error => {
                    reject(error)
                })
    
            }
        })
    }
}

// 防抖
function debounce(func, wait, immediate) {
    let timout;
    return function () {
        let context = this
        let args = arguments
        if (timout) clearTimeout(timout)
        if (immediate) {
            var callNow = !timeout;
            timeout = setTimeout(() => {
                timeout = null;
            }, wait)
            if (callNow) func.apply(context, args)
        } else {
            timeout = setTimeout(function(){
                func.apply(context, args)
            }, wait);
        }
    }
}

// 节流
function throttle1(func, delay) {
    let timer = null, // 用来保存setTimeout返回的值
        startTime = Date.now(); // 创建节流函数的时间

    // 返回一个函数
    return function() {
        let curTime = Date.now(), // 返回的这个函数被调用的时间
            remaining = delay - (curTime - startTime), // 设定的delay与[上一次被调用的时间与现在的时间间隔]的差值
            context = this, // 上下文对象
            args = arguments; // 返回的这个函数执行时传入的参数

        // 首先清掉定时器
        clearTimeout(timer); 

        // // 假如距离上一次执行此函数的时间已经超过了设定的delay，则执行
        if (remaining <= 0) { 
            func.apply(context, args);
            startTime = Date.now(); // 重置最后执行时间为现在

        // 否则，等到间隔时间达到delay时，执行函数
        } else {
            timer = setTimeout(() => {
                func.apply(context, args);
            }, remaining);
        }
    }
}

// flat 实现
 function flat(arr, deep = 1) {
    return deep > 0 ? arr.reduce((pre, cur) => {
        return pre.concat(Array.isArray(cur) ? flat(cur, --deep) : cur);
    }, [])
    : []
}

// 快排
function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  let pivotIndex = Math.floor(arr.length / 2);
  let pivot = arr.splice(pivotIndex, 1)[0];
  let left = [];
  let right = [];

  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat([pivot], quickSort(right));
};

// 反转链表
function ReverseList(pHead) {
    // write code here
    let pPre=null,
        pNext=null;
    while(pHead!==null){
        pNext=pHead.next;    //当前节点的下一个节点
        pHead.next=pPre;    //完成反转
        pPre=pHead;    //pPre往前走
        pHead=pNext;    //当前节点往前走
    }
    return pPre;
}

// 反转二叉树
function reverseTree(root) {
    if (root !== null) {
        let temp = root.left
        root.left = root.right
        root.right = temp
        reverseTree(root.left)
        reverseTree(root.right)
    }
    return root
}


// 深拷贝对象
function cloneDeep (obj) {
    let newObj = Array.isArray(obj) ? [] : {};
    if (obj && typeof obj === "object") {
        for (let i in obj) {
            let prop = obj[i]; // 避免相互引用造成死循环，如obj.a=obj
            if (prop == obj) {
                continue;
            }
            if (obj.hasOwnProperty(i)) {
                // 如果子属性为引用数据类型，递归复制
                if (prop && typeof prop === "object") {
                    newObj[i] = (prop.constructor === Array) ? [] : {};
                    arguments.callee(prop, newObj[i]); // 递归调用
                } else {
                    // 如果是基本数据类型，只是简单的复制
                    newObj[i] = prop;
                }
            }
        }
    }
    return newObj;
}

// 柯里化函数
function add () {
    let args = Array.prototype.slice.call(arguments)

    let temp = function () {
        args.push(...arguments)
        return temp
    }

    temp.toString = function () {
        return args.reduce(function(a, b) {
            return a+b
        })
    }
    return temp
}