函数 函数参数 函数传参 函数类型及应用

函数： 任意代码的封装，可以任意时候调用

        语法:

          function 函数名(){

              //封装的代码

          }

          使用函数需要用函数调用语句

          函数名()  //函数调用语句

 //定义一个名为getMax的函数
        function getMax(){
            var m = 10
            var n = 21
            var max = m
            if(n > max){
                max = n
            }
            console.log('最大值是 ',max)
        }
        
        console.log('程序开始111');

        getMax() // 函数调用语句
        
        console.log('程序结束');

函数的定义

 // 声明式定义一个函数

        function fn([形参...]){

            函数体

        }

        fn()

       

        // 赋值式定义一个函数

        var fn = function([形参...]){

            函数体

        }

        声明式与赋值式 区别：

          赋值式定义函数，必须先定义再使用，

          声明式定义函数，调用没有先后限制  

//  var fn = function(){
        //     console.log('这是赋值式定义一个函数');
        // }

        fn()

        function fn(){
            console.log('这是声明式定义一个函数');
        }

函数参数 

函数参数：

       //创建一个函数

        // 形参(行参)

        function 函数名(x,y,z){

            函数体

        }

       //调用函数

        函数名(10,20,30) //实参

function getMax(x) { //x=10
            let m = x
            console.log('m = ', m)
        }
        // getMax(10)


        /**
         * 求两个数最大值
         */
        function getMaxTwo(x,y){ //x = 34, y = 45
            var m = x
            var n = y
            var max = m
            if(n > max){
                max = n
            }
            console.log('最大值是 ',max)
        }

        getMaxTwo(34,45)

函数传参

形参与实参个数不相同是时，怎么处理?

            如果形参多了， 多的形参默认值是 undefined

            如果实参多了， 多的实参不起作用

参数默认值

传参的示例：

求34，56，78三个数的最大值，要求定义一个函数实现

            最大值思想:

               方法一:

                  让某个数与其它两个数比较，如果比其它两个数都大，则这个数就是最大值

               方法二:

                  假设第一个数是最大值，依次让后面的数与它比较，如果比它大，则将值赋值给它，继续重复比较

function getMaxThree(x,y,k){
            var m = x
            var n = y
            var z = k

            var max = m //假设第一个数是最大值
            if(n > max){
                max = n
            }
            if(z > max){
                max = z
            }
            console.log('最大值 ',max);

        }

        getMaxThree(34,65,78)

函数参数默认值

function fn(m){
            m = m || 100  // 参数默认值设置方式
            
            console.log('m :',m);
        }

        fn(21)

函数类型

函数类型

          参数 | 返回值

         1. 无参无返回值

           function fn(){

              //函数体

           }

           fn()

        2. 有参无返回值

           function fn(x){

               //函数体

           }

           fn(10)

        3. 无参有返回值

           function fn(){

               return 值

           }

           var f = fn()

        4. 有参有返回值

            function fn(m){

               return 值

           }

           var f = fn(10)

 function fn() {
            console.log('无参无返回值');
        }
        fn()

        function fn1(m) {
            console.log('有参无返回值', m);
        }
        fn1(100)

        function fn2() {
            console.log('无参有返回值');
            return 200
        }
        var m = fn2()
        console.log('m :', m)

        function getMaxTwo(m, n) {
            var max = m
            if (n > max) {
                max = n
            }
            return max
        }

        var m = getMaxTwo(34, 28)

        console.log('最大值 ', m)

函数类型应用

示例--// 打印20到100之间能被4整除的数

function printNum(start,end){
            for(var i = start; i <= end; i++){
                if(i % 4 == 0){
                    console.log(i)
                }
            }
        }

        printNum(20,100)