函数function

     函数：

    1、函数三要素：函数名、参数、返回值；

    2、函数：为了反复调用，而使用function命名的代码区块；

    3、函数的声明方式：

        1、声明式函数：function test(a,b(参数)){
                            函数功能的实现
                            return a + b ;
                    }
                    console.log(test(a,b))


        2、函数表达式：(变量赋值）

                     var test = function (){
                        console.log(a)
                    };

        ！！！声明式结束时不用加分号，表达式结束时要加分号；

        3、（不常使用）构造函数：

                var add = new Function ("a","b","return a + b")(参数，参数，实现）；
                    console.log(add (a,b));

        4、匿名函数：！function () {
                        console.log("1,2,3");
                        }();

                    (function() {
                        console.log("1,2,3");
                        }());

        5、函数的重复声明：若采用function多次声明同一个函数，则后面的声明会覆盖前面的声明；
                function f(){
                    console.log(1);
                }
                    f(); // 2 
                function f(){
                    console.log(2);
                }
                    f(); // 2

    4、形式参数：function fn(x,y){
                return x+y;
                }
                fn(1,2)//3    

    5、立即调用：当在定义函数后，立即调用函数时，不能在函数的定义之后加上圆括号，
                否则会被认为是函数定义语句，而不是表达式。
                    ！function （） {
                    }
                    ();
                    (function(){
                    }
                    ());    
                    (function(){
                    }
                    )();    

    6、第一等公民：函数与其他数据类型处于相同的地位。

    7、函数名的提升：
                 
                 1、JS引擎将函数名视为变量名，所以采用function声明函数时，
                   整个函数会被提升到代码头部。
                    var sum = add(1,2);
                    console.log(sum);

                    function add (x,y){
                        return x + y;
                    }

                   2、同时采用function命令和赋值语句声明同一个函数，最后总是采用
                    赋值语句的定义。
                    var fn = fuction(){
                        console.log("1");
                    };
                    function fn(){
                        console.log("2");
                    }
                        fn(); // 1

        ！！预解析：先找var和声明式函数，然后再正常解析

    8、函数的属性和方法：

            1、name属性：返回紧跟在function关键字之后的那个函数名。
                        function fn1(){}
                        console.log(fn1.name);

            2、length属性：返回函数定义中参数的个数。
                        function fn(x,y){}
                        console.log(fn.length);
                    
    9、函数作用域：

            1、定义：是指变量存在的范围；


            2、 全局作用域：变量在整个程序中一直存在；
               函数（局部）作用域；变量只在函数内部存在。

               ！！1、在函数外部声明的变量就是全局变量，课在函数内部读取；
                   2、在函数内部定义的 变量，外部无法读取；
                   3、内部定义的变量，会在内部作用域中覆盖同名全局变量。

            3、函数作用域内部也会产生“变量提升”现象。var声明的变量不管在什么位置，
                变量声明都会被提到函数体的头部。

            4、函数本身也是一个值，有自己的作用域，其作用域绑定其声明时所在的
                作用域。

                var a = 1 ;
                var fn = function(){
                    console.log(a)；
                    }；

                function fn1(){
                    var a = 2;
                    fn();
                    }
                fn1(); // 1

    10、参数

        1、定义：    函数运行时，有时需要提供外部数据，根据不同的外部数据，会得到不一样的结果，
            这种外部数据就叫参数。

            function fn (x){
                return x + x ;
            }
            fn(1);//2
            fn(2);//4

        2、传递方式：    
                1、传值传递：是函数参数本身的传递方式，意味着在函数体内修改参数值，
                            不会影响到函数外部。

                    //原始数据类型：
                            var a = 1;
                            function fn(a){
                                    a=3;
                                }
                            fn(a);
                            console.log(a);//1

                    //引用类型：
                            var arr = [1,2,3];
                            function fn1(arr){
                                arr = [4,5,6];
                            }
                            fn1(arr);
                            console.log(arr);//[1,2,3]

                2、传址传递：针对复合型变量来说，其属性是通过地址读取的，
                            在函数体内修改复合类型变量的属性值，会影响到函数外部。

                    //修改对象的属性值：
                        var obj = {
                            attr:1
                            };
                        function fn(obj){
                            obj.attr = 2;
                        }
                        console.log(obj.attr);

                    //修改数组的元素值：
                        var arr = [1,2,3];
                        function fn (arr){
                            arr[0] = 4;
                            arr[1] = 5;
                            arr[2] = 6;
                        }
                        fn(arr);
                        console.log(arr.toString());
        
        3、arguments对象：
            
            1、由来：由于js允许函数有不定数目的参数，所以我们需要有一种机制，
                    可以在函数内部读取所有参数。

            2、arguments对象包含了函数运行时的所有参数，这对象只有在
                函数内部，才可以使用。

            3、用过arguments对象的length属性，可以判断函数调用时带了几个参数。        

转载于:https://www.cnblogs.com/qingshixiaodao/p/5429135.html