前端js基础面试题总结(不定时更新)

1. 数组排序

• 冒泡排序

function popSort(list) {
    for (let i = 0; i < list.length - 1; i++) {
        for (let j = 0; j < list.length - i - 1; j++) {
            if (list[j] > list[j + 1]) {
                let temp = list[j];
                list[j] = list[j + 1];
                list[j + 1] = temp;
            }
        }
    }
    return list;
}

• 快速排序

function quickSort(list) {
    if (list.length <= 1) {
        return list;
    }
    let left = [];
    let right = [];
    let mid = Math.floor(list.length / 2);
    let midItem = list.splice(mid, 1);
    for (let i = 0; i < list.length; i++) {
        if (list[i] <= midItem) {
            left.push(list[i])
        } else {
            right.push(list[i]);
        }
    }
    return quickSort(left).concat(midItem, quickSort(right));
}

• sort排序

function jsSort(list) {
    return list.sort((a, b) => a - b);
}

2. 数组去重

• new Set方法

function uniq(list) {
    return [...new Set(list)];
}

• map方法(不用对象是因为无法区分obj[1]和obj['1'])

function uniq(list) {
    let map = new Map();
    let arr = [];
    for (let i = 0; i < list.length; i++) {
        if (!map.has(list[i])) {
            map.set(list[i], true);
            arr.push(list[i]);
        }
    }
    return arr;
}

3. 写一个函数，这个函数会返回一个数组，数组里面是 2 ～ 32 之间的随机整数(不能重复) ，这个函数还可以传入一个参数，参数是几，返回的数组长度就是几;

function randomList(num = 10) {
    let initNum = 32 - 2 + 1;
    if (num > initNum) {
        num = initNum;
    }
    let list = Array(initNum).fill(1).map((item, index) => index + 2);
    let arr = [];
    for (let i = 0; i < num; i++) {
        let index = Math.floor((Math.random() * list.length));
        let temp = list.splice(index, 1)[0];
        arr.push(temp);
    }
    return arr;
}

4.实现fn(1)(2)(3, 4)的值为10

function curry(...args) {
    let _args = [...args];
    function fn(...fnArgs) {
        _args = _args.concat(fnArgs);
        return fn;
    }
    fn.toString = function() {
        return _args.reduce((a, b) => a + b);
    }
    return fn;
}

5.利用promise实现最大请求数为10的函数

class Limit {
    constructor(max = 10) {
        this.max = max;
        this.count = 0;
        this.queue = [];
    }
    
    runCall(caller, ...args) {
        return new Promise((resolve, reject) => {
            let task = this.createTask(caller, resolve, reject, args);
            if (this.count >= this.max) {
                this.queue.push(task);
            } else {
                task();
            }
        });
    }
    
    createTask(caller, resolve, reject, args) {
        return () => {
            this.count++;
            caller(...args).then(resolve).catch(reject).finally(() => {
                if (this.queue.length > 0) {
                    let task = this.queue.shift();
                    task();
                }
            });
        };
    }
}

6.青蛙跳台阶，一次可以跳1级也可以跳2级，请实验一个函数，实现跳10级台阶总共有多少种可能性

• 典型的斐波那契函数

function fb(n = 10) {
    if (n === 1) {
        return 1;
    }
    return n <= 2 ? 2 : fb(n - 2) + fb(n - 1);
}