一.闭包的概念
闭包是这样的一种机制:函数嵌套函数,内部函数可以引用外部函数的参数和变量。参数和变量不会被垃圾回收机制收回。
1.函数嵌套函数
function fn(a){
return function(){
//访问道这个a
console.log(a);
}
}
console.log(fn('hello'));//调用外部的函数
fn('hello')()//调用内部函数
2.作用域
function fn1(){
let i = 0 //i不会被垃圾回收机制回收
return function(){
i++
return i
}
}
console.log(fn1()()); //1
console.log(fn1()()); //1
let a = fn1()
console.log(a());//1
console.log(a());//2
console.log(a());//3
3.垃圾回收机制有两种:1.标记清除, 2.引用计数
1.标记清除:js会对变量做一个标记yes or no的标签以供js引擎来处理,当变量在某个环境下被使用则标记为yes,当超出改环境(可以理解为超出作用域)则标记为no,然后对有no的标签进行释放。
2.引用计数:对于js中引用类型的变量, 采用引用计数的内存回收机制,当一个引用类型的变量赋值给另一个变量时, 引用计数会+1, 而当其中有一个变量不再等于值时,引用计数会-1, 如果引用计数为0, 则js引擎会将其释放掉。
二.闭包的作用
相比全局变量和局部变量,闭包有两大特点:
1.闭包拥有全局变量的不被释放的特点
2.闭包拥有局部变量的无法被外部访问的特点
闭包的好处:
1.可以让一个变量长期在内存中不被释放
2.避免全局变量的污染,和全局变量不同,闭包中的变量无法被外部使用
3.私有成员的存在,无法被外部调用,只能直接内部调用
闭包可以完成的功能:1.防抖、2.节流、3.函数柯里化
1.防抖
//防抖 避免函数的重复调用 只会调用一次
function Antishake(fn,wait){ //第一个参数是函数 第二个参数是毫秒值
let timer = null //声明一个变量来接收延时器 初始值为null
return function(){
clearTimeout(timer)
timer = setTimeout(() => {
fn() //调用这函数
}, wait);
}
}
let an = Antishake(function(){ //用一个变量接收
console.log('555');
},2000)
document.querySelector('div').onmouseenter = ()=>{
an() //调用一次
}
2.节流
function throttle(fn,wait){
let timer = null //节点闸
return function(){
if(timer) return //null false 不是null结果减少true 如果上传没有我就直接跳过 没有人我就上去
timer = setTimeout(() => { //上车了
fn()
timer = null //做完之后重新关闭节点闸
}, wait);
}
}
let throttle1 = throttle(()=>{
console.log('我上车了');
},2000)
document.querySelector('div').onclick = ()=>{
throttle1()
}
节流和防抖的区别
防抖避免重复执行 只执行一次
节流 减少执行次数 执行多次
3.函数柯里化
函数柯里化 其实就是函数颗粒化 将一个函数变成一个个颗粒可以组装,就是这个里面的多个参数 将他变成一个个的函数来传递这个参数。
简单柯里化函数:
function fnSum(a,b,c){//求和函数
return a+b+c
}
//简单柯里化 他就是使用了一个函数来改造原本的函数
function curry(fn){
return function(a){
return function(b){
return function(c){
return fn(a,b,c)
}
}
}
}
//调用 避免了多余的无用参数传递
let fnCurry = curry(fnSum) //函数
console.log(fnCurry(1)(2)(3));//6
改进的柯里化函数:
function fnSum(a,b,c){//求和函数
return a+b+c
}
function curry1(fn){
//接收一个后面的参数 除了fn的参数
let args = Array.prototype.slice.call(arguments,1)//从下标1开始全部剪切 把Array里面的slice方法加给外部函数的arguments
return function(){
let newArg = args.concat(Array.from(arguments)) //将内部函数的参数和外部的参数合并
return fn.apply(this,newArg) //将内部函数自动指向 传入所有的参数
}
}
let fn2 = curry1(fnSum,1,2) //函数
console.log(fn2(3)); //6
最终改进的柯里化函数:可以任意组合传参 如果不满足就返回偏函数 如果满足就返回结果
function fnSum(a,b,c){//求和函数
return a+b+c
}
function curry2(fn){
//接收一个后面的参数 除了fn的参数
let args = Array.prototype.slice.call(arguments,1)
return function(){
let newArg = args.concat(Array.from(arguments)) //将内部函数的参数和外部的参数合并
if(newArg.length < fn.length){ //参数没有到三个 fn.length获取传递的函数的参数个数
return curry2.call(this,fn,...newArg) //又套了一个function 这个this指向这个function 如果没有到达会一直套这个方法
}else{
return fn.apply(this,newArg) //将内部函数自动指向 传入所有的参数
}
}
}
let fn3 = curry2(fnSum) //函数
console.log(fn3(1)()(2)()(3)); //6
console.log(fn3()(1)()(2)()()); //偏函数 function
三.this指向以及this的绑定
1.this指向问题
在构造函数里面this指向对象
function Box(name) {
this.name = name;
this.show = function(){
console.log(this.name);
}
}
var box = new Box('zhangsan');
在普通函数里面谁调用就指向谁
function func() {
console.log(this);
}
func(); //window对象
在定时器里面this指向window
setInterval(function(){
console.log(this); //window对象
}, 2000);
在事件函数中this指向触发这个事件的标签
box.onclick = function() {
console.log(this);//this指向box
}
2.this绑定的方法
bind() 里面传递的是对应指向的对象
call() 里面传递的是指向的对象和参数(会自动调用)
apply() 里面传递时指向的对象及参数数组(会自动调用)
function fn(name){ //函数
this.name = name
console.log(this);
}
fn('李四') //this指向window
function Student(){
this.name = 'hello'
this.age = 18
}
let student = new Student()
//bind 里面传递的是对应指向的对象
fn.bind(student)('李四')
//call 里面传递的是指向的对象和参数
fn.call(student,'王五') //name参数王五 自动调用方法
//apply 里面传递时指向的对象及参数数组
fn.apply(student,['赵六']) //传递一个参数数组 自动调用方法
相同点:call、apply和bind都是JS函数的公有的内部方法,他们都是重置函数的this,改变函数的执行环节。
不同点:bind是创建一个新的函数,而call和aplay是用来调用函数;call和apply作用一样,只不过call为函数提供的参数是一个个的,而apply为函数提供的参数是一个数组。