函数的概念

封装一段可以被重复调用执行的代码块来实现大量代码的重复使用

2、函数的使用分为两步:声明函数和调用函数

3、声明函数的关键字全部是小写

4、函数名一般是动词、函数不调用自己不执行

函数封装

函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。

用函数把重复的代码块包裹起来就是函数封装。
封装的作用：

其实就是为了减少代码的冗余，增加代码的可读性与易维护性，

将实现同一功能的代码封装起来，在需要实现这一功能时调用即可。

形参和实参

在声明函数的括号里面是形参

形参是接受实参的

在调用函数的括号里面是实参

函数的参数可以有,也可以没有不限制个数
参数的作用:在函数内部的某些值不固定的时候,我们可以通过参数在调用的时候传递不同的值进去

注意:

多个参数之间逗号隔开

形参可以看做是不用声明的变量

如果实参的个数多余形参,会取到形参的个数

如果实参的个数小于形参,多出来的形参定义为undefined

函数的返回值

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

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

遇到return会终止函数

return 只能返回一个值,如果有多个值就只返回最后一个值

函数如果没有return,则返回undefined

break,continue,return区别

break:结束当前循环体(for,while)

continue：跳出本次循环,继续执行下次循环(for,while)

return: 不仅可以退出循环,还能够返回return语句的值,同时还可以结束当前的函数体内的代码

arguments使用

当我们不确定有多少个参数传递的时候,可以用arguments来获取,arguments存储了传递的使用实参

只有函数才有arguments

伪数组具有

数组的length属性

按照索引的方式进行存储

他没有真正数组的方法

函数的两种声明方式

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

function 函数名(){}

函数表达式(匿名函数)

var 变量名=function(){}

变量名()

变量名不是函数名

函数表达式调用的时候也可以传递参数

```
function sum(num1, num2) {
    var num = 0;
    for (var i = num1; i <= num2; i++) {
        num += i;
    }
    console.log(num);
}
sum(1, 100)

// 声明函数
function hello() {
    // 函数体
    console.log("hello word");

}
// 函数调用
// 函数名()
hello()


// 1~100之间的累加和
function getSum() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
        sum += i
    }
    console.log(sum);
}
getSum()

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


// 求任意两个数的和
function getsum(num1, num2) {
    console.log(num1 + num2);
}
getsum(1, 6)
// 求任意两个数之间的和
function getsums(start, end) {
    var sum = 0;
    for (var i = start; i <= end; i++) {
        sum += i
    }
    console.log(sum);
}
getsums(2, 5)


//  形参和实参不匹配的问题
function getmax(num1, num2) {
    console.log(num1 + num2);
}
getmax(2, 4)
getmax(2, 4, 5)
getmax(2)


// return
// function 函数名() {
//     return 需要返回的结果
// }
// 函数名()
function getResult() {
    return 222
}
console.log(getResult());

// 完善任意两个数的和
function getnum(num1, num2) {
    return num1 + num2
}
console.log(getnum(3, 4));

// 求任意两个数的最大值
function getMax(num1, num2) {
    // 方法一
    if (num1 > num2) {
        return num1
    } else {
        return num2
    }
    // 方法二
    return num1 > num2 ? num1 : num2
}
console.log(getMax(8, 6));


// 求数组中的最大值
// var newArr = [666, 4, 65, 11, 36, 89, 2]
function getArr(arr) {

    var max = arr[0]
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i]
        }
    }
    return max
}
console.log(getArr([666, 4, 65, 11, 36, 89, 2]));
// 方法二
var re = getArr([666, 4, 65, 11, 33336, 89, 2])
console.log(re);


// 任意两个数的加减乘除
function getResult(num1, num2) {
    return [num1 + num2, num1 - num2, num1 * num2, num1 / num2]
}
var look = getResult(1, 3)
console.log(look);

举例：

// 用户任意输入两个数(简单的计算器小功能),并且推出结果
function getCalculator() {
    var num1 = Number(prompt("请输入第一个数字"))
    var num2 = Number(prompt("请输入第二个数字"))
    var choice = (prompt("请输入运算符号"))
    if (choice == "+") {
        return num1 + num2
    } else if (choice == "-") {
        return num1 - num2
    } else if (choice == "*") {
        return num1 * num2
    } else if (choice == "/") {
        return num1 / num2
    }
}
alert(getCalculator());

// 任意输入三个数字，弹出最大值
function getMax() {
    var num1 = Number(prompt("请输入第一个数字"))
    var num2 = Number(prompt("请输入第二个数字"))
    var num3 = Number(prompt("请输入第三个数字"))
    var newArr = [num1, num2, num3]
    var list = []
    newArr.sort(function (a, b) {
        return b - a
    })
    var list = newArr[0]
    alert(list);
}
getMax()


function fn() {
    console.log(arguments);

}
fn(1, 2, 3, 4)

// 封装一个函数任意翻转数组
function reverse(arr) {
    var newArr = []
    for (var i = arr.length - 1; i >= 0; i--) {
        newArr[newArr.length] = arr[i]
    }
    return newArr
}
var arr1 = reverse([2, 355, 664, 34, 67, 22])
console.log(arr1);


// 利用函数冒泡排序
function arrSort() {
    var arr = [5, 66, 99, 4, 11, 5]
    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
}
console.log(arrSort());


// 函数互相调用
function fun1() {
    console.log("888");
}

function fun2() {
    fun1()
}
fun2()


// 判断是否是闰年
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(2012));

// 判断用户输入的年份输出二月份天数
function backDay() {
    var year = prompt("请输入年份")
    if (isRunYear(year)) {
        alert("当前是闰年,二月份有29天")
    } else {
        alert("当前不是闰年,二月份有28天")
    }
}
backDay()
```

举例：删除dom对象的空白节点：

function removeNode(nodee) {
		for (var i = 0; i < nodee.length; i ++) {
			if (nodee[i].nodeType === 3 && /^\s+$/.test(nodee[i].nodeValue)) {
				nodee[i].parentNode.removeChild(nodee[i]);
			} 
		}
		return nodee;
	}

阻止默认行为：

function stopcancelable(evt){
	var e=evt||window.event;
	if(e.preventDefault()){
		e.preventDefault();
	}else{
		cancelable=true
	}
}

随机数

function random(min,max){
		return parseInt(Math.random()*(max-min))+min;
	}

函数的封装