关于vue.js:js进阶手写常见函数

无论是学习 react 还是 vue，它们都是 js 的利用框架。剥去他们的壳子看到的始终是 js，所以作为一个前端大厨必须要熟练掌握好 js 这个大勺，能力烧出一顿好菜

无论是自我晋升还是应酬面试以下这些手写性能是每一个前端程序员必须把握的

  每个 Function 对象都存在 apply()、call()、bind() 办法，其作用都是能够在特定的作用域
  中调用函数，等于设置函数体内 this 对象的值，以裁减函数赖以运行的作用域。

apply、call、bind 的异同

  1. 三者都能够扭转 this 的指向，第一个参数都是 this，如果指向是 null 或者 undefined 则指向 window
  2.  apply 的参数是数组，call 是列表，而 bind 能够屡次传入
  3.  apply 和 call 是扭转 this 的指向之后间接运行函数，而 bind 则是返回绑定之后的函数

apply 实现的参考代码

/** * 手写 apply */
window.name='gy' // 全局变量 
let obj={name:'ckx'}

var func=function(b,c){console.log(`this=`, this)
  console.log(this.name,b,c)
  return 1
}

func('24','hz')   //  gy 24 hz

func.apply(obj,['24','hz']) // ckx 24 hz

let newObj={
  name:'xmx',
  age:24
}
Function.prototype.myApply=function(base,args){
  // 1. 如果指向是 null 或者 undefined 则指向 window
  base=base || window
  // 2. 依据 this 是谁调用就指向谁的原理，将 this 指向的函数 赋值给 base 对象的一个属性
  base.fn=this
  // 3. 执行函数, 调用 base.fn 时，fn 中的函数指向 base 对象
  let result=base.fn(...args)
  // 4. 删除 base 的 fn 属性
  delete base.fn
  // 5. 返回 result 后果
  return  result
}

func.myApply(newObj,['55','yw']) // xmx 55 yw

apply 代码执行成果

相干 js 视频解说：进入学习

call 实现的参考代码

/** * 手写 call */
window.name='gy' // 全局变量 
let obj={name:'ckx'}

var func=function(b,c){console.log(`this=`, this)
  console.log(this.name,b,c)
  return 1
}

func('24','hz')   //  gy 24 hz

func.call(obj,'24','hz') // ckx 24 hz

let newObj={
  name:'xmx',
  age:24
}
// call 和 apply 须要留神参数的格局即可
Function.prototype.myCall=function(base,...args){
  // 1. 如果指向是 null 或者 undefined 则指向 window
  base=base || window
  // 2. 依据 this 是谁调用就指向谁的原理，将 this 指向的函数 赋值给 base 对象的一个属性
  base.fn=this
  // 3. 执行函数, 调用 base.fn 时，fn 中的函数指向 base 对象
  let result=base.fn(...args)
  // 4. 删除 base 的 fn 属性
  delete base.fn
  // 5. 返回 result 后果
  return  result
}

func.myCall(newObj,'55','yw') // xmx 55 yw

call 代码执行成果

bind 实现的参考代码

/** * 手写 bind */
window.name = "gy"; // 全局变量
let obj = {name: "ckx",};

var func = function (b, c,d) {console.log(`this=`, this);
  console.log(this.name, b, c,d);
  return 1;
};

func("24", "hz",26); //  gy 24 hz 26

let funcRes = func.bind(obj, "24", "hz");
funcRes(24);  // ckx 24 hz 24

let newObj = {
  name: "xmx",
  age: 24,
};
// 留神 bind 返回的时绑定的函数以及能够屡次传递参数
Function.prototype.myBind = function (base, ...args1) {return (...args2) => {
    // 1. 如果指向是 null 或者 undefined 则指向 window
    base = base || window;
    // 2. 依据 this 是谁调用就指向谁的原理，将 this 指向的函数 赋值给 base 对象的一个属性
    base.fn = this;
    // 3. 执行函数, 调用 base.fn 时，fn 中的函数指向 base 对象
    let result = base.fn(...args1,...args2);
    // 4. 删除 base 的 fn 属性
    delete base.fn;
    // 5. 返回 result 后果
    return result;
  };
};
let myfuncRes=func.myBind(newObj, "55", "yw")
myfuncRes(24) // xmx 55 yw 24

bind 代码执行成果

new 关键字执行时做了哪些

1. 创立了一个新对象
2. 将这个新对象与构造函数用原型链链接起来
3. 将构造函数的 this 指向新的对象，执行构造函数的代码赋值
4. 如果构造函数没有返回一个对象就返回新创建的对象否则返回构造函数返回的对象

手写 new 参考代码

/*** * 手写 new 关键字执行 */

function Person(name,age) {this.name = name;}
Person.prototype.getName = function () {return this.name;};
let a = new Person('gy');
console.log(a);
console.log(a.getName());


