函数

引入（认识函数）

说起函数，其实我们并不陌生，在初中数学中我们就接触过函数；例如我们所学的 y = 2X+1 ; 这是一个二元一次方程，也是我们数字中的函数；
当我们每次输入一个X的值时，经过这个函数的运算，就会输出一个对应的y;
从这里我们可以看出：函数能够揭示一些规律，后续凡是具备相同的规律，可以用一种方法来解决 那么js中的函数是什么呢？

什么是函数

函数：可以无限次完成特定功能代码块；

函数的作用

1.代码重用
2.用于组织代码

函数声明的方法：

1.函数声明式
2.函数表达式

函数声明式

语法格式:
function 函数名(可选参数1，可选参数2，可选参数3){
     //函数体：功能代码
}

应用：
//使用函数：实现：求1~100之间的的和
        function sum(){//函数名
            var a = 0;//保存和
            for(var i =1; i<=100;i++){
                a += i;
            }
            console.log(a)
        }
        sum();//自定义函数直接调用：函数名()；


说明：
1.function ：定义函数的关键字
2.函数名：自定义的一个名字（需要符合标识符的命名规范）
3.函数名称后面是小括号，必不可少，用来装载形式参数的        
4.{ }就是函数体：要完成某个功能的代码块，它可以完成某个特定的功能

函数表达式

语法格式：
var 变量名 = function(){
    //函数体
}
变量名：函数名

应用：
var sum1 = function(){
    var a = 0;
    for(var i = 2; i<=100;i++){
        a += i;
    }
    console.log(a);
}
sum1()

说明：
1）将function整体，放在赋值运算符的左边，作为表达式来使用。
2）通过一个变量来引用当前的function，便于后续的调用。
3）函数名称可以加上，但是只对函数内部起作用，

两种定义方式的区别

1.函数表达式在定义前面调用
//var fn //生明提升，将var fn 变量提升到作用域顶部
console.log(fn)//声明为负值所以fn的值为undefined

fn();//在定义函数前面调用报错
//注意：因此此时的fn未变量，所以不能用函数的方式调用，报错
var fn = function(){//执行倒这一步，给fn赋值，赋给一个函数
    alert('表达式');
}

2．函数表达式在定义后面调用；
var fn = function(){
    alert('表达式');
}
fn();//因此上一部已经给fn赋值一个函数，所以可以在定义的下面调用函数


3，函数声明式：
函数被声明提升到作用域的顶部:因此可以在任何地方调用
funciton fun(){
    console.log('生命式')
}
fun();

总结：
1.函数声明式：声明被提升，即用函数声明式定义的函数，可以在定义前调用，也可以在定义后调用
2.函数表达式：其实就是一个变量，只不过我们赋值时，讲函数这种数据类型赋给了它，因此它遵循变量的规则，先声明后使用；即，用函数表达式，定义的函数，必须在定义之后调用

函数的数据类型；

function fun(){
console.log('声明式');
}
fun();
console.log(typeof(fun))//funciton类型

注意：
1.函数声明式定义的函数；在定义前后都可以调用
2.函数表达式定义的函数，必须在定义的后面调用，否则会报错
3.函数的数据类型为function；

函数的参数

函数的本质：

1.函数的作用，代码重用，编写一个函数，就是为了解决一类问题。 2函数每次调用，都有一个结果，那么结果和什么相关呢？和我们给定的某一个值相关的。

这就涉及到参数的问题：

举个例子：
//榨汁机是一台机器，提供榨汁的功能。
//榨汁的过程: //首先得放点东西:苹果+水。橘子+水，香蕉+水，葡萄+水
//开始启动开关
//得到的水果的碎片+水的混合体

> //模拟这个过程
//此处的水果就是一个形式参数，不代表具体的某种水果，代表了某种类型的值
function shui(水果){
    //搅拌
    return '这个水果对应的碎片 + 水的 混合体'
}
//调用
//此处的苹果和葡萄是实际参数，具体在调用的时候，传入的值
shui('葡萄'); //得到葡萄汁
shui('苹果'); //得到苹果汁

注意：函数中的参数分为

形参：函数定义时小括号中的参数称为形参表示要传入什么样的值
实参：函数调用时输入的参数称为实参，具体的某个值

案例，我们需要定义一个函数，对两个数进行求和。

