面试中出现的经典题

方法类数组去重排序数组去重数组排序数组拍平，降维判断一个数组是不是数组二级目录lc编程类全排列js实现类手写promise手写then手写instanceof节流防抖深浅拷贝promise实现3秒后输出123promise.allpromise.race

方法类

数组去重排序

经典问题方法要尽可能多

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、使用indexoffunction 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 ArrayArray.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输出111function 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);}});}