JavaScript学习笔记（四、函数）
函数
一、什么是函数？
把一段相对独立的具有特定功能的代码封装起来，形成一个独立的实体，就是函数，在后续开发中可以反复调用。
函数的作用就是封装一段代码，将来可以重复使用。
二、函数的定义：
1、函数声明（命名函数）
//函数名需遵循驼峰命名法
function 函数名(){
//函数体
}2、函数表达式（匿名函数）
a、匿名函数：没有名字的函数。
b、匿名函数如何使用：匿名函数不能通过直接调用来执行，可以通过以下2种方法调用：
1.将匿名函数赋值给一个变量，这样可以通过变量进行调用
var f1 = function(){
//函数体
}; //这里必须加分号
2.匿名函数自调用（自调用的作用：防止全局变量污染）
(function(){
//函数体
})(); *函数声明的时侯，函数体并不会执行，只有当函数被调用的时候才会执行。
三、函数的调用
1、函数调用的语法
//命名函数调用
函数名();
// 例子：求1-100之间所有数的和
function getSum() {
var sum = 0
for (var i = 1; i <= 100; i++) {
sum += i;
}
console.log(sum);
}
getSum();
//匿名函数调用
var f1 = function(){
//函数体
};
f1();四、函数的参数
1、为什么要有参数？
上面求和的例子虽然可以重复调用，但是只能计算1-100之间所有数的和。
如果想计算n-m之间所有数的和，应该怎么办呢？
2、语法
//函数内部是一个封闭的环境，可以通过参数的方式把外部的值传递给函数内部。
//带参数的函数声明
function 函数名(形参1,形参2,形参3....){
//函数体
}
//带参数的函数调用
函数名(实参1,实参2,实参3....);形参：在声明一个函数的时候，为了函数的功能更加灵活，有些值是固定不了的，对于这些固定不了的值我们可以给函数设置参数。这个参数没有具体的值，仅仅起到一个占位作用，我们通常称之为形式参数，也叫形参。
实参：如果函数在声明时，设置了形参，那么在函数调用的时候就需要传入对应的参数，我们把传入的参数称为实际参数，也叫实参。
五、函数的返回值
当函数执行完的时候，并不是所有时候都要把结果打印。我们期望函数给我一些反馈（比如计算的结果返回进行后续的运算），这个时候可以让函数返回一些东西。也就是返回值。函数通过return返回一个返回值。
1、返回值语法：
//声明一个带返回值的函数
function 函数名(形参1,形参2,形参3...){
//函数体
return 返回值;
}
//可以通过变量来接收这个返回值
var 变量 = 函数名(实参1,实参2,实参3....);函数调用的结果就是返回值，因此我们可以直接对函数调用结果进行操作。
2、返回值详解：
a、如果函数没有显示的使用return语句，那么函数有默认的返回值：undefined
b、如果函数使用return语句，那么return后面的值，就是函数的返回值
c、如果函数使用return语句，但是return后面没有任何值，那么返回值也是：undefined
d、函数使用return语句后，这个函数在执行完return语句之后停止并立即退出，也就是说return语句后面的其他代码都不会执行
*推荐的做法是要么让函数始终都返回一个值，要么永远不要返回值。
案例:
//1、求1-n之间所有数的和
function getSum(n) {
var sum = 0;
for (var i = 1; i <= n; i++) {
sum += i;
}
return sum;
}
console.log(getSum(10));
//2、求n-m之间所有数的和
function getEverySum(n, m) {
var sum = 0;
for (var i = n; i <= m; i++) {
sum += i;
}
return sum;
}
console.log(getEverySum(5, 23));
//3、已知半径求圆的面积
function getArea(r) {
return Math.PI * r * r;
}
console.log("半径为5cm的圆的面积为" + getArea(5) + "平方厘米");
//4、求2个数中的最大值
function getMax(n, m) {
return n > m ? n : m;
}
console.log(getMax(5, 89));
//5、求3个数中的最大值
function getThreeMax(a, b, c) {
return a > b ? (a > c ? a : c) : (b > c ? b : c);
}
console.log(getThreeMax(3, 10, 7));
//6、判断一个数是否是素数（质数：大于1的自然数中，除了1和它本身以外不再有其他因数）
function getZhiShu(n) {
if (n > 1) {
for(var i=2;i<n/2+1;i++){
if(n%i==0){
return "不是一个质数";
}else {
return "是一个质数";
}
}
}
return "不是质数";
}
console.log(getZhiShu(1));
//7、求阶乘
function getJieCheng(n) {
var result = 1;
for (var i = 1; i <= n; i++) {
result *= i;
}
return result;
}
console.log(getJieCheng(5));
//8、求1!+2!+3!+....+n!
//注意变量声明的位置特别重要
function getSumJieCheng(n) {
var sum = 0;
for (var i = 1; i <= n; i++) {
var result = 1;
for (var j = 1; j <= i; j++) {
result *= j;
}
sum += result;
}
return sum;
}
console.log(getSumJieCheng(5));
//9、求一组数中的最大值
function getArrayMax(arr) {
var max = arr[0];
for (var i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
var arr1 = [10, 22, 45, 78, 22, 31, 1, 34, 5, 90, 33, 1];
console.log(getArrayMax(arr1));六、伪数组arguments的使用
JavaScript中，arguments对象是比较特别的一个对象，实际上是当前函数的一个内置属性。也就是说所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。arguments是一个伪数组，因此可以进行遍历。
案例：
//1、求任意个数的最大值
function getMax() {
var max = arguments[0];
for (var i = 0; i < arguments.length; i++) {
if (max < arguments[i]) {
max = arguments[i];
}
}
return max;
}
console.log(getMax(10, 29, 22, 21, 89));
//2、求斐波那契数列Fibonacci中的第n个数是多少？ 1 1 2 3 5 8 13 21 34 55...
function getFibonacci(n) {
var num1 = 1;
var num2 = 1;
var num3 = 0;
var temp;
if (n <= 2) {
return 1;
} else {
for (var i = 2; i < n; i++) {
num3 = num1 + num2;
num1 = num2;
num2 = num3;
}
return num3;
}
}
console.log(getFibonacci(10));
//3、翻转数组，返回一个新数组
function getReversalArray(arr) {
var temp;
for (var i = 0; i < arr.length / 2; i++) {
temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
return arr;
}
console.log(getReversalArray([1, 2, 3, 4, 5, 6, 7, 8, 9]));
//4、对数组排序，从小到大
function getSortArray(arr) {
var temp;
for (var i = 0; i < arr.length - 1; i++) {
for (var j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
console.log(getSortArray([11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]));
//5、输入某年某月某日，判断这一天是这一年的第几天？
function getDays(data) {
var year = parseInt(data[0] + data[1] + data[2] + data[3]);
var month = parseInt(data[5] + data[6]);
var day = parseInt(data[8] + data[9]);
var arr = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];//存放每个月的天数
var days = 0;
//判断是否是闰年
if (year % 4 == 0 && year % 100 != 0 && year % 400 == 0) {
arr[1] = 29;//闰年2月29天
}
for (var i = 0; i < month - 1; i++) {
days += arr[i];
}
return days + day;
}
console.log("第"+getDays(prompt("请按2018/01/01的格式输入年月日"))+"天");七、函数是一种数据类型
function fn(){}
cosole.log(typeof fn);//function1、函数作为参数：因为函数也是一种数据类型，可以把函数作为另一个函数的参数，在另一个函数中调用。
2、函数作为返回值：因为函数也是一种数据类型，所有可以把函数作为返回值从函数内部返回。
function fn(b) {
var a = 10;
return function () {
alert(a + b);
}
}
fn(15)(); //弹出25八、作用域：变量可以起作用的范围
1、全局变量和局部变量
a、全局变量：在任何地方都可以访问到的变量就是全局变量，对应全局作用域
隐式全局变量：不使用var声明的变量，不推荐使用。
b、局部变量：只在固定代码片段内可访问到的变量，最常见的如函数内部。对应局部作用域（函数作用域）
局部变量退出作用域后销毁，全局变量关闭网页或浏览器后才会销毁。
2、块级作用域
任何一对花括号（｛和｝）的语句集都属于一个块，在这之中定义的所有变量在代码块之外都是不可见的，我们称之为块级作用域。
在ES5之前没有块级作用域的概念，只有函数作用域。
3、词法作用域
变量的作用域是在定义时决定的而不是执行是决定的，也就是说词法作用域取决于源码，通过静态分析就能确定，因此词法作用域也叫做静态作用域。
在JavaScript中词法作用域的规则：
a、函数允许访问函数外部的数据。
b、整个代码结构中只有函数可以限定作用域。
c、作用域规则首先使用提升规则分析。
d、如果当前作用规则中有名字了，就不考虑外面的名字了
var num = 123;
function foo() {
console.log( num );
}
foo();
if ( false ) {
var num = 123;
}
console.log( num ); // undefiend 4、作用域链
只有函数可以制造作用域结构，那么只要是代码，就至少有一个作用域，即全局作用域。凡是代码中有函数，那么这个函数就构成另外一个作用域。如果函数中还有函数，那么在这个作用域中又可以诞生一个作用域。将这样的所有的作用域列出来，可以有一个结构：函数内指向函数外的链式结构，就称作作用域链。
function f1() {
function f2() {
}
}
var num = 456;
function f3() {
function f4() {
}
}
九、预解析
JavaScript代码的执行是由浏览器中的JavaScript解析器来执行的。JavaScript解析器执行JavaScript代码的时候，分两个过程：预解析过程和代码执行过程。
预解析过程：
1、把变量声明提升到当前作用域的最前面，只提升声明，不会提升赋值。
2、把函数声明提升到当前作用域的最前面，只提升声明，不会提升调用。
3、先提升var，再提升function，如果变量和函数同名的话，函数优先。
var a = 25;
function abc (){
alert(a);//undefined
var a = 10;
}
abc();
// 如果变量和函数同名的话，函数优先
console.log(a);//函数代码
var a = 1;
function a() {
console.log('aaaaa');
}
console.log(a); //1 变量提升：定义变量的时候，变量声明会被提升到作用域的最上面，变量赋值不会提升。
函数提升：JavaScript解析器首先会把当前作用域的函数声明提前到整个作用域的最前面。
// 1、-----------------------------------
var num = 10;
fun();
function fun() {
console.log(num);
var num = 20;
}
//2、-----------------------------------
var a = 18;
f1();
function f1() {
var b = 9;
console.log(a);
console.log(b);
var a = '123';
}
// 3、-----------------------------------
f1();
console.log(c);
console.log(b);
console.log(a);
function f1() {
var a = b = c = 9;
console.log(a);
console.log(b);
console.log(c);
}