前端笔试题1

实现函数柯里化,类似于add(1)(2,3)(4)

原理是通过argument和递归获取不断获取函数的参数列表，最后返回结果。

    function myCurry(){
        const _args = [...argument];
        return function fn(){
            _args.push(...arguments)
            fn.add = function() {
                return _args.reduce((pre, cur)=> pre + cur)
            }
            return fn
        }
    }

实现new

在函数内部创建一个新对象，把该对象的原型指向参数对象的prototype对象，把this指向新建对象，绑定方法，最后如果参数对象不是Object类型则返回新对象，否则返回执行后的结果

function myNew(Obj, ...args){
    const obj = Object.create(Obj.prototype);
    const res = Obj.apply(obj, args);
    if(obj instanceof Object) return result;
    else return obj;
}

实现数组扁平化

可以直接使用js的flat方法，也可以用递归和栈方法

const arr = [1,2,3,[4,5],6];
// 1。使用flat
console.log(arr.flat());
// 2.使用递归
const recurseFlat = (arr) => {
    const _arr = [];
    arr.forEach((item, index)=> {
        if(!Array.isArray()) _arr.push(item);
        else _arr = _arr.concat(recurseFlat(item))
    })
    return _arr;
}
// 3.使用栈
const stackFlat = (arr) => {
    const _arr = [...arr]
    const res = []
    while(_arr.length){
        let item = _arr.pop()
        if(!Array.isArray()) res.unshift(item)
        else _arr.push(...item)
    }
    return res
}

实现数组去重

const arr = [1, 1, 2, 2, 3, 4, 5];
//利用Set
console.log(Array.from(new Set(arr)));
// 双层循环
const dedupDouble = (arr) => {
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j]) {
                arr.splice(j, 1);
            }
        }
    }
    return arr;
}
//利用Map
const mapDedup = (arr) => {
    let res = new Map();
    let arr1 = [];
    arr.map((item, index) => {
        if(!res.has(item)) {res.set(item, true); arr1.push(item)}
    })
    console.log(arr1);
    return res;
}
//利用indexOf
const indexOfDedup = (arr) => {
    let res = [];
    arr.map((item, index) => {
        if (res.indexOf(item) === -1) res.push(item)
    })
    return res;
}

实现apply

const myApply(context, args) => {
    context = context || window
    context.fn = this
    const res = context.fn(...args)
    delete context.fn
    return res
}

实现call

const myCall(context, ...args) => {
    context = context || window
    context.fn = this
    const res = context.fn(...args)
    delete context.fn
    return res
}

实现bind

const myBind(context, args1) => {
    context = context || window
    return function(args2){
         let args = [...args1, ...args2]
        let result = context.fn(...args)
        delete context.fn
        return result
    }
}

实现instancef

const myInstanceof = (left, right) => {
    let proto = Object.getPrototypeOf(left)
    while(true) {
        if(proto === right.prototype) return true
        if(proto === null ) return false
        proto = Object.getPrototypeOf(proto)
    }
}