闭包、this指向

闭包

1、闭包

就是打通了⼀条在函数外部访问函数内部作⽤域的通道。正常情况下函数外部是
访问不到函数内部作⽤域变量的

闭包产生有两种表现：
1、函数作为参数被传递
2、函数作为返回值被返回

函数中的自由变量，取决于函数定义的地方，跟执行的地方没关系

 // 函数作为参数被传递
    	function fn() {
            let a = 10
            return function() {
                console.log(a); // 10
            }
        }
        let an = fn()
        let a = 20
        an()

    // 函数作为参数被传递
    function fn() {
        const a = 20
        f()
    }
    const a = 10
    function f() {
        console.log(a); // 10
    }
    fn(f)

闭包的优点

1. 函数内部变量在函数执行完后，仍然存活在内存中(延长局部变量的生命周期)
2. 让函数外部可以操作(读写)到函数内部的数据(变量/函数)

缺点

函数执行后，函数内的局部变量没有释放，占用内存会变长，容易造成内存泄漏。

this指向

普通函数
定时器
对象方法
call apply bind
class
箭头函数

普通函数中的this

  function fn(){
    console.log(this);// 这里的this指向Window
  }
  fn(); 

对象方法

    let obj = {
        name:'zbt',
        run: function() {
            console.log(this);  // obj, this指向方法调用者
        }
    }
    obj.run()

call apply bind

    	let obj={name:10}
        let pox={
        name:20,
            run:function(){
                console.log(this.name)
            }
        } 
        // 对象方法中的this.指向方法的调用者。
        pox.run();// pox 20
        pox.run.call(obj)// 10
        pox.run.apply(obj);// 10
        pox.run.bind(obj)();//10

call() /apply() /bind() 都可以改变this指向,指向第一个参数
call:参数是单个使用的 参数是一个参数列表，
apply:参数是一个集合时使用，参数是一个数组
bind:使用bind会改变this，不会改变数据，需要在调用的地方加一个括号

class语法糖

	class Person {
        constructor(name,age) {
            this.name = name
            this.age = age
        }
        run() {
            console.log(this);  // this指向p实例对象
        }
    }
    let p = new Person('小明',19)
    p.run()

箭头函数
箭头函数的this是在定义时确定的，指向父级上下文对象，并且不可以被 call()/apply()/bind()修改

		var name = '小明'
        let arr = {
            name:'小红',
            run:()=>{
                console.log(this.name);
            }
        }
        let fn = {name:'小小'}
        arr.run()        // 小明
        arr.run.call(fn) // 小明
        arr.run.apply(fn) // 小明
        arr.run.bind(name)();//小明