const myNew = (Func, ...args) => {let newObj = {};
  newObj.__proto__=Func.prototype
  let result=Func.apply(newObj,args)
  return  typeof result == Object ? result: newObj
};
let b = myNew(Person,'gy1')
console.log(b);
console.log(b.getName());

代码执行后果参考图

原型链示意图

    typeof 能够判断根本数据类型 然而 null 返回的也是 object 不能辨认 援用数据类型
    instanceof 能够精确的判断援用数据类型不能够判断 根本数据类型
    instanceof 是用于检测构造函数的 prototype 是否呈现某个实例对象的原型链上

参考代码

/*** 手写 instanceof*/
let obj= {label:'gy'}
let arr= ['hello']

let result = obj instanceof Object
let result1 = arr instanceof Array
let result2 = arr instanceof Object
let result3 = obj instanceof Array

console.log('result=',result)
console.log('result1=',result1)
console.log('result2=',result2)
console.log('result3=',result3)

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

const myResult= myInstanceof(obj,Object)
const myResult1= myInstanceof(arr,Array)
const myResult2= myInstanceof(arr,Object)
const myResult3= myInstanceof(obj,Array)

console.log('myRsult=',myResult)
console.log('myResult1=',myResult1)
console.log('myResult2=',myResult2)
console.log('myResult3=',myResult3)

代码执行后果截图

依据下面的代码打印后果须要留神的是：万物皆对象，包含数组，如果存在一个变量（arrOrObj）可能为 array 或者 object 如果应用 instanceof 去判断，肯定须要先判断是否为数组先，否则 arrOrObj instanceof Object 肯定为 true 就无奈辨别 array 和 object

    继续的触发某一事件，提早 n 秒后执行回调，在未到 n 秒再次触发，会从新登程倒计时    继续的触发某一时间，提早 n 秒后执行回调，在未达到 n 秒再次登程，不会从新计时

两者的应用场景

防抖 可能用于无奈预知的用户被动行为，如用户输出内容去服务端动静搜寻后果。用户打字的速度等是无奈预知的，具备非规律性。

节流 可能用于一些非用户被动行为或者可预知的用户被动行为，如用户滑动商品橱窗时发送埋点申请、滑动固定的高度是已知的逻辑，具备规律性。

节流 和防抖 也是闭包的利用

手写防抖代码参考

/*** * 手写防抖 */
const debounce = (func, delay) => {
  let timer = null;
  return function (...args) {if (timer) {clearTimeout(timer);
      timer = null;
    }
    timer = setTimeout(() => {func(args);
    }, delay);
  };
};
const getfn = (data) => {console.log(data);
};
debounce(getfn, 2000)("gy");

手写防抖代码执行后果

手写节流

/*** * 手写节流 * 这里只须要留神和防抖不同的时 不会革除定时器 */
const throttle = (func, delay) => {
  let flag = false;
  return function (...args) {if (flag)  return
    flag=true
    setTimeout(() => {func(args);
      flag=false
    }, delay);
  };
};
const getfn = (data) => {console.log(data);
};
throttle(getfn, 2000)("gy");

    AJAX 的全称为 Asynchronous JavaScript + XML，最重要的要属 XHR(XMLHttpRequest)
    XMLHttpRequest 通过不刷新页面申请特定 URL，获取数据。

实现的必备条件

XMLHttpRequest() 是一个构造函数
XMLHttpRequest.onreadystatechange 状态码变动时触发事件（所有浏览器反对）
XMLHttpRequest.readyState 申请的状态码

XMLHttpRequest.status 响应状态码返回规范的 HTTP 状态码

其余的申请响应参数

XMLHttpRequest.response 这个是整个响应实体
XMLHttpRequest.responseText 返回 `DOMString`
XMLHttpRequest.timeout 超时工夫
XMLHttpRequest.upload 上传进度

在看看罕用办法 open()

// method/url 是必须的
xhr.open(method, url, async, user, password); send()

// body 可选默认为 null
// 能够是 Blob, BufferSource (en-US), FormData,
// URLSearchParams, 或者 USVString 对象.
XMLHttpRequest.send(body); setRequestHeader()

XMLHttpRequest.setRequestHeader(header, value);
// 例如
XMLHttpRequest.setRequestHeader (“content-type”, “application/x-www-form-urlencoded”);

基于以上 API 实现 ajax

    1.  结构一个申请 XMLHttpRequest
    2.  初始化一个申请 open
    3.  监听申请 onreadystatechange
    4.  发送该申请 send

/*** 手写一个 ajax*/
const myAjax =(url,methods,header,success,error)=>{
    // 创立一个申请
    let request=new XMLHttpRequest()
    // 设置申请头
    for (const key in header) {request.setRequestHeader(key,header[key])
    }
    // 初始化申请
    request.open(methods,url)
    // 发送申请
    request.send()
    // 监听申请 onreadystatechange
    request.onreadystatechange =function(){if(request.readyState==4){if(request.status==200){success(request.response)
            }else {error()
            }
        }
    }
}