函数精讲：声明、调用与参数-优快云博客

函数
（1）概念：封装了一段可以被重复执行调用的代码块；目的：让大量代码可以重复使用；
（2）函数使用：
先声明函数再调用函数（函数名加小括号）；
1，function声明函数的关键字全部小写；
2，函数是做某件事情，函数名一般是动词；
3，函数不调用自己不执行；
（3）函数的封装：
把一个或多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口；

（4）函数的参数：形参和实参；在声明函数的小括号里的是形参，在调用函数的小括号里的是实参；形参是接受实参的，形参类似于一个变量；函数的参数可以有，也可以没有，个数不限。目的：在函数内部某些值不能固定，可以通过参数在调用函数时传递不同的值过去。注意点：多个参数之间用逗号隔开；形参可以看做是不用声明的变量。
1，如果形参和实参个数一致，则正常输出结果；
2，如果实参个数多于形参个数，会取到形参个数；
3，如果实参个数小于形参个数，多余的形参定义为undefined 最终结果为NaN
模板：

function 函数名(形参1,形参2,){
        }
        函数名(实参1,实参2);

例子：用函数求任意两个数之间的和

 function getSum(start, end) {
            var sum = 0;
            for (var i = start; i <= end; i++) {
                sum += i;
            }
            console.log(sum);
        }
        getSum(1, 100);

（5）return语句：
1，函数只是实现某种功能，最终的结果需要返回给函数的调用者函数名（）通过return实现；
2，只要函数遇到return，就把后面的结果返回给函数的调用者函数名（）=return后面的结果；
3，函数都是有返回值的，有return则返回return后面的值，没有则返回undefined；
例子：求两个值的最大值

function getMax(a, b) {
            if (a > b) {
                return a;
            } else {
                return b;
            }
        }
        console.log(getMax(4, 9));

    **三元运算符形式**：`return a > b ? a : b;`
    在实际开发中，经常使用一个变量来接受函数的返回结果：
    `        var res=getMax(4,9);
    console.log(res);`

（6）break、continue、和return的区别：
break：结束当前的循环体（如for、while）；
continue：跳出本次循环，继续执行下次循环（如for、while）；
return：不仅可以退出循环，还能够返回return语句中的值，同时可以结束当前的函数体内的代码；
例子：打印计算的结果

function getRes(a, b) {
            return [a + b, a - b, a * b, a / b];
        }
        var res = getRes(1, 2);
        for (var i = 0; i < res.length; i++) {
            console.log(res[i]);
        }

例子：简单计算器

function jiSu() {
            var a = prompt("第一个数字");
            var b = prompt("请输入运算符");
            var c = prompt("第二个数字");
            switch (b) {
                case "+":
                    return parseFloat(a) + parseFloat(c）;
                    break;
                case "-":
                    return a - c;
                    break;
                case "*":
                    return a * c;
                    break;
                case "/":
                    return a / c;
                    break;
            }
        }
        alert(jiSu());

（7）arguments的使用：当不确定有多少个参数传递时，可以用arguments获取，它是当前函数的一个内置对象，所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参； arguments展示形式是一个伪数组，具有数组的length属性，按照索引的方式进行存储；只有函数才有该对象，而且每个函数都有该对象。
例子：求任意个数的最大值

function getMax() {
            var max = arguments[0];
            for (var i = 1; i < arguments.length; i++) {
                max = arguments[i];
            }
            return max;
        }
        console.log(getMax(1, 5, 3, 9));
        console.log(getMax(1, 5, 3, 55));
        console.log(getMax(1, 5, 3, 91));

例子2：翻转任意数组reverse

function reverse(arr) {
            var arr1 = [];
            for (var i = arr.length - 1; i >= 0; i--) {
                arr1[arr1.length] = arr[i];
            }
            return arr1;
        }
        var re = reverse([1, 2, 3, 4, 5, 6]);
        console.log(re);

例子3：利用函数封装对数组进行冒泡排序sort

function sort(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;
        }
        var re = sort([1, 3, 6, 2, 5, 4]);
        console.log(re);

（8）函数的调用：函数之间是可以相互调用的
例子：判断是否是闰年

function backDay() {
            var year = prompt("请输入年份");
            if (isRunYear(year)) {
                alert('当前年份是闰年二月有29天');
            } else {
                alert('当前年份是平年二月有28天');
            }
        }
        backDay();
        function isRunYear(year) {
            var flag = false;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            }
            return flag;
        }

（9）函数的声明方式：
1，利用函数关键字自定义函数（命名函数）