高阶函数、闭包
高阶函数
把一个函数如果接受另一个函数作为参数，或者该函数会返回另一个函数作为返回值的函数，那么这个函数就称之为是一个高阶函数
函数作为参数使用
function calc(num1, num2, calcFn){ console.log(calcFn(num1, num2)) } function sub(num1, num2){ return num1 + num2 } var m = 20; var n = 30; calc(m, n, sub) // 50
函数作为返回值使用
function makeAdder(count) { function add(num) { return count + num } return add } var add5 = makeAdder(5) console.log(add5(6)) // 11
闭包
《JavaScript高级程序设计》中对闭包的定义：
- 闭包指的是那些引用了另一个函数作用域中变量的函数，通常是在嵌套函数中实现的；
🤔我找资料发现，很多人总结闭包形成的条件有一条是函数嵌套，但有的人又总结：“闭包是一个可以访问外部作用域的内部函数，即使这个外部作用域已经执行结束。”到底函数嵌套是不是闭包的一个必要条件呢？
来看看下面这段代码：
var a = 1; function demo() { console.log(a) } demo();
一直在纠结这个是不是闭包，直到看到了冴羽大佬的一篇关于闭包的文章，里面将闭包分为理论上的闭包和实践上的闭包。
理论上的闭包
闭包是两部分组建的：函数+可以访问的外层作用域的自由变量
- 从广义的角度来说：JavaScript中的函数都是闭包；（因为JavaScript中的函数都可以访问到外层作用域的自由变量）
- 从狭义的角度来说：JavaScript中一个函数，如果访问了外层作用域的变量，那么它是一个闭包（严格意义上在函数内有访问外层作用域的变量才算闭包）
//理论上这是一个闭包 var a = 1; function demo() { console.log(a) } demo();
实践上的闭包
而实践上闭包的定义：
- 即使创建它的上下文已经销毁，它仍然存在（比如：内部函数从父函数中返回）
- 在代码中引用了自由变量
// 常见的闭包 function fun_1(){ const n = 10; function fun_2(){ console.log(n) } return fun_2; } var foo = fun_1(); foo()
其实不需要纠结于某个函数是不是闭包的问题，一般闭包的好处是在函数嵌套中体现的。
一般闭包的好处在于：
1：保存变量不受外界影响，形成不销毁的栈变量、
2：闭包使得 timer 定时器，事件处理，AJAX 请求等异步任务更加容易、
3：可以通过闭包来达到封装性。
闭包的内存泄漏
一般情况下，函数执行会形成一个新的私有作用域，一般函数执行完成后，我们当前的作用域都会主动地进行释放和销毁。但当遇到函数执行一个引用数据类型的值，并在函数的外面被某个变量接收了，这种情况下形成的私有作用域都不会被销毁。
因此，闭包不能滥用，否则会导致内存泄漏，影响网页性能。
我们先来回顾一下常见的GC算法——标记清除
- 这个算法是假定一个根对象（root object），垃圾回收器会定期从这个根开始，找所有从根开始有引用到的对象，对于哪些没有引用到的对象，就认为是不可用的对象；
然后我们来看看下面这段代码：
function foo(){ const n = 10; function bar(){ console.log(n) } return bar; } var fn = foo(); fn()
由上图可知在GO对象中有一个fn引用到了bar，而这个bar 的parentScope引用了foo函数中的AO对象，根据标记清除的算法，这些都是可用的对象，所以没有被销毁。
而怎样解决呢？
foo = null fn = null
这样标记清除的算法就能将这些没有被从根开始引用到的对象清除掉了
参考资料：
https://juejin.cn/post/6844903769646317576#heading-23
https://juejin.cn/post/6844903475998900237
神奇的this
this在全局作用域下
在大多数情况下，this都是出现在函数中
在全局作用域下，this 的指向：
- 浏览器：window( globalObject)
- Node 环境：{ }
🤔有时候我们会发现JS执行this指向的结果会不一样，有什么规律吗？
this指向什么，跟函数所处的位置是没有关系的，而跟函数调用的方式有关系
function foo() { console.log(this); } var obj = { foo: foo } foo(); // 默认绑定 obj.foo(); // 隐式绑定 foo.call('a') // 显式绑定
this的默认绑定
当独立函数调用时，this 默认绑定（独立函数指函数没有被绑定到某个对象上进行调用）
function foo() { console.log(this); } var obj = { foo: foo } foo(); // 默认绑定 而默认绑定this在浏览器的指向是 window( globalObject)
this的隐式绑定
当通过某个对象发起的函数调用时，this 隐式绑定
function foo() { console.log(this); } var obj = { foo: foo } obj.foo(); // 隐式绑定
而隐式绑定this在浏览器的指向是 发起函数调用的对象（上面代码 this 的指向就是 obj 这个对象）
前提条件：必须在调用的对象内部有一个对函数的引用 （比如一个属性），不然会找不到函数而报错
var obj = { foo: foo }
🤔如果不想要在对象上添加属性，但又想绑定这个对象要怎么办呢？
那就要用到显示绑定了
this的显示绑定——call/apply/bind
调用call/apply方法就可以手动地指定函数中this的指向对象
function foo() { console.log(this); } // foo.apply('a') foo.call('a') // 显式绑定
🤔 call 和 apply 有什么区别呢？
如果只是单纯的指定对象，那他们的区别不大，它们主要的区别在于传递参数的形式
call 和 apply 的区别
这两个函数的第一个参数都要求是一个对象，后面的参数，call是参数列表，apply是数组
function sum(num1,num2) { console.log('this指向的对象为' + this, num1 + num2) } sum.call('call', 10, 20) sum.apply('apply', [10,20])
用bind来绑定
通过bind来绑定就不用一直调用call/apply方法来进行绑定（相当于用bind绑定一次可用多次）
function foo() { console.log(this); } var newFoo = foo.call('a') newFoo() newFoo()
function foo() { console.log(this); } var newFoo = foo.bind('a') newFoo() newFoo()
🤔这里就有一个问题了： newFoo( )是一个独立函数调用吧，那它为什么不是指向window而是指向 ‘a’
是因为如果默认绑定和显示绑定一起出现，则显式绑定起作用，显示绑定优先级更高
this的new绑定
除了上面的默认绑定、隐式绑定和显式绑定，我们还可以通过一个new关键字来绑定对象
当我们通过一个new关键字调用一个函数时（构造器），这个时候this是在调用这个构造器时的对象
function Pet(name,hobby){ this.name = name this.hobby = hobby } var p1 = new Pet('三号楼', 'eat') console.log(p1.name,p1.hobby) //三号楼 eat
规则绑定的优先级
默认绑定 < 隐式绑定 < 显示绑定 < new 关键字绑定
