函数（方法、参数、参数的数量、arguments对象的使用）

一、函数（方法）

1、什么是函数？

函数是一个可以重复使用的程序模块，该程序模块可以完成一个特定的功能

2、函数的定义：

function 函数名（【参数】]）{

           函数体语句

}

        （1）function：是关键字，必须小写

        （2）函数名：用户标识符（用户自定义）

        （3）【参数】：'()'不能省略，'参数'是可选的（函数可以有参数，也可以没有参数）

        （4）'{}'：不能省略，表示函数的控制范围

        （5）'函数体语句'：实现功能的代码

function getSum(){
     let sum = 0
     for(let i=1;i<=100;i++){
           sum += i
     }
     return sum    //返回
}

3、函数的调用：

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

                   let / var 变量 = 函数名(【参数】)

（2）无返回值的函数调用：

                   函数名（【参数】）

             例：定义一个函数，返回所有水仙花数 

function circulation() {
            let arr = [];
            for (let i = 100; i < 1000; i++) {
                let a = i % 10;
                let b = parseInt(i / 10 % 10);
                let c = parseInt(i / 100);
                if (i == a ** 3 + b ** 3 + c ** 3) {
                    arr.push(i);
                }
            }
            // return arr;
            console.log(arr);
        }
        // console.log(circulation());
        circulation();

注意：关于函数的返回值

           a、函数是否要返回值由具体的需求决定

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

二、函数的参数：函数在运行时需要外部的数据才是实现具体的功能。这个外部的数据就是参数

1、形参：形式参数，是在函数定义时出现在函数首部的参数。形参没有实际值，只是一个占位符

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

3、在函数调用时，参数的传递方向是实参--->形参（传递方向是单向的，当形参发生改变后不会影响实参）

        例：参数传递是单向的：实参--->形参

 //参数传递是单向的：实参--->形参
        function swap(x,y){ //两个形参
            console.log('形参;x='+x+',y='+y);
            let temp = x;
            x = y;
            y = temp;
            console.log('形参;x='+x+',y='+y);
        }

        //调用函数
        let a = 5;b = 6;
        console.log('实参;a='+a+',b='+b);
        swap(a,b);
        console.log('实参;a='+a+',b='+b);

三、函数参数的数量：在javascript中允许函数的形参与实参不同

1、实参的数量多于形参的数量：函数可以正常运行，多余的实参被忽略

function f1(m,n){ //m、n是形参
            return m+n
        }
 
let t = f1(11,22,33,55) //实参是4个,多余的实参被忽略
console.log(t)

2、实参的数量少于形参的数量：多出的形参是一个已声明未赋值的变量，它的值是undefined

function f2(a,b,c){ //形参是3个，c的值是undefined
            console.log('a='+a+',b='+b+',c='+c)
}
 
f2(123,456) //实参是2个

四、arguments对象的使用

1、是内置对象：已经定好的，用户只要使用即可

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

强调：每个函数内部都有一个arguments对象，本质是一个数组，保存的是调用函数时传递的实参

        例：定义一个函数，判断一个数是否是'完数'

function fun(n){  //判断n是否是完数
            let sum = 0  //sum用于累加n的因子
            for(let i=1;i<n;i++){
                if(n % i == 0){ //条件为真，表示i是n的因子
                    sum += i  
                }
            }
            if(sum === n){  //sum存放n的所有因子之和
                return true
            }else{
                return false
            }
}

//输出1000以内的所有'完数'
for(let j=1;j<1000;j++){
    if(fun(j)){
       console.log(j)
    }
}

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

1、定义

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

                         函数体语句

           }

2、调用

          变量名（【参数】）

let min = function(val1,val2){
            if(val1 < val2){
                return val1
            }else{
                return val2
            }
        }
        
let  t = min(12,25)
console.log('最小数：',t)

六、函数的递归调用（重点、难点）

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

2、递归算法：

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

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

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

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

         （2）递归的过程

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

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

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

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