JavaScript函数

函数概述

函数就是封装了一段可被重复调用执行的代码块，通过次代码块可以实现大量代码的重复使用

函数的使用

函数在使用时分为两步：声明函数和调用函数

声明并封装函数

函数的封装是把一个或多个功能通过函数的方式封装起来，对外只提供一个函数接口

function 函数名() {函数体}	

function fn() {
	consolo.log('123');
}

调用函数

函数名(); 

注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码

function fn() {
	consolo.log('123');
}
fn(); // '123'

函数可以相互调用

function fn1() {
	console.log(111);
	fn2();
	console.log('fn1');
}

function fn2() {
	console.log(222)
	console.log('fn2');
}
fn1(); // 111  222  fn2  fn1

函数的参数

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

形式参数
函数定义的时候传递的参数，默认值undefined，形参接收实参，类似于一个变量

实际参数
函数调用的时候传递的参数，实参是传递给形参的

function fn(a) {
    return (a + 1);
}
console.log(fn(1)); // 2

参数的作用
在函数内部某些值不能固定，可以通过参数在调用函数时传递不同的值进去

形参实参的匹配问题

• 实参多于形参：取形参的个数
• 形参多于实参：undefined，输出结果为null

函数的返回值 return

函数只是实现某种功能，最终的结果需要返回给函数的调用者

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

只要函数遇到return，就把后面的结果返回给函数调用者

函数名() = return后面的结果

function fn(a, b) {
    return a + b;
}
console.log(fn(1, 2)); // 3

实际开发中常用一个变量来接收函数的返回结果，使用更简单

function fn(a, b) {
    return a + b;
}
let s = fn(1, 2);
console.log(s); // 3

注意：

• return语句之后的代码不被执行(结束当前函数体内的代码)
• return只能返回一个值，如果用逗号隔开多个值，以最后一个值为准，可以使用return[]返回一个数组
• 没有return则返回undefined

arguments 的使用

arguments是当前函数的一个内置对象，所有函数都内置了一个arguments对象
arguments对象中存储了传递的所有实参；当不确定有多少个参数传递时，可以通过arguments来获取

通过arguments获取到的是一个伪数组

1. 具有数组的length属性
2. 按照索引的方法进行存储
3. 它没有真正数组的一些方法pop() push()…等

function fn() {
	console.log(arguments); // [1,2,3]
	console.log(arguments.length); // 3
	console.log(arguments[2]); // 3
	// 按照数组的方式遍历 arguments
	for (let i = 0; i < arguments.length; i++) {
		console.log(arguments[i]);
		// 1
		// 2
		// 3
	}
}
fn(1, 2, 3);

案例：利用函数的arguments对象求各数的最大值

function getMax() {
	let max = arguments[0];
	for (let i = 1; i < arguments.length; i++) {
		if (arguments[i] > max) {
			max = arguments[i];
		}
	}
	return max;
}
console.log(getMax(11,33,44,22)); // 44

函数案例

封装函数翻转任意数组

function fn(arr) {
	let newArr = [];
	for (let i = arr.length - 1; i >= 0; i--) {
		newArr[newArr.length] = arr[i];
	}
	return newArr;
}
let arr1 = fn([1,2,3,4,5]);
console.log(arr1); // [5,4,3,2,1]

函数封装冒泡排序

function fn(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
let arr1 = fn([1, 44, 55, 6, 22]);
console.log(arr1); // [1,6,22,44,55]

封装函数判断闰年

function runYear(year) {
    // 闰年返回true
    let flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
    return flag;
}
let year = runYear(2020);
console.log(year); // true

函数的两种表达方式

• 利用函数关键字自定义函数

    function 函数名() {}
    调用：函数名()
  

• 函数表达式

    let 变量名 = function () {}
    调用：变量名()