函数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属性,可以判断函数调用时带了几个参数。        

posted @ 2016-04-25 02:09  白教主  阅读(434)  评论(0编辑  收藏  举报