高阶函数：闭包、递归

异步任务：
1.回调函数
2.定时器
3.ajax回调函数

一、高阶函数

• 高阶函数是对其他函数进行操作的函数，它接收函数作为参数或将参数作为返回值输出。
• 函数也是一种数据类型，同样可以作为参数传递给另一个参数使用，比如回调函数。

  function fn(callback) {
            callback && callback();
        }
        fn(function () {
            alert("hi");
        })

 function fn() {
            return function () { }
        }
        fn();

例如：jQuery调用回调函数，将前面参数执行完毕，最后才调用回调函数。

   $("div").animate({ left: 200 }, function () {
            $("div").css("backgroundColor", "purple");
        })

二、闭包

变量作用域：
1.局部作用域：函数外部不可以使用局部作用域。
2.全局作用域
3.当函数执行完毕后，局部作用域会销毁。
所谓闭包，指有权访问另一个函数作用域中变量的函数。
作用：延伸了变量的作用范围（延长生命周期）。
最简单例子：

  function fn(){
        var num = 0;
        function func(){
            console.log(num);
        }
        func();
    }
    fn();   // 0    子类访问到父类的变量

fn中的num变量被访问到，所以可以说fn是个闭包函数。也可以说闭包是种现象。

function fn() {
    var num = 0;
      return function () {
                console.log(num);
            };
}
var f = fn();
f();   //  用return返回出去，使外部能访问内部变量。

闭包实现循环小li

 var lis = document.querySelectorAll('li');
        for(var i = 0;i<lis.length;i++){
            //一般做法将每次循环的索引号赋值给i 比闭包简单
            lis[i].index = i;
            lis[i].onclick = function(){
                console.log(this.index);
            }
        }
        // 2.利用闭包得到当前小li的索引号
        for(var i =0;i<lis.length;i++){
            //利用for循环创建了4个立即执行函数
            //立即执行函数也称为小闭包，因为立即执行函数里所有函数都可以访问到i变量
            (function(i){
                lis[i].onclick = function(){
                    console.log(i);
                }
            })(i);
        }

闭包计算出租车价格

var car = (function () {
    var start = 13; //起步价
    var total = 0;  //总价
    return {
        price: function (n) {
            if (n <= 3) {
                total = start;
            } else {
                total = start + (n - 3) * 5
            } return total;
        },
        delay: function (flag) {
            return flag ? total + 10 : total;
        }
    }
})()
console.log(car.price(5)); //23
console.log(car.delay(true));  //33

console.log(car.price(3));//13
console.log(car.delay(false));//13

思考题1

 var name = "Hello Window";
        var object = {
            name:"MyObject",
            getNameFunc:function(){
                return function(){
                    return this.name;
                }
            }
        }
        console.log(object.getNameFunc()());  //  Hello Window 
        //匿名函数this指向window window下又有个name属性 = Hello Window
        // 拆解如下：
        var f = object.getNameFunc();
              = function(){
                    return this.name;
                }
                // 不是闭包，没有局部变量使用

var name = "Hello Window";
var object = {
    name: "MyObject",
    getNameFunc: function () {
        var that = this;
        return function () {
            return that.name;
        }
    }
}
console.log(object.getNameFunc()());  // MyObject

三、递归

• 一个函数可以在内部调用自己。
• 由于递归很容易发生栈溢出（stack overflow）错误，所以一定要加退出条件return。

  var num = 1;
        function fn() {
            console.log("我要打印6句话");
            if (num == 6) {
                return;
            }
            num++;
            fn();
        }
        fn();

斐波那列序列

   // 斐波那契数列（兔子序列） 1 1 2 3 5 8 13 21  前两项后第三项的和
    function fn(n) {
        if (n === 1 || n === 2) {
            return 1;
        }else{
            return fn(n-1) + fn(n-2);
        }
    }
  console.log(fn(8));   // 21：   表示第8个数是21

递归遍历复杂数据

var data = [{
    id: 1,
    name: "小米",
    goods: [{
        id: 11,
        gname: "小明"
    }, {
        id: 12,
        gname: "小兰"
    }]
}, {
    id: 2,
    name: "小新"
}];
//利用递归遍历到每一次id 根据用户输入id号匹配输出
function getId(json, id) {
    json.forEach(function (item) {
        if (item.id == id) {
            console.log(item);
        } else if (item.goods && item.goods.length > 0) {
            getId(item.goods, id);
        }
    });
}
(getId(data, 11)); //