function sum(a,b){//形式参数
    //var s = a + b;
    return s;
    return a + b;
}
//调用一会函数
var s = sum(1,4);//实际参数
console.log(s);
正是由于有了参数这么一个武器，所以我们的函数才得以重用。
'注意：多个参数由逗号 (,) 分隔'

说明：
	1.在定义和调用函数的时候，对形式参数和实参要求没有那么严格。
	2.形参和实参的个数，可以不相等，程序不会出错，结果可能会出问题。
    function fun (x,y,z){//x = 2;y =3; z = undefined
        console.log(x);//2
        console.log(y);//3
        console.log(z);//undefined
    }
    fun(2,3)//调用函数时，参数，实际上是将实参赋给形参的一个过程

注意：
那么以上只可以获取到2和3，如果我们的实际参数的数量很多个呢？

 function fun (x,y,z){//x = 2;y =3; z = 9
        console.log(x);//2
        console.log(y);//3
        console.log(z);//9
    }
    fun(2,3,9,6,7,8,2)
	
	思考:想要获取实参6,7,2怎么办?
注意：这个时候就可以用到我们函数独特的一个功能了"arguments"

arguments

什么是arguments?

arguments是实参的一个集合；
	function fn(x,y,z){
        console.log(arguments);//将所有的实参都放在一个类数组中
        //返回值:[2,3,9,6,7,8,2]
    }
	fun(2,3,9,6,7,8,2)


**说明：**
1.arguments队形是用来接受实参的，每一个函数都有arguments对象，arguemnts只会在内部找自身的arguments,无法引用到外层的arguments
演示：
function fn(x,y,z){
     console.log(arguments);//[2,3,9,6,7,8,2]
}
fun(2,3,9,6,7,8,2)
console.log(arguments);//arguments is not defined

2.我们将实参收集起来,放到一个arguments对象里，组成一个由实参构成的类数组，[实参1，实参2，实参3…..实参n]

3.我们可以通过arguments的索引(0,1,2,3…)，来访问每一个实参,
语法：
arguments[下标]
演示：
    function fn(x,y,z){
        console.log(arguments);
        console.log(arguments[0]);;//2
        console.log(arguments[1]);//3
        console.log(arguments[2]);//9
        console.log(arguments[3]);//6
        console.log(arguments)[4];//7
        console.log(arguments)[5];//8
        console.log(arguments)[6];//2
    }
	fun(2,3,9,6,7,8,2)

5.arguments.length:可以得到实参是个数
演示：
     function fn(x,y,z){
            console.log(arguments.length);
            //arguments. length;计算的是实参的总个数，由调用时传入的参数决定
        }
        fun(2,3,9,)
细节：
5.1：arguments[0]可以取到传入的第一个实参
5.2:arguments[arguments.length-1] 可以取到传入参数的最后一个实参
	演示：
	 function fn(x,y,z){
        	console.log(arguments.length);
        console.log(arguments.length)[0]//第一个参数
            console.log(arguments.length-1);//最后一个参数
        //因为下标从0开始，所以最大下标为arguments. length-1
        }
        fun(2,3,9,)
5.3:arguments的长度是由传入的实参个数决定的，而不是由定义函数时的命名参数的个数决定的
5.4:传参的时候arguments.length 为0时是个空集合：[]
	演示：
    function fn(x,y,z){
        console.log(arguments);//[]
        	console.log(arguments.length);0
     }
     fun()
5.5:获取每一个实参：
	演示：
	function fn(){//arguments是一个收集实参的类数组
       	for(var i = 0;i < arguments.length;i++){//遍历类数组的下标i；下标
            console.log(arguments[i])//arguments[i]:表示每一个实参
        }
     }
        fun(5，8，true,'word',null)

函数的返回值

实际上，在js开发中，我们调用一个函数，往往是需要通过它的处理，得到一个具体的结果。 函数中的return语句是指定函数调用的返回值

说明：return只能在函数体中出现，如果不是的话会报语法错误
在使用ruturn语句时，函数就会停止执行，并返回指定的值，后面的语句不会被执行。
	演示：
    function f1(){
            //相关的处理代码
            console.log('f1之前');//f1之前

            return 'f1';
            console.log('f1之后');//由于前面的return语句，所以后面的语句都不会执行
        }
        var c = f1();
        console.log(c);
        
