JavaScript函数（方法）基础知识

一、什么是函数？

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

二、函数的定义：

           function 函数名 （【参数】）{

               函数体语句

      }

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

（2）函数名：用户标识符（用户自定义）--- 建议：见名知意。

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

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

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

 //1~100的累加
 function getSum(){
             let sum = 0;
             for(let i = 0; i <= 100; i++){
                 sum += i;
             }
             return sum;
         }

三、函数的调用：

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

        let 变量 = 函数名 （【参数】）

 //1~100的累加
 function getSum(){
             let sum = 0;
             for(let i = 0; i <= 100; i++){
                 sum += i;
             }
             return sum;
         }
         let a = getSum();//getSum函数中return返回值赋值给a
         console.log('1+2...+100=',a);

练习：定义函数计算1! + 2! +...5!的和。

  function getSum(){
             let sum = 0;
             
             for(let i = 1; i <= 5; i++){
                 let count = 1;
                 for(let j = 1; j <= i; j++){
                     count *= j;
                 }
                 sum += count;
             }
             return sum;
         }
         console.log('结果：',getSum());

练习：定义一个函数，返回所有水仙花数。

 function getSum(){
             let a = [];
         for(let i = 100; i < 1000; i++){
                 let gewei = i % 10;
                 let shiwei = parseInt(i / 10 % 10);
                 let baiwei = parseInt(i / 100);
             if(i === gewei ** 3 + shiwei ** 3 + baiwei ** 3){
                a.push(i);
             }
         }
             return a;
         }
         console.log(getSum());

注意：关于函数的返回值

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

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

2、无返回值的函数调用：

函数名（【参数】）

四、函数的参数

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

1、形参：

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

function getNum(n){//n为形参
             let sum = 1
             for(let i = 1; i <= n; i++){
                 sum *= i;
             }
             return sum;
         }

2、实参：

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

练习：

//定义一个函数，计算n!
 ​
 function getNum(n){//n为形参
             let sum = 1
             for(let i = 1; i <= n; i++){
                 sum *= i;
             }
             return sum;
         }
 ​
         let k = prompt('输入一个数')//k为实参
         let m = getNum(k);
         console.log(m);

 //定义一个函数，用于输出一个二维数组
 ​
         function showArray(arr){//arr为形参
             let str = '';
             for(let i = 0; i < arr.length; i++){
                 for(let j = 0; j < arr[i].length; j++){
                     str += arr[i][j] + '\t';
                 }
                 str += '\n';
             } 
             console.log(str);
         }
       
         let a1 = [[1,2,3],[4,5,6],[7,8,9]]//a1为实参
         showArray(a1);
 ​
         let a2 = new Array(new Array(11,22,33,44),new Array(55,66,77,88));
         showArray(a2);

//定义一个函数，用来判断一个数是否是素数，是返回true，不是返回false
 ​
         function isPrime(n){//n为形参
             for(let i = 2; i < n; i++){
                 if(n % i == 0){
                     return false;
                 }
             }
             return true;
         }
 ​
         let k = prompt('输入一个数')
         console.log(isPrime(k));
 ​
         //输出100以内所有素数
 ​
         let str = ''
         for(let i = 2; i <= 100; i++){
             if(isPrime(i) == true){//i是实参
                 str += i + '\t'
             }
         }
         console.log(str);

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;
         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对象中。

//定义一个函数，返回调用该函数时实参中的最大值
 ​
         function getMax(){
             let max = arguments[0];
             for(let i = 0; i < arguments.length; i++){
                 if(max < arguments[i]){
                     max = arguments[i];
                 }
             }
             return max;
         }
 ​
         let a = getMax(12,23,333,256);
         console.log(a);//返回结果：333

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

练习

 /* 定义一个函数，判断一个数是否是"完数"
         完数：某个数的所有因子（不包含自身）之和等于它本身 */
 ​
         function getNum(n){
             let sum = 0;
             for(let i = 1; i < n; i++){
                 if(n % i == 0){
                     sum += i;
                 }
             }
             if(sum == n){
                     return true
                 }else{
                     return false
                 }
            
         }
 ​
         //输出1000以内的所有'完数'
         for(let j = 1; j < 1000; j++){
             if(getNum(j)){
                 console.log(j);
             }
         }