关于javascript:javascript函数5

Js 函数的定义

函数：封装了一段可反复执行调用的代码块。

目标：能够让大量代码重复使用

求和

函数的命名是动词，而变量名的命名是名词

        function getSum(num1, num2) {
            var sum = 0;
            for (var i = num1; i <= num2; i++) {sum = sum + i;}
            return sum;

        }
        console.log(getSum(1, 100)); // 求~100 的和
        console.log(getSum(1, 1000)); // 求 1~1000 的和
    </script>

函数的应用？

1. 申明函数

2. 调用函数

申明函数

    function 函数名 () {// 函数体}

调用函数

  函数名 ()

注意事项

• function 是申明函数的关键字，必须是小写
• 函数是做某件事情，因而函数名为动词
• 函数自身不执行，必须调用能力应用
• 调用函数不要遗记加小括号呀

案例

    <script>
        // 申明函数
        function sayHi() {return '尧子陌'}

        // 调用函数
        console.log(sayHi())
    </script>

函数的封装

 函数的封装：简略而言，就是把一个性能或多个性能以函数的形式进行封装，对外提供一个简略的函数接口。简略了解：相似于快递打包。

求 1~10 之间的相乘的后果

    <script>
        function getSum(num1, num2) {
            var sum = 1;
            for (var i = num1; i <= num2; i++) {sum = sum *i;}
            return sum;

        }
        console.log(getSum(1, 10)); // 求~10 的相乘的后果

    </script>

带参数的函数

• 函数的参数：形参加实参
• 形参：申明函数时，函数名前面的小括号外面的参数是形参，形参是模式上的参数。形参是为了承受理论参数传递的值。
• 实参：调用函数时，函数名前面的小括号外面的参数是实参，实参是实际上的参数。

• 参数：函数外部的值不固定，咱们能够通过参数调用函数传递不同的值进去

    // 申明函数
    function 函数名 (形参 1，形参 2...){ }
    // 调用函数
     函数名 (实参 1，实参 2...) 
  

    <script>
        // 申明函数
        function cook(arr) {return arr}
        

        // 调用函数
        console.log(cook("酸辣土豆丝"))
        console.log(cook("香辣大白菜"))
    </script>

函数的参数能够有，也能够没有, 依据状况而定

函数的案例

求任意两个数的和

    <script>
        // 申明函数
        function getSum(num1, num2) {return num1 + num2}
        // 调用函数
        console.log(getSum(100, 200))
        console.log(getSum(10, 20))
    </script>

求任意两个数之间的和

<script>
    // 申明函数
    function getSum(star, end) {
        var sum = 0;
        for (var i = star; i <= end; i++) {sum = sum + i;}
        return sum
    }
    // 调用函数
    console.log(getSum(20, 50))
    console.log(getSum(1, 100))
</script>

函数形参加实参个数的匹配

函数形参加实参个数统一的状况下，则失常输入后果

<script>
    // 申明函数
    function getSum(num1, num2) {return num1 + num2}

    // 调用函数
    console.log(getSum(10, 20))
</script>

函数形参的个数小于实参的个数，则取形参的个数

<script>

    // 申明函数
    function getSum(num1, num2) {return num1 + num2}

    // 调用函数
    console.log(getSum(1, 200, 500))
</script>

函数形参的个数大于实参的个数，则后果为 undefined

剖析如下

• 函数的形参能够看作是未声明的变量，后果为 undefined
• 任何数值加 undefind 最终后果都为 NaN(不是一个数值)

<script>
    // 申明函数
    function getSum(num1, num2, num3) {return num1 + num2 + num3}

    // 调用函数
    console.log(getSum(100, 200)) // 形参的个数大于实参的个数的状况下 
    console.log(getSum(100, 200, 500)) // 形参的个数与实参的个数统一的状况下
</script>

函数参数的总结

• 函数能够带参数，也能够不带参数
• 函数的参数有多个时，两头用英文状态下的逗号相隔
• 申明函数时，函数名小括号里的参数为形参，其默认值为 undefined
• 调用函数时，函数名前面的小括号为实参，用来传递值给形参
• 函数的形参加实参的个数该当统一，否则后果难以预计。

函数的返回值

函数是做某件事情或实现某种性能，最终都会把后果返回给函数调用者

<script>
    // 申明函数
    function getResult() {return 520}
    // 调用函数
    console.log(getResult())
</script>

察看执行过程，在函数执行过程中，遇到 retern 便会把前面的后果返回给函数的调用者

求两个数之间的最大值

第一种办法：利用 if 语句

<script>
    function comParison(num1, num2) {if (num1 > num2) {return num1} else {return num2}
    }
    console.log(comParison(20, 50))
</script>

第二种办法：利用三元表达式

<script>
    function comParison(num1, num2) {return num1 > num2 ? num1 : num2}
    console.log(comParison(20, 50))
</script>

利用函数求最大值

留神：在理论开发过程中，通常用变量接管函数的返回值

<script>
    function getMax(arr) {var max = arr[0];
        for (var i = 0; i <= arr.length; i++) {if (max < arr[i]) {max = arr[i]
            }
        }
        return max

    }

    // 在理论开发中，咱们通常用一个变量来接管函数的返回值。var result = getMax([5, 2, 22, 96, 85])
    console.log(result)
</script>

return 终止函数

在函数外部 retur 返回的后果前面的语句不执行

<script>
    function getSum(num1,num2) {
        return num1+num2;
        alert("return 终止函数")  //return 后果前面的代码块不会执行
    }
   console.log(getSum(20,50))
</script>

return 前面只能返回一个值

<script>
    function  getSum(num1,num2) {return num1,num2}
console.log(getSum(2,5))
</script>

利用数组能够返回多个值

<script>
    function getSum(num1,num2) {return [num1*num2,num1/num2,num1+num2,num1- num2]
    }
    console.log(getSum(20,50))
</script> 

break continue nreturn 的区别

• break: 完结以后循环
• continue：跳出以后循环，持续下一次循环
• return: 不仅能够跳出循环而且能够完结函数体内的代码，返回 return 前面的后果

通过榨汁机来看透函数

arguments 的应用

 当咱们不确定传递多少个实参的时候，能够应用 arguments 对象，arguments 对象是函数内置的对象，存储着所有传递过去的实参

<script>
    function fn() {console.log(arguments);
        for(var i =0;i<arguments.length;i++) {return arguments[i]
        }
    }
    console.log(fn(20,20,50,80))
    console.log(fn(20,20,50,80,100))
</script>

注意事项

• arguments 是伪数组，并不是真正的数组
• 具备 length 属性，依照索引的形式进行存储
• 不能应用真正的数组办法，如 push() pop() 等等

利用 arguments 求任意个数的最大值

• 思路如下 数组中求最大值的思路一样，只不过采纳 arguments 对象来获取数组中的最大值。

<script>
        
    function getMax() {
        // 申明一个最大变量 Max
        var Max = 0;
        for(var i=0;i<arguments.length;i++) {if(Max<arguments[i]) {Max = arguments[i]
            }
        }
        return Max;
    }
    
    console.log(getMax(20,50,60)) //60
    console.log(getMax(20,50,60,100)) //100
    </script>
</script>

函数封装的案例

采纳函数封装的形式 反转任意数组

<script>
    function reserve(arr) {var newArr= [];
        for(var i = arr.length-1 ;i>=0;i--) {newArr[newArr.length] = arr[i]

        }
        return newArr

    }
    console.log(reserve([10,20,50]));
     console.log(reserve([10,20,50,500,4522,205]));
</script>

利用函数封装的形式 实现冒泡排序

<script>
    function sorce(arr) {for(var i = 0;i<arr.length-1;i++){for(var j = 0;j<arr.length-i-1;j++) {if(arr[j]>arr[j+1]) {var temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp


                }
            }
        }
        return arr
    }

    console.log(sorce([20,50,80,30,15,60]))
    console.log(sorce([200,510,880,30,195,60]))
</script>

利用函数封装的形式 实现判断是否是平年

申明一把锁，如果是平年，则返回 true，如果不是平年，则返回 false

<script>
    function isRunYear(year) {
        
        var flag  = false;
        if(year % 4 ==0 && year % 400 != 0 || year % 400 == 0) {flag = true;}
        return flag
    }
    console.log(isRunYear(2000))
     console.log(isRunYear(2001))
</script>

函数之间能够相互调用

每个函数都是一个独立的代码块，为了实现特殊任务，函数之间能够互相调用

<script>
    function fn1() {console.log('111') 
        fn2() // 调用 fn2()
    }
    fn1()

    function fn2() {console.log('222');
        
    }
</script> 

求下列代码的后果

<script>
    function fn1() {console.log(111);
        fn2();
        
        console.log('fn1')

    }

    function fn2() {console.log(222);
        console.log('fn2')
    }
    fn1()
</script>

判断以后年份的二月份有多少天？

在 feBruary 函数中，if 判断语句中调用 isRunYear 函数并传参进去，如果为 true，则弹出 2 月份有 29 天，如果是 false，则弹出二月份有 28 天

<script>
 function  feBruary() {var year = prompt("请输出以后的年份")
    if(isRunYear(year)) {alert('以后是平年 2 月份有 29 天')
        
    }else {alert('以后是平年 2 月份有 28 天')
    }
 }


 feBruary() // 调用函数


    function isRunYear(year) {
        
        var flag  = false;
        if(year % 4 ==0 && year % 400 != 0 || year % 400 == 0) {flag = true;}
        return flag
    }
    console.log(isRunYear(2000))
    console.log(isRunYear(2001))
</script>

函数的两种申明形式

函数的第一种申明形式:function 关键字申明

function fn() {console.log('hello')
}
fn()

函数的第二种申明形式: 函数表达式申明函数

<script>
    var fn = function(str) {console.log(str)
    }
    fn('hello word')
</script>

留神：

• fn 是变量名 而不是函数名
• 申明变量和申明函数的形式差不多，只不过变量外面存储的值，函数表达式外面存储的是函数
• 函数表达式也能够传递参数