每日一题：算法题

1、实现一个批量请求，multiRquest(urls, maxnum);(20210608)

• 最大并发树为maxnum
• 每当有一个请求返回，就留下一个空位，可以增加新的需求
• 所以请求完成后，结果按照urls的顺序依次输出

class multiRquest {
    constructor(urls, num) {
        this.len = urls.length;
        this.results = [];
        this.curUrls = urls.slice(0, num);
        this.restUrls = urls.slice(num, this.len);

        this.curUrls.forEach(url => {
            this.ajax(url);
        })
    }

    ajax(url) {
        fetch(url).then(res => {
            this.results.push(url);
            console.log(this.restUrls)
            if(this.restUrls.length > 0) {
                let nextUrl = this.restUrls.shift();
                this.ajax(nextUrl);
            }
        })
    }


}

const req = new multiRquest([1,2,3,3,4,5,6,7], 2)

2、手动实现Array.flat(arr, num); (20210609)

class arrayFlat {
    constructor(arr, num) {
        if(!Array.isArray(arr)) {
            console.error('请输入正确的数组格式！')
            return;
        }
        this.index = 0;
        this.num = num;
        this.result = [];
        this.trueRes = arr.flat(num);

        if(arr.length) {
            this.index++;
            arr.map(ar => {
                this.flatItem(ar);
            })
        }
    }

    flatItem(item) {
        if(this.num >= this.index) {
            if(Array.isArray(item)) {
                this.index++;
                item.map(i => {
                    this.flatItem(i);
                });

                return;
            };

        }
        this.result.push(item);
    }
}

let arr = new arrayFlat([1,2,3,[1,2,[2,3]]], 1);

3、手写promise.all; (20210610)

let promiseAll = function(arr) {
    return new Promise((resolve,reject) => {
        let len = arr.length;
        let count = 0;
        let result = [];

        for(let i = 0; i < len; i++) {
            Promise.resolve(arr[i]).then(res => {
                count++;
                result[i] = res;
                if(count == len) {
                    return resolve(result);
                }
            }, err => {
                reject(err);
            })
        }
    })
}

4、防抖和节流

// 防抖：当一个事件需要延时执行回调的时候，多次触发事件后都要重新开始计时；
function debounce (delay, cb) {
    let timer = null;

    return function(...arg) {
        if(timer) {
            clearTimeout(time);
        }

        timer = setTimeout(function() {
            cb.apply(this,arg);
        }, delay);
    }
}
// 节流：事件多次触发，我们拦截事件，在10s内只执行一次
function throttle(delay, cb) {
    let pretime = 0;

    return function(...arg) {
        let now = +new Date();
        if(now - pretime > delay) {
            pretime = now;
            cb.call(this.arg);
        }
    }
}

5、数组去重

function unique(arr) {
    if(Array.isArray(arr)) {
        console.error('请输入正确的数据格式！');
        return;
    }

    let obj = {};
    let result = [];
    arr.length && arr.map(item => {
        if(!obj[item]) {
            obj[item] = 1;
            result.push(item);
        }
    })

    return result;
}

function unique2(arr) {
    if(Array.isArray(arr)) {
        console.error('请输入正确的数据格式！')；
        return;
    }
    return [...new Set(arr)];
}

6、数组排序

// 冒泡排序
const bubble = (arr) {
    let len = arr.length;
    for(let i = len - 1; i > 1; i--) {
        for(j = 0; j < i - 1; j++) {
            if(arr[j+1] > arr[j]) {
                let res = arr[j];
                arr[j+1] = arr[j];
                arr[j] = res;
            }

        }
    }
    return arr;
}
// 选择排序
const selectSort = (arr) => {
    let len = arr.length;
    for(let i = 0; i < len; i++) {
        for(let j = i; j < len; j ++) {
            if(arr[j] < arr[i]) {
                [...arr[i], arr[j]] = [...arr[j], arr[i]];
            }
        }
    }

    return arr;
}
// 快速排序
const quickSort = (arr) => {
    if(arr.length < 2) {
        return arr;
    }
    
    let len = arr;
    let left = [], right = [];
    let first = arr[0];

    for(let i = 1; i < len; i++) {
        if(arr[i] > first) {
            right.push(arr[i])
        } else {
            left.push(arr[i])
        }
    }

    return quickSort(left).concat(first, quickSort(right));
}