......

1.promise.all

function myAll(promises){
    return new Promise((resolve,reject) => {
        results = []
        // 迭代数组中的 Promise，将每个 promise 的结果保存到一个数组里
        let counter = 0
        for (let i = 0; i < promises.length; i++) {
            // 如果不是 Promise 类型要先包装一下
            // 调用 then 得到结果
            Promise.resolve(promises[i]).then(res => {
                // 这里不能用 push()，因为需要保证结果的顺序。感谢评论区大佬的批评指正
                results[i] = res
                counter++
                // 如果全部成功，状态变为 fulfilled
                if(counter === promises.length){
                    resolve(results)
                }
                },err => { // 如果出现了 rejected 状态，则调用 reject() 返回结果
                reject(err)
            })
        }
    }
)
}
 
// test
let p1 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        resolve(1)
    }, 1000)
})

2.promise.race

function myRace(promises) {
    return new Promise((resolve, reject) => {
        promises.forEach(promise => {
            Promise.resolve(promise).then(res => {
                resolve(res)
            }, err => {
                reject(err)
            })
        })
    })
}

3.new apply bind

1.防抖节流

        let time = null;//定义定时器，
        return function(){
            let context = this;
            let args = arguments;
            if(time) clearTimeout(time);
            
            var firstClick = !time; 
            //如果是第一次点击则立即执行
            if(firstClick){
                func.apply(context,arguments)
            }
            time = setTimeout(function(){
                time=null;
            },delay);
        }
    }
    
    function throttle(func,delay){
        let timer = null
        return function(...args){
            if(!timer){
                timer = setTimeout(()=>{
                    func.call(this,...args)
                    //完成一次计时
                    timer = null
                },delay)
            }
        }
    }

2.数组去重

           1.Set  Array.from(new Set(array))   [...new Set(array)]
           2.filter 判断是不是首次出现
           3.创建一个新数组，之前没加入就加入 indexOf()

3.JsonP

let jsonP = function (url, data, callback) {
    let dataStr = url.indexOf('?') === -1 ? '?' : '&'
    for (let key in data) {
        dataStr += `${key}=${data[key]}`
    }
    let cb_name = 'jsonPcallback'
    dataStr += 'callback=' + cb_name

    let scriptBody = document.createElement('script')
    scriptBody.src = url + dataStr

    window[cb_name] = function (data) {
        callback(data)
        document.removeChild(scriptBody)
    }

    document.body.append(scriptBody)
}

4.filter

Array.prototype.myFilter = function(fn){
    let newArr = []
    for(let i = 0; i< this.length; i++){
        if(fn(this[i])){
            newArr.push(this[i])
        }
    }
    return newArr
}

5.深拷贝

const checkedType = (target) => {
    return Object.prototype.toString.call(target).slice(8, -1);
}
const deepClone = (target) => {
    //判断拷贝数据类型
    //初始化变量 result成为最终数据
    let result, targetType = checkedType(target)
    if (targetType === 'Object') {
        result = {}
    }
    else if (targetType === 'Array') {
        result = []
    }
    else {
        return target
    }
    //遍历目标数据
    for (let i in target) {
        let value = target[i]
        if (checkedType(value) === 'Object' || checkedType(value) === 'Array') {
            result[i] = deepClone(value)
        } else {
            result[i] = value
        }
    }
    return result
}