前端提高篇（十二）JS进阶9函数三大特性与对象的属性

函数三大特性：

• 方法特性：用大括号括起
• 对象特性：用点.获取对象属性
• 类的特性：用new创建类似对象

对象属性：

• 自有属性：arguments，name，length，prototype，call，apply，toString，bind方法
  1.使用自有属性的方法是：函数名.属性名，不是函数名().属性名，这样操作的是函数返回值，而我们是要操作函数
  2.arguments属性只能在函数体内才有值，否则都是null，因为操作的是实参，func.arguments无法获取实参；函数执行完arguments又会被置空
  3.其他自有属性都通过func.属性来获取，如func.length可以获取到函数的形参个数
• 自定义属性：
  1.在函数内部定义的属性，要函数执行之后，才生效，因为外部看不见内部的代码；只有执行，才能在函数外获取这个属性的值
  2.如果定义了函数，并在函数体外给函数增加一个属性，即使函数不执行，这个属性也能被访问，因为外部看得见
  3.如果函数体A内嵌套了函数B，只能由A去调用函数B，且A执行的前提下，调用B，B才能执行

func函数未执行时访问函数体内定义的属性

注意此处是func.x = 1(函数属性)，不是var x = 1;(局部变量）

        //自定义属性特性
        func.y = 2;
        function func(){
            func.x = 1;
        }

运行效果：

当func函数执行之后再访问x属性：

        func.y = 2;
        function func(){
            func.x = 1;
        }
        func();

运行效果：函数体内定义的x属性也能访问得到

如果是定义局部变量x，即使函数func执行过，外部也不能访问到x：

        func.y = 2;
        function func(){
            var x = 1;
        }
        func();

运行效果：

函数嵌套函数

之前我们讲嵌套函数，是这样的：

        function func(){
            function e(){
                console.log('e');
            }
            e();
        }
        func();

e是局部的，func()中执行

讲闭包是这样的：

        function func(){
            var count = 0;
            e = function (){
                console.log('e');
                count ++;
            }
            
        }
        func();
        e();

e是全局的，不由func调用

或者这样的：

        function func(){
            var count = 0;
            var e = function (){
                console.log('e');
                count ++;
            }
            return e
            
        }
        var e = func();
        e();

将e函数return出来，运行结果同上

所以如果要在外部使用这个嵌套函数，一种办法是return出来，这时e仅是对象；另一种是，用函数名.属性的方式，在外层函数执行之后使用这个嵌套函数，这时e是函数的自定义属性
将内嵌函数return出来的方法：

        function func(){
            var e = function (){
                console.log('e');
            }
            return e;
        }
        // func();
        var e = func();
        e();

运行效果：e函数在大环境被顺利调用执行

函数名.属性方法：

        function func(){
            func.e = function e(){
                console.log('e');
            }
        }
        func();

运行效果：e函数在大环境被顺利调用执行

所以，实现计数器的功能，之前用闭包实现，现在又有了一个新的方式

        function f(){
            if (f.x == undefined){
                console.log('f.x初始化');
                f.x = 0;
            }
            return f.x++
        }
        for (var i = 0; i < 10; i++){
            console.log('i:'+ i + ' x:' + f());
        }

效果：

之前用闭包是这样的：

        //版本一
        function f1(num){
            var count = 0;
            plus = function(num){
                console.log('i:'+ num + ' count:'+ count)
                count ++;
                
            }
        }
        f1();
        for ( var i = 0; i < 10; i++){
            plus(i);
        }
        
        //改进版本
        function f1(){
            var count = 0;
            plus = function(){
                return count ++;
                
            }
        }
        f1();
        for ( var i = 0; i < 10; i++){
            console.log('i:'+ i + ' count:'+plus())
        }

如果没有return count++，则plus没有返回值，不能直接console.log(plus())

在这里注意console.log的位置，在console中调用f函数，运行顺序应该是先console，再自增

之前关于函数的两篇文章，文一，文二