目录
4、 break 、 continue 、 return 的区别
一、函数的概念
在 JS 里面,可能会定义非常多的相同代码或者功能相似的代码,这些代码可能需要大量重复使用。虽然 for 循环语句也能实现一些简单的重复操作,但是比较具有局限性,此时我们就可以使用 JS 中的函数。
函数:就是封装了一段可被重复调用执行的代码块。通过此代码可以实现大量代码的重复使用。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 1. 求 1~100 的累加和
var sum = 0;
for (var i = 1; i <= 100; i++){
sum += i;
}
console.log(sum); // 结果为:5050
// 2. 求 10 ~50 的累加和
var sum = 0;
for (var i = 10; i <= 50; i++){
sum += i;
}
console.log(sum); // 结果为:1230
// 3.函数就是封装了一段可以重复被执行调用的代码块 目的:就是让大量代码重复使用
function getSum(num1,num2){
var sum = 0;
for (var i = num1; i <= num2; i++){
sum += i;
}
console.log(sum);
}
// 求 1~100 的累加和
getSum(1,100); // 结果为:5050
// 求 10 ~50 的累加和
getSum(10,50); // 结果为:1230
</script>
</body>
</html>
二、函数的使用
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 函数使用分为两步:声明函数 和 调用函数
// 1. 声明函数
// function 函数名(){
// // 函数体
// }
function sayHi(){
console.log('hi~~')
}
// (1) function 声明函数的关键字 全部小写
// (2) 函数是做某件事情,函数名一般是动词 sayHi
// (3) 函数不调用自己不执行
// 2. 调用函数
// 函数名();
sayHi(); //结果为:hi~~
// 调用函数的时候千万不要忘记加小括号
</script>
</body>
</html>
1、声明函数
- function 是声明函数的关键字,必须小写
- 由于函数一般是为了实现某个功能才定义的,所以通常我们将函数名命为动词,比如 getSum
2、调用函数
- 调用的时候千万不要忘记添加小括号
- 口诀:函数不调用,自己不执行。
注意:声明函数本身并不会执行代码,只有调用函数时才会执行函数体代码。
3、函数的封装
- 函数的封装是把一个或者多个功能通过函数的方式封装起来,对外只提供一个简单的函数接口
案例:利用函数计算 1~100之间的累加和
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 利用函数计算 1~100 之间的累加和
// 1.声明函数
function getSum(){
var sum = 0;
for(var i = 1; i <= 100; i++){
sum += i;
}
console.log(sum);
}
// 2.调用函数
getSum(); // 结果为:5050
</script>
</body>
</html>
三、函数的参数
1、形参和实参
在声明函数时,可以在函数名称后面的小括号中添加一些参数,这些参数被称形参,而调用该函数时,同样也需要传递相应的参数,这些参数被称为实参。
参数的作用:在函数内部某些值不能固定,我们可以通过参数在调用函数时的传递不同的值进去。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 1.函数可以重复相同的代码
function cook(){
console.log('红烧鱼');
}
cook(); //结果为:红烧鱼
// 2.我们可以利用函数的参数实现函数的重复不同的代码
// function 函数名(形参1,形参2...) { // 在声明函数的小括号里面是 形参 (形式上的参数)
// }
// 函数名(实参1,实参2...); //在函数调用的小括号里面是 实参 (实际的参数)
// 3.形参和实参的执行过程
function cook(aru){ // 形参是接受实参的 aru = '红烧鱼' 形参类似于一个变量
console.log(aru);
}
cook('红烧鱼') //结果为:红烧鱼
cook('糖醋鱼') //结果为:糖醋鱼
// 4.函数的参数可以有,也可以没有个数不限
</script>
</body>
</html>
2、利用函数求任意两个数的和
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 1.利用函数求任意两个数的和
function getSum(num1,num2) {
console.log(num1 + num2);
}
getSum(1,3); // 结果为:4
getSum(2,2); // 结果为:4
// 2.利用函数求任意两个数之间的和
function getSum(start,end) {
var sum = 0;
for(var i = start; i <= end; i++){
sum += i;
}
console.log(sum);
}
getSum(1,100); //结果为:5050
getSum(1,10); //结果为:55
// 3.注意点
// (1) 多个参数之间用逗号隔开
// (2) 形参可以看做是不用声明的变量
</script>
</body>
</html>
3、函数形参个数不匹配问题
注意:在 JavaScript 中,形参的默认值是undefined。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 函数形参实参个数匹配
function getSum(num1,num2) {
console.log(num1 + num2);
}
// 1.如果实参的个数和形参的个数一致 则正常输出结果
getSum(1,2); //结果为:3
// 2.如果实参的个数多于参数的个数 会取到形参的个数
getSum(1,2,3); //结果为:3
// 3.如果实参的个数小于形参的个数 多于的形象定义为undefined 最终的结果就是 NaN
// 形参可以看做是不用声明的变量 num2 是一个变量但是没有接受值 结果就是undefined
getSum(1); //结果为:NaN
// 建议 我们尽量让实参的个数和形参相匹配
</script>
</body>
</html>
4、小结
- 函数可以带参数也可以不带参数
- 声明函数的时候,函数名括号里面的是形参,形参的默认值为undefined
- 调用函数的时候,函数名括号里面的是实参
- 多个参数中间用逗号分隔
- 形参的个数可以和实参个数不匹配,但是结果不可预计,我们尽量要匹配
四、函数的返回值
1、return 语句
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 1. 函数是做某件事或者实现某种功能
function cook(aru) {
console.log(aru);
}
cook('红烧鱼'); //结果为:红烧鱼
// 2. 函数的返回值格式
// function 函数名() {
// return 需要返回的结果;
// }
// 函数名();
// (1) 我们函数只是实现某种功能,最终的结果需要返回给函数的调用者 通过return 实现
// (2) 只要函数遇到return 就把后面的结果 返回给函数的调用者 函数名() = return后面的结果
// 3. 代码验证
function getResult(){
return 666;
}
getResult(); // getResult() = 666
console.log(getResult()); //结果为:666
// function cook(aru){
// return aru;
// }
// console.log(cook('糖醋鱼')); //结果为:糖醋鱼
// 4. 求任意两个数和
function getSum(num1,num2){
return num1 + num2;
}
console.log(getSum(1,2)); //结果为:3
</script>
</body>
</html>
案例:利用函数求任意两个的最大值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
//利用函数 求两个数的最大值
function getMax(num1,num2) {
// if(num1 > num2) {
// return num1;
// } else {
// return num2;
// }
// 或者这样
return num1 > num2 ? num1 : num2;
}
console.log(getMax(1,3)); // 结果为:3
console.log(getMax(11,3)); // 结果为:11
</script>
</body>
</html>
案例:利用函数求任意一个数组中的最大值
求数组[ 5,2,99,101,67,77 ] 中的最大数值。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 利用函数求数组 [5,2,99,101,67,77] 中的最大数值
function getArrMax(arr) { // arr 接受一个数组 arr=[5,2,99,101,67,77]
var max = arr[0];
for(var i = 1; i <= arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
// getArrMax([5,2,99,101,67,77]); // 实参是一个数组送过去
// 在我们实际开发里面,我们经常用一个变量来接受 函数的返回结果 使用更简单
var re = getArrMax([5,2,99,101,67,77]);
console.log(re); // 结果为:101
</script>
</body>
</html>
2、 return 终止函数
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 函数返回值注意事项
// 1. return 终止函数
function getSum(num1,num2){
return num1 + num2; // return 后面的代码不会被执行
alert('我是不会被执行的哦!')
}
console.log(getSum(1,2)); //结果为:3
// 2. return 只能返回一个值
function fn(num1,num2){
return num1,num2; // 返回的结果是最后一个值
}
console.log(fn(1,2)); //结果为:2
// 3. 我们求任意两个数的 加减乘数结果
function getResult(num1,num2) {
return [num1 + num2, num1 - num2 ,num1 * num2 ,num1 / num2];
}
var re = getResult(1,2); // 返回的是一个数组
console.log(re); // 结果为:[3, -1, 2, 0.5]
</script>
</body>
</html>
3、函数没有 return 返回 undefined
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 我们函数如果有 return 则返回的是 return后面的值, 如果函数没有 return 则返回undefined
function fun1(){
return 666;
}
console.log(fun1()); // 返回666
//
function fun2(){
}
console.log(fun2()); // 函数返回的结果是 undefined
</script>
</body>
</html>
函数都是有返回值的
1. 如果 return 则返回 return 后面的值
2. 如果没有 return 则返回 undefined
4、 break 、 continue 、 return 的区别
- break :结束当前的循环体(如for 、while)
- continue:跳出本次循环,继续执行下次循环(如for 、while)
- return:不仅可以退出循环,还能够返回 return 语句中的值,同时还可以结束当前的函数体内的代码
五、 arguments 的使用
当我们不确定有多少个参数传递的时候,可以用 arguments 来获取。在 JavaScript 中, arguments 实际上它是当前函数的一个内置对象。所有函数都内置一个 arguments 对象,arguments 对象中存储了传递的所有实参。
arguments 展示形式是一个伪数组,因此可以进行遍历。伪数组具有以下特点:
- 具有 length 属性
- 按索引方式存储数据
- 不具有数组的 push ,pop 等方法
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// arguments 的使用 只有函数才有 arguments 对象 而且是每个函数都内置好了这个 arguments
function fn() {
console.log(arguments); // 里面存储了所有的传递过来的实参 arguments = [1,2,3]
// 结果为:Arguments(3) [1, 2, 3, callee: ƒ, Symbol(Symbol.iterator): ƒ]
console.log(arguments.length);
// 结果为:3
console.log(arguments[2]); // 索引
// 结果为:3
// 我们可以按照数组的方式遍历 arguments
for(var i = 0; i < arguments.length; i++){
console.log(arguments[i]);
// 结果为:1 2 3
}
}
fn(1,2,3);
// 伪数组并不是真正意义上的数组
// 1. 具有数组的 length 属性
// 2. 按照索引的方式进行存储的
// 3. 它没有真正数组的一些方法 pop() push() 等等
</script>
</body>
</html>
案例:利用函数求任意个数的最大值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 利用函数求任意个数的最大值
function getMax() { // arguments = [1,2,3]
var max = arguments[0];
for(var i = 1; i < arguments.length; i++) {
if(arguments[i] > max) {
max = arguments[i];
}
}
return max;
}
console.log(getMax(1,2,3)); // 结果为:3
console.log(getMax(1,2,3,4,5)); // 结果为:5
console.log(getMax(11,2,34,444,5,100)); // 结果为:444
</script>
</body>
</html>
六、函数案例
案例1:利用函数封装方式,翻转任意一个数组
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 利用函数翻转任意数组 reverse 翻转
function reverse(arr){
var newArr = [];
for(var i = arr.length -1; i >= 0; i--){
newArr[newArr.length] = arr[i];
}
return newArr;
}
var arr1 = reverse([1,3,4,6,9])
console.log(arr1);
// 结果为:[9, 6, 4, 3, 1]
var arr2 = reverse(['red','pink','blue']);
console.log(arr2);
// 结果为:["blue", "pink", "red"]
</script>
</body>
</html>
案例2:利用函数封装方式,对数组排序 -- 冒泡排序
案例分析
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 利用函数冒泡排序
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 arr1 = sort([1,4,2,9]);
console.log(arr1); // 结果为:[1, 2, 4, 9]
var arr2 = sort([11,7,22,999]);
console.log(arr2); // 结果为: [7, 11, 22, 999]
</script>
</body>
</html>
案例3:判断闰年
要求:输入一个年份,判断是否是闰年(闰年:能被4整除并且不能被100整数,或者能被400整除)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 利用函数判断闰年
function isRunYear(year) {
// 如果是闰年我们返回 true 否则 返回 false
var flag = false;
if (year % 4 == 0 && year % 100 !=0 || year % 400 ==0) {
flag = true;
}
return flag;
}
console.log(isRunYear(2000)); // 结果为:true 是闰年
console.log(isRunYear(1999)); // 结果为:false 不是闰年
</script>
</body>
</html>
案例4:函数可以调用另外一个函数
因为每个函数都是独立的代码块,用于完成特殊任务,因此经常会用到函数相互调用的情况。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 函数相互调用的
function fn1() {
console.log(11);
fn2(); // 在fn1 函数里面调用了 fn2 函数
}
fn1();
function fn2() {
console.log(22);
}
</script>
</body>
</html>
结果为:
案例5:用户输入年份,输出当前年份2月份的天数
如果是闰年,则2月份是29天,如果是平年,则2月份是28天
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 用户输入年份,输出当前年2月份的天数
function backDay() {
var year = prompt('请您输入年份:');
if(isRunYear(year)) { // 调用函数需要加小括号
alert('当前年份是闰年2月份有29天');
} else {
alert('当前年份是平年2月份有28天');
}
}
backDay();
// 判断是否为闰年的函数
function isRunYear(year) {
// 如果是闰年我们返回 true 否则 返回 false
var flag = false;
if (year % 4 == 0 && year % 100 !=0 || year % 400 ==0) {
flag = true;
}
return flag;
}
</script>
</body>
</html>
七、函数的两种声明方式
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 函数的2种声明方式
// 1. 利用函数关键字自定义函数(命名函数)
function fn() {
}
fn();
// 2. 函数表达式(匿名函数)
// var 变量名 = function() {};
var fun = function(aru) {
console.log('我是函数表达式'); // 结果为:我是函数表达式
console.log(aru); // 结果为:今天天气真好
}
fun('今天天气真好');
// (1) fun 是变量名 不是函数名
// (2) 函数表达式声明方式跟声明变量差不多,只不过变量里面存的是值,而 函数表达式里面存的是函数
// (3) 函数表达式也可以进行传递参数
</script>
</body>
</html>