常见面试题

1.节流函数封装

function throttle (fn,  delay = 1000) {
    let timer = null;
    let firstTime = true;

    return function (...args) {
        if (firstTime) {
          // 第一次加载
            fn.apply(this, args);
            return firstTime = false;
        }
        if (timer) {
          // 定时器正在执行中，跳过
            return;
        }
        timer = setTimeout(() => {
            clearTimeout(timer);
            timer = null;
            fn.apply(this, args);
        },  delay);
    };
}

2.防抖函数封装

let btn = document.getElementsByClassName("btn")[0]

​      let time;

​      btn.onclick = function () {

​        clearTimeout(time)

​        time = setTimeout(fangdou, 3000)

​      }

​      function fangdou() {

​        let div = document.getElementsByClassName("div")[0]

​        div.innerHTML += "别点了"

​      }

3.数组去重（禁止使用ES6方法）

var arra = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN,'NaN', 0, 0, 'a', 'a', {}, {}];



​    function unique(arr) {

​      for (var i = 0; i < arr.length; i++) {

​        for (var j = i + 1; j < arr.length; j++) {

​          if (arr[i] == arr[j]) { //第一个等同于第二个，splice方法删除第二个

​            arr.splice(j, 1);

​            j--;

​          }

​        }

​      }

​      return arr;

​    }

​    console.log(unique(arra))

4.深克隆函数（禁止使用JSON.parse及JSON.stringify）

function fn(obj) {

​      var a = Object.prototype.toString;

​      if (a.call(obj) === "[object Array]") {

​        let arr = []

​        obj.forEach(element => {

​          if (element instanceof Array || element instanceof Object) {

​            return arr.push(fn(element))

​          } else {

​            arr.push(element)

​          }

​        });

​        // console.log(arr);

​        return arr

​      }

​      if (a.call(obj) === "[object Object]") {

​        let key = Object.keys(obj);

​        let val = Object.values(obj)

​        let Obj = {}

​        for (i = 0; i < key.length; i++) {

​          if (key[i] instanceof Array || key[i] instanceof Object) {

​            return Obj[key] = fn(val[i])

​          } else {

​            Obj[key[i]] = val[i]

​          }

​        }

​        return Obj

​      }

​      if ((a.call(obj) !== "[object Array]") && a.call(obj) !== "[object Object]") {

​        return obj

​      }

​    }

​    let obj = {

​      obj: {

​        a: 1,

​        b: 2,

​        arr: [

​          [1, 23, 4],

​          [5, 7, 8]

​        ]

​      },

​      obj1: {

​        c: 3,

​        d: 5,

​        obj: {

​          null: undefined,

​          "[]": [{

​            11: 2

​          }]

​        }

​      }

​    }

​    let a = fn(obj)

​    console.log(obj);

​    console.log(a);

5.柯里化函数封装

function curryingHelper(fn,len){
	//这里先说个基本知识点 fn.length 返回的是这个方法需要传入的参数个数
	//这里第一次运行时通过fn.length 后面递归都是用的传入的len len为剩余的参数个数
	const length = len || fn.length;
	return function(...rest){
		//判断这次传入的参数是否大于等于剩下的参数 如果不是递归返回下一个方法继续传参
		return rest.length >= length  
		? fn.apply(this,rest)
		: curryingHelper(currying.apply(this,[fn].concat(rest)),length-rest.length)
	}
}
//还是刚才的sayHello 函数
let betterShowMsg = curryingHelper(sayHello);
//自动控制传参层数
betterShowMsg('zyx')(22)('葡萄');
betterShowMsg('zyx',22)('葡萄');

es6 柯理化
function currying(fn,...rest1){
	return function(...rest2){
		//这里用apply 是为把数组形式的参数直接传入原函数 null是因为不需要改变this
		return fn.apply(null,rest1.concat(rest2));
	}
}
将一个sayHello函数柯里化

function sayHello(name,age,fruit){
	console.log(`我叫${name},我${age}岁了，我喜欢吃${fruit}`);
}

//传入第一个参数
let curryingShowMsg = currying(sayHello,'小明');
//执行传入剩余参数
curryingShowMsg(22,'芒果');

//es6 
function currying(fn,...rest1){
	return function(...rest2){
		//这里用apply 是为把数组形式的参数直接传入原函数 null是因为不需要改变this
		return fn.apply(null,rest1.concat(rest2));
	}
}
将一个sayHello函数柯里化

function sayHello(name,age,fruit){
	console.log(`我叫${name},我${age}岁了，我喜欢吃${fruit}`);
}

//传入第一个参数
let curryingShowMsg = currying(sayHello,'小明');
//执行传入剩余参数
curryingShowMsg(22,'芒果');

6.判断是否为回文字符串（传递一个字符串到函数中，回文返回为true，否则返回为false）

回文：即前后读取都是相同的，例如’abcba’,‘abccba’,‘aabbccbbaa’

//回文字符串

​

     let str = "assa"

​      let srt = "ass"

​      function huiwen(str) {

​        let s = str.split("").reverse().join("")

​        if(s==str){

​          return true

​        }else{

​          return false

​        }

​      }

​      console.log(huiwen(str)); 

​      console.log(huiwen(srt));

7.菲波那切数列封装

8.封装函数，传递字符串。输出字符串中字符出现的总次数

例如：输入‘aaabbbbccccupaacu’

输出：a5次，b4次，c5次，u2次，p1次

let str = "aaaaaabbbbbccccdddssssaascasds"

​      function ji(str) {

​        str = str.split("").sort().join("");

​        let obj = {}

​        for (let i = 0, j = str.length; i < j; i++) {

​          let char = str[i];

​          obj[char] = str.lastIndexOf(char) - i + 1;

​          i = str.lastIndexOf(char)

​        }

​        return obj

​      }

​      console.log(ji(str));

9.封装函数，参数传递为url，将url中的参数封装成对象作为返回结果

let url = "https://uland.taobao.com/sem/tbsearch?refpid=mm_?refpi=mm_?rfpid=mm_?efpid=mm_?rpid=mm_"

​    function urls(url){

​      let len = url.indexOf("?")

​      let str = url.slice(len+1,url.length)

​      let arr = str.split("?")

​      let obj ={};

​      arr.forEach(ele => {        

​        let leng = ele.indexOf("=")

​        let key = ele.slice(0,leng)

​        let val = ele.slice(leng+1,ele.length)

​        obj[key] = val

​      });

​      return obj

​    }

   console.log(urls(url)); 

10.给定一个数组，求它的最大值/最小值

**输入描述:**数组

**输出描述:**最大值，最小值

输入:[3,4,5,6]**输出:**6，3

{

​    let arrmin = [3,4,5,6]
​    function min(arr){

​      let min=null,max=null;

​      for(let i=0;i<arr.length;i++){

​        min = arr[0]

​        if(min>=arr[i]){

​          min = min

​        }else{

​          max = arr[i]

​        }

​      }

​      return console.log(min,max);

​    }

​    min(arrmin)
或者使用Math.max() Math.min()方法
		console.log(Math.max(1,2,3,4,5,6,7));
      	console.log(Math.min(1,2,3,4,5,6,7));
  }