JavaScript中的函数（方法），水仙花数的示例，以及函数的递归调用*

1. 在javaScript中

        函数是一个可以重复性使用的并且实现一个特性的程序模块。

2. 函数的定义

            a.   定义的方式

               function  函数名 （参数）{

                         函数体语句   // 实现功能

                }

            b.   函数表达式

                  将定义的函数赋给一个变量，通过变量完成函数的调用和参数传递（即函数是匿名的）

              （1）  函数表达式的定义

                let / var /  const    变量名   =   function  (参数){

                                函数体语句

                 }       

                （2） 函数表达式的调用

                            即：     变量名（【参数】）

                 语法演示如下：

        

        //定义函数表达式(匿名函数)
        let min = function (value1, value2) {
            if (value1 < value2) {
                return value1;
            } else if (value2 < value1) {
                return value2;
            }
        }
        //对该函数表达式的调用
        let num = min(6, 6);
        console.log(`最小值min=${num}`);//返回undefined

3. 函数调用

        （1）带返回值的函数（函数体中有return语句的函数）：

                  let / var 变量 =  函数名 （  ）

                如下示例，找到三位数的水仙花数

      // 定义函数,找到三位数的水仙花数
        function daffodils() {
           // 定义数组来接收返回的水仙花数
            let arr = [];
                
            for (let i = 100; i < 1000; i++) {
                // 数字的拆分
                let bai = parseInt(i / 100);
                let shi = parseInt((i / 10) % 10);
                let ge = parseInt(i % 10);
                //判断i为水仙花数
                if (i == (bai ** 3 + shi ** 3 + ge ** 3)){
                    arr.push(i);
                }
            }
            return arr;
        }
        console.log(daffodils());

控制台打印结果：

                (4) [153, 370, 371, 407]

                  *函数的返回值

                     a. 由需求决定

                     b. 返回值通过return语句来完成。函数中执行了return语句，当前函数结束运行

           (2)  无返回值的函数调用

                    函数名（参数） 

 4. 函数的参数

      1.  形参，在函数定义时出现在函数首部的参数（形参没有实际值，只是一个占位符）

      2 . 实参：实在参数。是函数调用时出现在函数首部的参数，实参表示的是一个实际值

      3.  参数的传递是单向的，仅从实参   --->  形参。 实参不会受到形参变化的影响

 5. 函数的参数数量

        在js中允许函数的形参与实参数量不同

        （1）实参多于形参数量时，多余实参会被忽略掉；

        （2）实参少于形参数量时，多出的形参表示是已声明的未赋值变量，值为undefined。

6.  arguments对象

     arguments 为函数的内置对象

            作用为：调用函数时，函数的实参都保存在arguments对象中。

     arguments对象也可看作 一个类数组。

        代码演示：

        

//定义一个函数，返回调用该函数时实参的最大值
 function getMax() {
            //假设arguments数组中的第一项最大
            let max= arguments[0];
            //遍历arguments数组,并进行比较
            for(let i =1;i< arguments.length; i++) {
                
                if(max < arguments[i]){
                    max = arguments[i]
                }
            }
            return max;
        }
        let a = getMax(23,45,3,99);//调用函数
        console.log('传递的实参中最大的值Max=',a);

    该代码控制台输出结果为：

            传递的实参中最大的值Max= 99
   

 *** 函数的递归调用

        1.  递归调用：函数自己调用自己（即在函数的函数体语句中调用自己）；

        2.  递归算法：

                1）用递归方式解决问题的前提

                     a、问题可以进行分解，分解得到的新问题的解法与原问题的解法相同

                           例：8! --> 8* 7! --->7 6!-->.......2!-->2 * 1！

                      b、问题的分解过程必须有明确的结束条件       

                        

         //用递归函数计算 n!
        function fun(n){
            //1.明确递归结束的条件
            if(n==1){
                return 1
            }else{
                //2.继续分解n
                return n * fun(n-1) //函数自己调用自己：在调用过程分解问题
            }
        }

        let m = fun(8)
        console.log('8!=',m)

                2）递归的过程

                        a、自上而下分解问题：得到最简单的问题的解

                        b、自下而上回溯得到原问题的解

     

           对于递归的使用例题：计算1+2+3+...100的值  

                分析:  原式可逐次拆分

                        100 + （99 + 98  +  ... + 1) 

                --->  100  + （ 99 + （98 + 97 + ... 1）)

                --->  100  + （ 99 + （98 + (97 + 96 + ...+ 1)）)

       代码实现如下 :

function getSum(n) {
                //明确递归的结束条件为 变量为1
                if (n === 1) {
                    return 1; // 结束函数运行
                } else {
                    //分解问题
                    return n + getSum(n -1 );
                }
        }
        let sum  = getSum (100);
        console.log(`1+2+3+... + 100 =${sum}`);