20-JS高阶函数

闭包和回调任意一个用在函数上，都是高阶函数

一、闭包

闭包的概念：

​ 一个函数和对其周围状态（lexical environment，词法环境）的引用捆绑在一起（或者说函数被引用包围），这样的组合就是闭包（closure）。也就是说，闭包让你可以在一个内层函数中访问到其外层函数的作用域。在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

未形成闭包

function test (fn) {
            var a = 1;  
            return fn();
}


test(function () {
        console.log(a);
 })

写一个函数，参数是初始数字
函数提供加减和获取值得方法
加减方法参数是每一次要加减的值

  function Calculate(initialNumber){
            var _number = Number(initialNumber) >>> 0;

            function add(num){
                _number += num;
                console.log(_number);
            }

            function minus(num){
                _number -= num;
                console.log(_number);
            }

            function value(){
                console.log(_number);
            }

            return{
                add: add,
                minus: minus,
                value: value
            }
        }

        var cal = Calculate(3);
        cal.add(4);
        cal.minus(2);
        cal.value();

二、回调函数：

(1)、什么是回调函数

a函数的参数是b函数， b函数就是a函数的回调函数 callback function

call-back 回电话的意思

函数的调用叫做call 回调函数的调用 call back

如果想将任务分成两个部分，一个先执行，一个后执行，这是可以给一个函数传入另一个函数。

回调函数的意义在于将所有任务分成主函数任务和回调函数任务

Calling Task Calling-back Task

fn执行不受test函数内部程序的影响，主函数和回调函数完美隔离

test函数在执行的时候（未执行回调函数的时候），fn函数定义

function test (fn) {
  // todo...
  fn();
}

test(function () {
  console.log(123);
});

(2)、回调的应用：

1、功能扩展与接力

 function test(num,callback){
           num += 1;
           callback && callback(num);
 }

test(1, function(num){
           console.log(num);
 })

主函数实现±*/功能

回调函数接收【数字1，数字2，进行的类型计算，计算时间】四个参数，打印出日志。

 function Calculate(callback){
            return function(a,b,type){

                let result = 0;
                let _a = Number(a) >>> 0;
                let _b = Number(b) >>> 0;

                const dateTime = new Date();

                switch(type){
                    case '+':
                        result = _a + _b;
                        break;
                    case '-':
                        result = _a - _b;
                        break;
                    case '*':
                        result = _a * _b;
                        break;
                    case '/':
                        result = _a / _b;  
                        break;
                    default:
                        break;          
                }

                callback && callback(_a, _b, type, result, dateTime);

            }
        }

        var cal = Calculate(function(a, b, type, result, dateTime){
            console.log(`${dateTime}: ${a} ${type} ${b} = ${result}`);
        })

        cal(1,2,'+');
        cal(1,2,'-');
        cal(1,2,'*');
        cal(1,2,'/');

2、检验传入参数的合法性

function Test(validator){
           return function(a, b, type){
               const {isError, errorMsg} = validator(a,b);

               if(isError){
                   throw new Error(errorMsg);
               }

               switch(type){
                   case '+':
                       return a + b;
                   case '-':
                       return a - b;
                   case '*':
                       return a * b;
                   case '/':
                       return a / b;            
               }
           }
       }
        
       var test = Test(validate100);

       console.log(test(199, 100, '-'));

       function validate100(a,b){
           if(a < 100 || b < 100){
               return {
                   isError: true,
                   errorMsg: 'a和b必须大于等于100'
               }
           }

           return {
               isError: false
           }
       }