js-函数

函数就是封装一段可以被重复执行调用的代码块，目的：是让大量代码重复使用。
函数使用分为两步：
声明函数和调用函数
1、声明函数

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

2、调用函数

函数名();

注意：
● function 声明函数的关键字 全部小写
● 函数是做某件事情，函数名一般是动词
● 调用函数是要加小括号
● 函数不调用自己不执行

函数的封装
函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口，简单理解：封装类似于将电脑配件整合组装到机箱中（类似快递打包）
函数的参数
形参和实参
在声明函数时，可以在函数名称后面的小括号中添加一些参数，这些参数被称为形参，而在调用该函数时，同样也需要传递相应的参数，这些参数被称为实参。

参数	说明
形参	形式上的参数 函数定义的时候 传递的参数 当前并不知道是什么
实参	实际上的参数 函数调用的时候传递的参数 实参是传递给形参的

//1、函数可以重复相同的代码
function cook(){
	console.log('酸辣土豆丝')
}
cook();
//2、我们可以利用函数的参数实现函数重复不同的代码
function 函数名(形参1,形参2.....){  //在声明函数的小括号里面是形参（形式上的参数）

}
函数名(实参1,实参2...)  //在函数调用的小括号里面是实参（实际的参数）
//3、形参和实参的执行过程
function cook(aru){  //形参是接受实参的  aru = ‘酸辣土豆丝’ 形参类似于一个变量
	console.log(aru);
}
cook('酸辣土豆丝');  //输出结果为酸辣土豆丝
cook('肉丝炒饼')；   //输出结果为肉丝炒饼
//4、函数的参数可以有，也可以没有个数不限

注意：多个参数之间用逗号隔开，形参可以看做是不用声明的变量。
小案例：
利用函数求任意俩个数之间的和

<script>
        function getSum(num1, num2) {
            var sum = 0;
            for (var i = num1; i <= num2; i++) {
                sum += i;
            }
            console.log(sum);
        }
        getSum(1, 100);
    </script>

函数形参实参个数不匹配

参数个数	说明
实参个数等于形参个数	输出正确的结果
实参个数多于形参个数	只取到形参的个数
实参个数小于形参个数	多的形参定位为undefined，结果为NaN

如果俩个实参的个数多于形参的个数，会取到形参的个数

<script>
function getSum(num1, num2) {
            console.log(num1 + num2);
        }
        getSum(3, 4, 5)
        //输出结果为7，5不参与运算
</script>

如果实参的个数小于形参的个数，多余的形参定位为undefined 最终的结果为NaN

<script>
function getSum(num1, num2) {
            console.log(num1 + num2);
        }
        getSum(3)
        //输出结果为NaN
</script>

建议：形参和实参的个数相匹配
函数的返回值
return 语句
将值返回给调用者，此时通过使用return语句来实现

function 函数名(){
	return 需要返回的结果；
}
函数名();
//函数只是实现某种功能，最终的结果需要返回给函数的调用者  函数名();通过return实现的
//只要函数遇到return就把后面的结果 返回给函数的调用者 函数名() = return后面的结果
<script>
        function cook(aru) {
            return aru;
        }
        console.log(cook('青椒鸡蛋'));
    </script>
    //求任意俩个数的和
    <script>
        function getSum(num1, num2) {
            return num1 + num2;
        }
        console.log(getSum(2, 3));
    </script>

小案例：
求数组中的最大值

<script>
 function getArrMax(arr) {
            var max = arr[0];
            for (var i = 0; i <= arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i]
                }
            }
            return max;
        }
        var ar = getArrMax([1, 2, 9, 88, 7, 56, 99]);
        console.log(ar);
</script>

函数返回值注意事项：
return终止函数

 function getSum(num1, num2) {
            return num1 + num2;
            alert('由于return会终止函数，return后面的代码不会被执行')
        }
        console.log(getSum(1, 2));

return只能返回一个值。如果逗号隔开多个值，以最后一个值为准；如想要输出多个值，可使用数组

function fn(num1, num2) {
    return num1, num2;    //返回的结果是最后一个值
 }
console.log(fn(1, 2));
function getReuslt(num1, num2) {
    return [num1 + num2, num1 - num2, num1 * num2, num1 / num2]
}
var re = getReuslt(1, 2);
console.log(re);  //输出结果为数组 [3, -1, 2, 0.5]

函数如果有return则返回的是return后面的值，如果函数没有return则返回undefined
arguments的使用
当不确定有多少个参数传递的时候，可以用argument来获取。在JavaScript中，argument实际上是当前函数的一个内置对象。所有函数都内置了一个argument对象，argument对象中存储了传递的所有实参。

//arguments里面存储了所有传递过来的实参
<script>
        function arr() {
            console.log(arguments); //输出结果1,2,3,4
             console.log(arguments.length);
        }
        arr(1, 2, 3, 4);
    </script>
    //伪数组 并不是真正意思上的数组
    //1、具有数组的length属性
    //2、按照索引的方式进行存储
    //3、没有真正数组的一些方法pop() push()等等

注意：
● 只有函数才有arguments对象 而且是每个函数都内置好了arguments
小案例：
1、利用函数求任意个数的最大值

 function arr() {
     var max = arguments[0];
     for (var i = 1; i < arguments.length; i++) {
         if (arguments[i] > max) {
             max = arguments[i];
         }
     }
     return max;
 }
 var ar = arr(1, 5, 6, 9, 8)
 console.log(ar);

2、利用函数翻转数组

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

3、利用函数 对数组排序—冒泡排序

  function sort(arr) {
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - i - 1; j++) {
            var temp;
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
console.log(sort([1, 4, 7, 2, 5, 8]));

函数的调用
因为每个函数都是独立的代码块，用于完成特殊任务，因此经常会用到函数相互调用的情况。

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

    function fn2() {
        console.log(222);

    }
 </script>

小案例：
判断为闰年还是平年，闰年则显示2月有29天，平年则显示2月有28天。

function backDay() {
    var year = prompt('请随意输入年份');
    if (isRunYear(year)) {
        alert('' + year + '年为闰年，2月有29天');
    } else {
        alert('' + year + '年为平年，2月有28天');
    }
}
backDay();

function isRunYear(year) {
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
    return flag;
}

匿名函数表达式

var fun = function(){
	console.log(‘我是函数表达式’);
}
fun();
//（1）fun是变量名，不是函数名
//（2）函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值而函数表达式里面存的是函数
//（3）函数表达式也可以进行传递参数