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）函数表达式声明方式和声明变量差不多，只不过变量里存的是值，函数表达式里存的是函数
//函数表达式也可以进行传递参数