【面试题】常见面试题汇总————手写题

方法类

数组去重排序

经典问题方法要尽可能多

let arr = [9,9,8,8,1,2,5,2,3,4,5,5,5];

//1、使用set方法

let num = [...new Set(arr)].sort((a,b) => a - b);
//console.log(num);

//2、使用indexof

function unique(arr){
    let res = [];
    for(let i = 0; i < arr.length; i++){
        if(res.indexOf(arr[i]) == -1){
            res.push(arr[i]);
        }
    }

    return res;
}

//排序
console.log(unique(arr));

//写一个快速排序

function quicksort(arr){
    if(arr.length <= 1) return arr;

    let left = [];
    let right = [];
    let index = Math.floor(arr.length/2);
    let pivot = arr.splice(index,1)[0];
    //arr = arr.splice(index,1)[0];

   
    for(let 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));
    
}

let step1= unique(arr);
console.log(quicksort(step1));

这里面包含了去重方法和排序方法

数组去重

Array.from(new Set(arr));

[...new Set(arr)];

function unique(arr){
    const h = Object.create(null)
    arr.forEach(v => h[v] = 1)
    return Object.keys(h).map(v => v | 0);
}

function unique (arr) 
{ const h = new Map() 
    arr.forEach(v => h.set(v, 1)) 
    return Array.from(h.keys()) 
}

function unique(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);
                j--;
            }
        }
    }
    return arr;
}

function unique(arr){
    return arr.filter((v,index,ar) => ar.indexOf(v) === index);
}


function unique(arr){
    const r = [];
    arr.forEach(v => !r.includes(v) && r.push(v))
    return r
}

function bubbleSort(arr){
    for(let i = 0; i < arr.length; i++){
        for(let j = i+1; j < arr.length; j++){
            if(arr[j] < arr[i]){
                [arr[j],arr[i]] = [arr[i],arr[j]];
            }
        }
    }
    return arr;
}

const sort = (a) => {
    for(let i = 0; i < a.length; i++){
        for(let j = i; j-- && a[j+1] < a[j]){
            [a[j+1],a[j]] = [a[j],a[j+1]];
        }
    }
    return a;
}

数组排序

sort()，快排，冒泡

数组拍平，降维

//数组拍平，多维数组降维

let arr = [1,[2,[3,3,4]],[2,3]];

function flaten(arr){
    let arr1 = [];
    for(let i = 0; i < arr.length;i++){
        if(arr[i] instanceof Array){
            arr1 = arr1.concat(flaten(arr[i]));
        }else{
            arr1.push(arr[i])
        }
    }

    return arr1;
}


function flaten(arr){
    return arr.reduce((prev,cur) => {
        return prev.concat(Array.isArray(cur) ? flaten(cur):cur)
    })
}

let arr1 = arr.toString().split(',').map((val) => {
    return parseInt(val);
})

判断一个数组是不是数组

Array.prototype.isPrototypeof(o);

o instanceof Array

Array.isArray(o);

Object.prototype.toString.call(o) === '[object Array]'

二级目录

lc编程类

全排列

const permute = function(nums){
    const res = [],path =[] ;
    let used = new Array(nums.length).fill(false);
    backtracking(nums,nums.length,[]);
    return res;

    function backtracking(n,k,used){
        if(path.length === k){
            res.push(Array.from(path));
            return;
        }

        for(let i = 0; i <k; i++){
            if(used[i]) continue;
            path.push(n[i]);
            used[i] = true;
            backtracking(n,k,used);
            path.pop();
            used[i] = false;
        }
    }
}

js实现类

手写promise

手写then

手写instanceof

function my_instanceof(left,right){
    let l_proto = left.__proto__;
    let a = right.prototype;

    while(true){
        if(l_proto === null){
            return false;
        }

        if(l_proto === a){
            return true;
        }

        l_proto = l_proto.__proto__;
        
    }


}

节流防抖

//节流
var timer;

function debounce(fn,delay){
    clearTimeout(timer);
    timer = setTimeout(function(){
        fn();
    },delay)
}

深浅拷贝

//object.assign()
//第一个参数是目标对象，其余参数是源对象

let target = {a:1}
let object1 = {b:2};
let object2 = {c:2,b:3,a:2};


//第一个参数是目标对象，剩下的是源，把没有的拷贝上，后面的同名属性会覆盖前面的
Object.assign(target,object1,object2);
//console.log(target);

//扩展运算符，在构造字面量对象的时候，进行属性拷贝，语法 
//浅拷贝，一个对象的深拷贝，嵌套的浅拷贝？？？？
let obj1 = {a:1,b:{c:1}};
let obj2 = {...obj1};
obj1.a = 2;

// console.log(obj2);
// console.log(obj1);

// obj1.b.c = 33;
// console.log(obj1);
// console.log(obj2);

//数组方法实现数组浅拷贝
//Array.prototype.slice()
//Array.prototype.concat(),两个参数都不写，就会返回一个数组的浅拷贝

//手写实现浅拷贝
function shallowCopy(object){
    //只拷贝对象
    if(!object || typeof object !== "object") return;
    //根据类型决定新建一个数组还是对象
    let newObject = Array.isArray(object)?[]:{};
    //遍历object，并且判断是object的属性才拷贝
    for(let key in object){
        if(object.hasOwnProperty(key)){//原型上的属性就不拷贝了
            newObject[key] = object[key];
        }
    }

    return newObject;
}

//深拷贝
//遇到属性值为引用类型的时候，新建一个引用类型并将对应的值复制给他
/*
获得一个新的引用类型而不是原有类型的引用，
*/

//JSON.stringify()
/*
的原理就是利用JSON.stringify 将js对象序列化（JSON字符串）
再使用JSON.parse来反序列化(还原)js对象。

拷贝的对象中如果有函数，undefined，symbol，
当使用过JSON.stringify()进行处理之后，都会消失。

*/

var objk = {
    a:0,
    b:{
        c: 0
    }
};

let obj3 = JSON.parse(JSON.stringify(objk));
objk.a = 1;
objk.b.c = 1;

/*
库函数lodash也提供了深拷贝方法，_.cloneDeep
*/
var _ = require('lodash');
var obj8 = {
    a:1,
    b:{f: { g: 1}},
    c: [1,2,3]
};

var obj4 = _.cloneDeep(obj8);
obj1.b.f.g = 1234
//console.log(obj4);

function deepCopy(object){
	if(!object||typeof object !== "object") return;
	let newObject=Array.isArray(object)?[]:{};
	for(let key in object){
		if(object.hasOwnProperty(key)){
			newObject[key]=typeof object[key]==="object"?deepCopy(object[key]):object[key];
		}
	}
	return newObject;
}

promise实现3秒后输出123

//3s输出111

function my_print(num){
    let res = new Promise(function(res,err) {
            setTimeout(function(){
                res(num);
            },1000)
    })

    return res;
}

my_print(123).then(res => {
    console.log(res);
})

promise.all

Promise.myAll = function(promiseArr){
    return new Promise((resolv,reject) => {
        const ans = [];
        let index = 0;
        for(let i = 0; i < promiseArr.length; i++){
            promiseArr[i].then(res => {
                ans[i] = res;
                index++;
                if(index === promiseArr.length){
                    this.resolve(ans);
                }
            })
            .catch(err => reject(err));
        }
    })
}

promise.race

Promise.race = function(arr){
    return new Promise(function(resolve,reject){
        if(!Array.isArray(arr)){
            return reject(new TypeError('promise.race accepts an array'))
        }

        for(var i = 0, len = arr.length; i < len; i++){
            Promise.resolve(arr[i]).then(resolve,reject);
        }
    });
}