JS笔试部分

JavaScript笔试部分

实现防抖函数（debounce）

//	防抖函数
const	debounce	=	(fn,	delay)	=>	{
    let	timer	=	null;	
    return	(...args)	=>	{	
        clearTimeout(timer);
        timer=setTimeout(()	=>	{
            fn.apply(this,	args);	
        },	delay);	
    };
};

实现节流函数（throttle）

//	节流函数 
const	throttle	=	(fn,	delay	=	500)	=>	{
    let	flag	=	true;	
    return	(...args)	=>	{
        if	(!flag)	return;	
        flag	=	false;
        setTimeout(()	=>	{	
            fn.apply(this,	args);	
            flag	=	true;	
        },	delay);	
    }; 
};

深克隆（deepclone）

简单版:

const	newObj	=	JSON.parse(JSON.stringify(oldObj));

简单第二版:Object.assign(target,source)

多层嵌套实现不了

var obj1 = {
    a: 1,
    b: 2,
    c: 3
}
var obj2 = Object.assign({}, obj1);
obj2.b = 5;
console.log(obj1.b); // 2
console.log(obj2.b); // 5

--------------------------
 var obj1 = {
    a: 1,
    b: 2,
    c: ['a','b','c']
}
var obj2 = Object.assign({}, obj1);
obj2.c[1] = 5;
console.log(obj1.c); // ["a", 5, "c"]
console.log(obj2.c); // ["a", 5, "c"]

递归拷贝

// 定义一个深拷贝函数  接收目标target参数
function deepClone(target) {
    // 定义一个变量
    let result;
    // 如果当前需要深拷贝的是一个对象的话
    if (typeof target === 'object') {
    // 如果是一个数组的话
        if (Array.isArray(target)) {
            result = []; // 将result赋值为一个数组，并且执行遍历
            for (let i in target) {
                // 递归克隆数组中的每一项
                result.push(deepClone(target[i]))
            }
         // 判断如果当前的值是null的话；直接赋值为null
        } else if(target===null) {
            result = null;
         // 判断如果当前的值是一个RegExp对象的话，直接赋值    
        } else if(target.constructor===RegExp){
            result = target;
        }else {
         // 否则是普通对象，直接for in循环，递归赋值对象的所有值
            result = {};
            for (let i in target) {
                result[i] = deepClone(target[i]);
            }
        }
     // 如果不是对象的话，就是基本数据类型，那么直接赋值
    } else {
        result = target;
    }
     // 返回最终结果
    return result;
}

let obj1 = {
        a: {
            c: /a/,
            d: undefined,
            b: null
        },
        b: function () {
            console.log(this.a)
        },
        c: [
            {
                a: 'c',
                b: /b/,
                c: undefined
            },
            'a',
            3
        ]
    }
    let obj2 = deepClone(obj1);
        console.log(obj2);

对promise的理解

promise是一种异步编程的解决方案,有三种状态,pending,resolved,rejected.

它的状态是由异步操作的结果决定的,状态改变就不能重新改变状态

promise可以解决回调地域,函数嵌套函数,配合async/awiat写异步代码

使用:

创建promise实例,实例有then,catch方法.分别指定resolved状态和rejected状态的回调函数

可以使用try和catch方法预防异常

race:多个任务同时执行,返回最先执行的任务的结果,不管这个结果是成功还是失败

all:多个任务同时执行,以数组形式返回所有promise执行结果,若果有一个任务rejected,则返回rejected任务的结果

promise的事件循环

Promise在初始化时，传入的函数是同步执行的，然后注册 then 回调。注册完之后，继续往下执行同步代码，在这之前，then 中回调不会执行。同步代码块执行完毕后，才会在事件循环中检测是否有可用的 promise 回调，如果有，那么执行，如果没有，继续下一个事件循环

Promise 的业界实现都有哪些？

• promise可以支持多个并发的请求，获取并发请求中的数据

• promise可以解决可读性的问题

promise的问题为：

• promise一旦执行，无法中途取消
• promise的错误无法在外部被捕捉到，只能在内部进行预判处理
• promise的内如何执行，监测起来很难

ES7引入了更加灵活多变的async，await来处理异步