JavaScript-----9.函数

1.函数的使用

1.1 声明函数和调用函数

//1.声明函数
//function 函数名() {
//    //函数体
//}
function sayHi() {
    console.log('hi~');
}

//2.调用函数
//函数名();
sayHi(); //hi~

案例：利用函数计算1~100之间的累加和

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

}
getSum(); //5050
getSum(); //5050

2.函数的参数

2.1语法格式

//1.声明
//function 函数名(形参1， 形参2，...) {
//    //函数体
//}
//2.调用
//函数名(实参1， 实参2，...);
function cook(aru) {
    console.log(aru);
}
cook('酸辣土豆丝'); //酸辣土豆丝

说明：

• 函数的参数可以有，也可以没有，个数不限

2.2案例：利用函数求任意两个数之和

function getSum(a, b) {
    console.log(a + b);
}
getSum(1, 5); //6
getSum(66, 66); //132

2.3案例：利用函数求任意两个数之间的数之和

function getSum(a, b) {
    var sum = 0;
    for (var i = a; i <= b; i++) {
        sum = sum + i;
    }
    console.log(sum);
}
getSum(1, 100); //5050
getSum(2, 6); //20

说明：形参可以是看作两个不用声明的变量

2.4函数实参和形参不匹配问题

function getSum(num1, num2) {
    console.log(num1 + num2);
}
//1.如果实参的个数和形参的个数一致则正常输出
getSum(1, 2); //3
//2.如果实参个数多于形参个数则会取到形参的个数
getSum(1, 2, 3); //3
//3.如果实参个数小于形参个数
//由于形参是可以看作不用声明的变量  num2是一个变量但是没有接收值，那num2就是undefined
getSum(1); //NaN

//建议：尽量让实参的个数和形参的个数相匹配

3.函数的返回值

3.1语法格式

//格式
function 函数名() {
    return 需要返回的结果
}
函数名();

3.2运用

function getResult() {
    return 666;
}
getResult();
console.log(getResult()); //666

3.3之前程序的改进

function cook(aru) {
    return aru;
}
console.log(cook('酸辣土豆丝')); //酸辣土豆丝

function getSum(num1, num2) {
    return num1 + num2;
}
console.log(getSum(1, 2)); //3

3.4案例

案例1：利用函数求两个数的最大值
方法1：

function getMax(a, b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}
console.log(getMax(1, 5)); //5
console.log(getMax(10, 5)); //10

方法2：

function getMax(a, b) {
    return a > b ? a : b;
}
console.log(getMax(1, 5)); //5
console.log(getMax(10, 5)); //10

案例2：利用函数求数组中的最大值

function getArrMax(a) {
    var len = a.length;
    var max_value = a[0];
    for (var i = 1; i < len; i++) {
        if (a[i] > max_value) {
            max_value = a[i]
        }
    }
    return max_value;
}
var re = getArrMax([5, 2, 99, 101, 67, 77]);
console.log(re); //101

3.5注意事项

• return除了可以返回函数值之外，还可以终止函数，即return之后的代码不会被执行
• return只能返回一个值，如果用逗号隔开多个值，以最后一个值为准

//1.终止函数
function getSum(num1, num2) {
    return num1 + num2;
    alert('我是不会被执行的哦!');
}
console.log(getSum(1, 2));

//2.return只能返回一个值
function fn(num1, num2) {
    //如果用逗号隔开多个值，以最后一个值为准 返回num2
    return num1, num2;
}
console.log(fn(1, 2)); //2

案例：求两个数的加减乘除

function getResult(num1, num2) {
    return [num1 + num2, num1 - num2, num1 * num2, num1 / num2];
}
var re = getResult(6, 3);
console.log(re);

• 若函数没有return 则返回的是undefined

function fun() {

}
console.log(fun());//undefined

3.6 break continue return的区别

• break:结束当前的循环
• continue:跳出本次循环，继续执行下次循环
• return: 不仅可以退出循环还可以返回return语句中的值，同时还可以结束当前函数体内的代码

3.7作业

作业1：写一个函数，用户输入任意两个数字的任意算数运算，弹出运算后的结果(简单计算器)

function cal() {
    num1 = prompt('请输入第一个数');
    symbol = prompt('请输入运算符号');
    num2 = prompt('请输入第二个数');

    switch (symbol) {
        case '+':
            return num1 + num2;
        case '-':
            return num1 - num2;
        case '*':
            return num1 * num2;
        case '/':
            return num1 / num2;
    }
}
alert(cal());

作业2：写一个函数，用户输入三个不同的数值，返回最大值

