一、函数的递归
（1） 什么是递归
函数递归recursion，描述了函数在自己的内部代码中调用自身的过程
（2） 递归基本语法
① for循环
// 1、基本语法：输出5~1五个数据
// - 普通for循环
// 理解：
// var i= 5: 循环变量的初始化，循环第一次执行时执行，并且只执行一次
// i > 5：循环条件，每次进入循环时需要判断
// i++：循环变量修改，每轮循环结束时进行变量值修改
for(var i = 5; i > 0; i--) {
console.log('i-> ', i)
}
// 案例 ：for循环实现斐波那契数列 100以内
var num1 = num2 = 1 // 初始准备的两个数据
console.log("数列初始数据：", num1, num2)
var next = 0 // 下一个数据
// 获取第10位的数据
for(var n = 3; n <= 10; n++) {
// 计算获取下一个数据
next = num1 + num2
/*if(next >= 100 ) {
// 如果斐波那契数列当前某个数据大于100，跳出循环
break
}*/
console.log("-数列数据：[" + next + "]")
// 交换数据
num1 = num2
num2 = next
}
② recursion递归
递归的本质：循环、函数级别的循环
// 2、函数递归：函数自己调用自己
// 理解这段代码：fn()函数就是用于展示数据的，你交给它一个数据；它就展示一个数据
// 展示数据的函数
function fn(n) {
// 结束条件
console.log("n计数:", n)
if(n == 1) return 1
// 递归调用：函数内部调用函数自己
// 输出完当前的n，输出下一个n：比当前的n小于1
return fn(n-1)
}
// 通过函数递归的方式，展示数据
fn(5)
// 案例：函数递归，获取100内的斐波那契数列
function feib(n) { // 参数n：表示获取第几个位置的数据
if(n <= 2) { // 初始数据
// 表示递归结束的条件: 当获取第一位或者第二位数据时，直接返回1
return 1
}
// 下一个数据是前面两个数据的和：递归调用
return feib(n-1) + feib(n-2)
}
var r = feib(1) // 获取第1个斐波那契数列的数据
console.log('r第一位：',r)
var r = feib(2) // 获取第2个斐波那契数列的数据
console.log('r第二位：',r)
var r = feib(10) // 获取第10个斐波那契数列的数据
console.log('r第十一位：',r)
（3）函数在内存中执行过程
递归执行，相当于当前声明的函数在内存中一遍又一遍的创建对象，并执行函数内部的代码，内部递归的函数执行没有完成时，函数占用的内存空间不会释放
① 普通函数的执行过程
// 函数的声明部分
function fn() {
console.log("xxxxxx")
}
// 函数的调用执行
fn()
image.png
** ② 递归函数在内存中的执行过程**
function fn(n) {
console.log("数据：", n)
if(n <= 1) { // 最后当n小于等于1的时候，直接返回1，结束函数的继续执行
return 1
}
// 输出完当前数据之后，继续输出下一个数据(比当前数据小于1的数据)
return fn(n - 1)
}
fn(5) // 5, 4, 3, 2, 1
image.png
二、函数的闭包
（1） 认识闭包
函数闭包
closure，描述了在一个函数的内部声明函数的语法；扩展了外部函数中局部变量的访问范围，同时避免了多功能开发时的变量全局污染问题！
// 函数的闭包
function outerFn() {// 外部函数
// ...
function innerFn() { // 内部函数（闭包函数），声明在外部函数的内部
// ...
}
return innerFn // 返回内部函数，方便函数的使用
}
（2） 闭包基本语法
// 函数的闭包：目标-先熟悉语法
function outerFn() {
// 局部变量: 一般都是声明在函数内部，只在当前函数内部可以被访问
var total = 200
// 闭包函数
function jiSuan(dat) {
var result = total + dat
return result
}
// 返回了内部的闭包函数(返回的是函数的声明)
return jiSuan
}
// 调用外部函数，获取到内部函数
var inFn = outerFn() // inFn 是一个函数
// 继续执行获取到的闭包函数：outerFn()函数的外部，直接操作局部变量的数据
var res = inFn(300)
console.log("res:" , res)
function outerFn() {
// ...
// 重点：一个函数声明在其他函数的内部 | 特殊的声明位置
function innerFn() {
// ...
}
// 返回内部的函数声明
return innerFn
}
// 调用：调用外部函数，获取到闭包函数
var inFn = outerFn() // inFn也是一个函数
// 通过inFn 调用闭包函数
var result = inFn() // 调用执行inFn这个函数，就是innerFn函数
（3） 关于全局污染问题
出现了数据的互相影响，导致运行结果错误，这样的问题称为全局污染问题。
解决全局污染的方法就是使用闭包
使用闭包，完计价器程序的开发
// 声明一个计程车函数；通过计程车可以获取到计价器
function taxi() {
// 总价格:局部变量
var sum = 0;
// 计价器
function jiJiaQi(msg, money) {
console.log(msg + ":" + money + "元")
sum += parseInt(money)
return sum
}
// 返回计价器
return jiJiaQi
}
// 执行函数，获取计程车的计价器
var jjq = taxi()
jjq("起步", 5)
jjq("行驶5公里", 15)
jjq("堵车", 4)
var s = jjq("行驶3公里", 9)
console.log("达到目的地：费用", s, "元")
三、自执行函数
（1）代码编写即刻执行
代码写在全局的范围，只需要写了代码立即会执行
代码的执行，没有问题
存在的缺陷：因为网页中存在多种效果，可能会引起全局污染
// 1、代码直接下载全局范围，写完代码就会立刻执行
// 轮播图效果[模拟]
var effect1 = "轮播图"
console.log(effect1)
// 选项卡效果
var effect2 = '选项卡'
console.log(effect2)
// 楼层效果
var effect3 = "楼层效果"
console.log(effect3)
（2） 函数封装调用执行
将对应的网页特效，封装到多个独立的函数中，调用执行
- 每个网页特效的代码都是 独立的函数 开发
- 存在的小缺陷：某些特效的函数代码，网页渲染的过程中只会调用一次，标准的函数声明和调用语法，让函数声明和调用分散/代码量增加
// 2、函数封装对应的特效，调用执行函数
function bannerEffect() {
// 声明和轮播图相关的局部变量
console.log("轮播图效果")
}
function tabEffect() {
// 声明和选项卡效果相关的局部变量
console.log("选项卡效果")
}
function floorEffect() {
// 声明和楼层效果相关的局部变量
console.log("楼层效果")
}
// 调用执行
bannerEffect()
tabEffect()
floorEffect()
（3） 自执行函数
自执行函数，就是描述了函数在声明的同时就立即执行的一种语法结构
// 第一种
(function() {...} ())
// 第二种
(function(){...}) ()
// 第三种
!function() {...} ()
// 第四种
void function() {...}()
// 第五种
[function() {...}()]
