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

例子：定义一个函数，求1+2+3+...+100的值

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！+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)

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

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、实参：实在参数。是函数调用时出现在函数首部的参数，实参表示的是一个实际值

例子：定义一个函数，计算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)

例子：定义一个函数，用于输出一个二维数组

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)

例子：定义一个函数，用来判断一个数是否是素数，若是素数返回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对象中

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

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对象，本质是一个数组，保存的是调用函数时传递的实参

例子：定义一个函数，输出1000以内的所有'完数'。

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)
    }
}