细节：
1.没有使用return的时候，我们可以这么理解，在一个函数当中，最后一定会有一个return 语句，默认的是 return undefined。
	演示：
    function f1(){
            //相关的处理代码
            
        }
      var c = f1();
       console.log(c);
        // 注意：如果我们在自定义函数中，没有显式返回值，默认返回的是undefined。

2.如果有 return 就是return的值
	演示：
    function f1(){
            //相关的处理代码
            return 'f1'//f1
        }
        var c = f1();
        console.log(c);
3.如果有return ,但是没有return后没有值，则返回undefined
	演示：
    function f1(){
            //相关的处理代码
            console.log('f1之前');//f1
            return;
            console.log('f1之后');//undefined
        }
        var c = f1();
        console.log(c);

函数的作用域

什么是作用域？

首先，作用域是针对变量而言的。要定义一个变量，这个变量就有一个相应的作用域。
作用域是指变量的生效范围，在程序中，在什么范围之内可以访问，什么范围不能访问。

在js中，以变量的界，可以分为如下两种：

全局变量：不在任何函数内定义的变量就是全局变量。
局部变量：(函数内var 声明的变量)只能被函数自身读取（该变量的作用域是局部的）。

变量的规则：（变量的作用域）

1.如果一个变量在函数体内部声明，则该变量的作用域为整个函数体，在函数体外不可引用该变量：
	演示：
    var a = 5;//全局变量
        function fn(){
            var b = 'hello';//局部变量
            console.log(b);//hello
        }
        fn();
        console.log(b);//报错
        注意：局部变量，作用域为整个函数体，在函数体外不可引用函数体内部的变量
        
2.如果两个不同的函数各自申明了同一个变量，那么该变量只在各自的函数体内起作用。换句话说，不同函数内部的同名变量互相独立，互不影响： 
 	演示：
    //不同函数内部的同名变量互相独立，互不影响:
        function fn(){
            var sum = 520;//num只在当前sum函数内有效
            console.log(sum);
        }
        fn();
        function fn1(){
            var sum = 'worde';//word只在 当前fun函数内有效
            console.log(sum);
        }
        fn1();

 3.函数外部的变量就算是和函数内部的变量名称相同，也是两个变量，没有任何关系，彼此不发生影响
 	演示：
     //函数外部的变量就算是和函数内部的变量名称相同，
        // 也是两个变量，没有任何关系，彼此不发生影响
        var a = 5;//全局变量
        function fn(){
            var a = 'hello'//局部变量
            console.log(a);//'hello'函数自身的变量，在自身找
        }
        fn()
        console.log(a);//5 输出全局变量的值

        var b = true;
        function sum(){
            console.log(b);//true 函数内部可以引用全局变量，自身没有的找全局

        }
        sum();
        console.log(b);//true 输出是全局变量的值

4.函数内部的变量，没有用var时，会逐层向上查找
(如果把值赋给尚未声明的变量，是隐式声明，不会变量提升，直接为全局变量)
	演示：
    先执行函数，再输出变量
    // 1函数内郁的变量，没有用var时，会逐层向上查找
        // (如果把值赋给尚未声明的变量，是隐式声明。不会安量提升。直接为全局变量)
        function fun(){
            a = '我是没有var的变量';
        }
        fun();
        console.log(a);//'我是没有var的变量'；
       // 分析:当执行了函数fun后，就在全局里存在一个变量， 所以在函数体外可以找到。\

    没有执行函数；直接输出
    演示：
     function fun(){
            a = '我是没有var的变量';
        }
        
        console.log(a);//'我是没有var的变量'；
        //分析：没有执行函数fun.所以不存在a交量
//因此:没有用var声明的变量不能声明提升。只有执行了，和'我是没有var的变量":这一 行代码。才存在9,否则不存在a

变量的生存周期：

1.JavaScript 变量的生命期从它们被声明的时间开始。
2.局部变量会在函数运行以后被删除。
3.全局变量会在页面关闭后被删除。

  函数同名的话，后写的函数覆盖先写的函数。 	
  注意：js没有重载

小结

1. 函数的参数分为形参和实参;
2. arguments是实参的集合
3. return是函数的返回值，也是函数的结束语句
4. 在函数体内声明的变量为局部变量，不再函数内声明的变量为全局变量
5. 局部变量只能在函数体内使用，全局变量可以在任意地方使用；