【Day5】ES5（函数02，arguments，递归）

日期：2月4日

---

1.函数的类型

        声明式

                function funName() {

                                }

                可以在页面任意位置上调用

        表达式

                var funName = function() {

                        }

                函数只能在表达式的后面调用

        函数的其他特点：

               1.函数的名字不能重复 如果函数名重复 后面的会把前面的覆盖掉

               2. js 没有重载的概念 

               3. 实参和形参的对应关系

                   形参的个数=实参的个数 一一对应

                   实参个数 < 形参个数 没有匹配到的形参就是undefined

                   实参个数 > 形参个数   没有匹配的实参 没办法在函数中使用的

               4. 函数之间可以相互调用

        函数的重载:

               同一页面 函数名相同 但是 参数列表不同

2.arguments:

            1. 任意一个函数中都有 arguments 属性

            2. arguments 是一个伪数组  保存函数的[实参]

       arguments是 伪数组：具有数组的结构  但是并不是数组的类型，遍历的方式和数组的遍历方式 一样

案例：

            for(var index in arguments) {
                console.log(index,arguments[index]);
            }

             for(var i = 0;i<arguments.length;i++) {
                console.log(i,arguments[i]);
            }

  案例：

        /**
         *  获取任意数的和
         */
        function sum() {
            var sum = 0;
            for(var index in arguments) {
               sum += arguments[index];
            }
            return sum;            
        }

    console.log( sum(1,2,3));
    console.log( sum(1,2,3,4,5,6));

           

  案例：

/*
    获取任意数的最大值
   */
   function arrMax() {
         
         var max;

         if(arguments.length) {
             max = arguments[0]
             for(var i = 1;i<arguments.length;i++) {
                 if(arguments[i] > max) {
                     max = arguments[i]
                 }

             }
         }

         return max;

      }
      console.log(arrMax(10,30,20));
      console.log(arrMax(50,30,20));
      console.log(arrMax(50,30,100));

3.递归

       1. 递归： 函数自己调用自己

       2.使用递归：一定要有出口  没有出口 递归就陷入一个死循环

       3.递归使用的场景：  同一个业务逻辑需要反复执行

       4. 递归的特点： 执行效率比较慢  有替代递归的方法 不推荐使用递归

                   递归函数的分析:  从前向后分析   假定一个函数时干什么 再找寻其出口

                   递归函数的执行： 从后向前执行   先执行出口函数  再一步一步向上赋值

        // 打印需求
        function fn(n) {
            if(n === 101) {
                return;
            }
         
            console.log(n);
            n++;

            fn(n)

        }


// 累加需求  1+2+3....n  业务逻辑 当前的值+ 之前的和

        function add(n) {
            if(n === 1) {
                return 1;
            }

            return  n + add(n-1);

        }

        console.log(add(100));

        // 求 1+ 2+3+4+5
        /*
         执行过程： 
           result  5 + fn(4) 10
           fn(4)   4 + fn(3) 6
           fn(3)   3 + fn(2) 3
           fn(2)   2 + fn(1) 1
           fn(1)   1
        
        
        */
        console.log(add(5));

案例：（斐波那契）

/*
         求第n个数的斐波那契的值 

         fn(n)  =  fn(n-1) + fn(n-2)
        */

        function feibo(n) {
            if(n === 1 || n === 2) {
                return 1;
            }

            return feibo(n-1) + feibo(n-2)
        }

        console.log(feibo(2));
        console.log(feibo(4));
        console.log(feibo(5));