function maxnum(num1, num2, num3) {
    if (num1 > num2) {
        if (num1 > num3) {
            return num1;
        } else {
            return num3;
        }
    } else {
        if (num2 > num3) {
            return num2;
        } else {
            return num3;
        }
    }
}

作业3：写一个函数，用户输入一个数，判断是否是素数(可被1和自身整除的数)

function prime(num) {
    for (var i = 2; i <= num / 2; i++) {
        if (num % i == 0) {
            return num + '不是素数';
        }
    }
    return num + '是素数';
}
alert(prime(2));//2是素数

4.arguments的使用

之前提到过函数的实参和形参最好匹配上，否则如果实参多了可能会用不上，实参少了可能会出问题。当我们不确定有多少个参数传递的时候，可以用arguments来获取。在JavaScript中，arguments是当前函数的一个内置对象。所有的函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。

伪数组
arguments展示形式是一个伪数组，因此可以进行遍历，伪数组具有以下特点：

• 具有length属性
• 按索引方式存储数据
• 可以遍历数组
• 不具有数组的push、pop等方法

//arguments的使用
function fn() {
    console.log(arguments); //Arguments(3) [1, 2, 3, callee: ƒ, Symbol(Symbol.iterator): ƒ]arguments是一个伪数组里面存储了所有传递过来的实参
    //arguments是伪数组
    console.log(arguments.length); //有长度3
    console.log(arguments[2]); //可索引3
    //可以按数组的方式遍历arguments=[1,2,3];
    for (var i = 0; i < arguments.length; i++) {
        console.log(arguments[i]);
    }
}
fn(1, 2, 3);

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

function maxnum() {
    var max = arguments[0];
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i] > max) {
            max = arguments[i];
        }
    }
    return max;
}
rel = maxnum(2, 5, 66, 2, 69, 129, 333, 2, 0);
console.log(rel);

5.函数的案例

5.1案例1

要求：利用函数封装的方法翻转任意一个数组

//利用函数封装的方法翻转任意一个数组
function reverArr(arr) {
    var arrNew = [];
    for (i = arr.length - 1; i >= 0; i--) {
        arrNew[arrNew.length] = arr[i];
    }
    return arrNew;
}
var a = [1, 2, 3, 4, 6, 8, 2, 6, 8];
var re = reverArr(a);
console.log(re);

5.2案例2

要求：利用函数封装的方式对数组排序（冒泡排序）

//冒泡排序
//对于i的范围：1个数，不用排； 两个数，排1趟； 三个数 排2趟。。。n个数，排n-1趟
//对于j的范围，n个数：第一趟比较n-1次，第二趟比较n-2次。。。第n-1趟比较1次
function sort(arr) {
    var temp;
    for (i = 0; i < arr.length - 1; i++) {
        for (j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
console.log(sort([4, 1, 6, 88, 9, 3, 666])); //(7) [1, 3, 4, 6, 9, 88, 666]

5.3案例3

要求：输入一个年份，判断是否是闰年（闰年：能被4整除且不可以被100整除或者可以被400整除）

<script>
    //输入一个年份，判断是否是闰年（闰年：能被4整除且不可以被100整除或者可以被400整除）
    function leap(year) {
        var flag = false;
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            flag = true;
        }
        return flag;
    }
    console.log(leap(2000)); //true
    console.log(leap(1999)); //false
</script>

5.4一个函数可以调用另一个函数

案例4
要求：用户输入年份，输出当年二月份的天数，即如果用户输入的是闰年二月份就是29天，如果用户输入的是平年，二月份就是28天

function backDays() {
    year = prompt('用户输入年份');
    if (leap(year)) {
        return alert(year + '年的二月份天数为' + 29 + '天');
    }
    return alert(year + '年的二月份天数为' + 28 + '天');
}
backDays()

//输入一个年份，判断是否是闰年（闰年：能被4整除且不可以被100整除或者可以被400整除）
function leap(year) {
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
    return flag;
}

6.函数的两种声明方式

• 利用函数关键自定义函数
• 函数表达式

//函数的2种声明方式
//1. 利用函数关键自定义函数（命名函数）
function fn() {

}
fn();
//2.函数表达式 匿名函数
//var 变量名=function(){}; 注意fun是变量名而不是函数名
var fun = function(aru) {
    console.log('我是函数表达式'); //我是函数表达式
    console.log(aru); //我是pink老师

}
fun('我是pink老师');
//（1）fun是变量名 不是函数名
//（2）函数表达式声明方式和声明变量差不多，只不过变量里存的是值，函数表达式里存的是函数
//函数表达式也可以进行传递参数