javascript-函数

一、函数（方法）：

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 变量 = 函数名(【参数】)

function getSum(){
            let sum = 0
            for(let i=1;i<=100;i++){
                sum += i
            }
            return sum
}
​
let  t = getSum()  //getSum函数中return语句将sum的值返回后赋给变量t
console.log('1+2+3+...+100=',t)

练习1：定义函数，计算1！+2！+3！+4 + 5!

function getSum(){
            let sum = 0
            for(let i=1;i<=5;i++){  //外循环：累加的
                //计算i的阶乘
                let t = 1
                for(let k=1;k<=i;k++){  //内循环：计算当前i的阶乘
                    t *= k
                }
                sum += t
            }
            return sum
        }
​
        function getSum1(){
            let sum = 0;
            let t = 1
            for(let i=1;i<=5;i++){
                t *=i
                sum +=t
            }
            return sum
        }
​
        let k = getSum1()
        console.log("1！+2！+3！+4！+5！=",k)

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

function getNumber(){
            let arr = []  //用来保存'水仙花'数
            for(let i=100;i<1000;i++){
                //1.拆分三位数
                let g = i%10
                let s = parseInt(i/10)%10
                let b = parseInt(i/100)
                //2.求各位数字的立方和
                if((g**3+s**3+b**3)=== i){
                    arr.push(i)
                }
            }
            return arr
        }
console.log(getNumber())

注意：关于函数的返回值

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

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

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

函数名（【参数】）

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

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

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

练习3：定义一个函数，计算n!（n的值由外部传入）

//定义一个函数，计算n!
        function getNum(n){  //n是形参，是函数定义时，放在函数名后的'()'中
            let t = 1
            for(let i=1;i<=n;i++){
                t *= i
            }
            return t
        }
​
        let k = 8
        let m = getNum(k) //5是实参。在函数调用时实参传递给形参
        console.log(m)

练习4：定义一个函数，用于输出一个二维数组

function showArray(arr){ //arr是形参
            let str=''
            for(let i=0;i<arr.length;i++){ //外循环：循环变量i是行下标
                for(let j=0;j<arr[i].length;j++){//内循环：循环变量j是列下标
                    str += arr[i][j] + '\t'
                }
                str += '\n'
            }
            console.log(str)
        }
​
        let a1 = [[1,2,3],[4,5,6],[7,8,9]]
        showArray(a1)
​
        let a2 = new Array(new Array(11,22,33,44),new Array(77,88,99,55))
        showArray(a2)

练习5、定义一个函数，用来判断一个数是否是素数，若是素数返回true，若不是返回false

//定义函数：判断一个数是否是素数
        function isPrime(n){  //n是形参
            // let flag = true  //假设n是素数
            for(let i=2;i<n;i++){
                if(n % i == 0){
                    // flag = false
                    // break
                    return false
                }
            }
            return true
        }
​
       //输出100以内的所有素数
       let str = ''
       for(let k=2;k<=100;k++){
          if(isPrime(k)==true){ //k是实参
            str += k+'\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
        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对象中

练习6：定义一个函数，返回调用该函数时实参的最大值

function getMax(){
            let max = arguments[0] //假设第一个实参是最大的
            for(let i=1;i<arguments.length;i++){
                if(max < arguments[i]){
                    max = arguments[i]
                }
            }
            return max
}
​
let m = getMax(78,45,156,98)
console.log(m)

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

练习7：定义一个函数，判断一个数是否是'完数'

'完数'是某个数的所有因子（不包含自身）之和等于它本身

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、自下而上回溯得到原问题的解

3、代码实现：

       //用递归函数计算 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)

练习1：定义递归函数，计算1+2+3+...100的值

 ```javascript

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

         let sum = fun(100)
            console.log(sum)