JavaScript高级程序设计(第三版) 7章

Menu

• 第6章 面向对象的程序设计

  • 7.1 递归
  • 7.2 闭包
  • 7.3 模仿块级作用域
  • 7.4 私有变量
    • 7.4.1 静态私有变量
    • 7.4.2 模块模式
    • 7.4.3　增强的模块模式

---

第七章 函数表达式

• functionName.name 能访问到函数名字（函数表达式的函数得到undefined）
• 函数声明提升， 函数表达式不提升

7.1 递归

// 递归实现阶乘， 严格模式不可用
    function factorial(num){
        if (num <= 1){
            return 1;
        } else {
            return num * arguments.callee(num-1);
        }
    }

//改成命名函数表达式， 严格模式下也可用
var factorial = (function f(num){
if (num <= 1){
return 1;
} else {
return num * f(num-1);
}
});

7.2 闭包

// 通过将匿名函数复制为null， 释放占用的内存空间
//创建函数
var compareNames = createComparisonFunction("name");
//调用函数
var result = compareNames({ name: "Nicholas" }, { name: "Greg" });
//解除对匿名函数的引用（以便释放内存）
compareNames = null;

• 闭包的副作用：只能取得包含函数中任何变量的最后一个值。

//解决办法：再创建一个函数将立即执行将i的值保存
    function createFunctions2(){
        var result = new Array();
        for (var i=0; i < 10; i++){
            result[i] = function(num){
                return function(){
                    return num;
                };
            }(i);
        }
        return result;
    }

    re = createFunctions2()[5]()
    document.write(re)

7.3 模仿块级作用域

 - JavaScript 没有块级作用域的概念。这意味着在块语句中定义的变量，实际上是在包含函数中而非语句中创建的。

    function outputNumbers(count){
        for (var i=0; i < count; i++){
            document.write(i);
        }
        // var i = 7; //重新声明变量后， 变成：0123456789>7 
        document.write(">", i); //计数
    }
    outputNumbers(10) // 0123456789>10

// 解决办法：利用匿名函数， 创建私有作用域
    function outputNumbers(count){
        (function () {
            for (var i=0; i < count; i++){
                document.write(i);
            }
        })();
        document.write(i); //导致一个错误！
    }
    outputNumbers(10)// i is not defined； 在匿名函数中定义的任何变量，都会在执行结束时被销毁。

7.4 私有变量

• 私有变量包括函数的参数、局部变量和在函数内部定义的其他函数。
• 特权方法：有权访问私有变量和私有函数的公有方法

    function MyObject(){
//私有变量和私有函数
        var privateVariable = 10;
        function privateFunction(){
            return false;
        }
//特权方法
        this.publicMethod = function (){
            privateVariable++;
            return privateFunction();
        };
    }

    object = new MyObject();
    document.write(object.privateVariable); // undefined
    document.write(object.publicMethod()); // false
    //  除了使用 publicMethod()没有办法可以直接访问 privateVariable 和 privateFunction()。

- 缺点：必须使用构造函数模式来达到隐藏那些不应该被直接修改的数据的目的；而构造函数模式会针对每个实例创建同样一组新方法；解决办法是使用静态私有变量；

• 7.4.1 静态私有变量？？？？

    (function(){
//私有变量和私有函数
        var privateVariable = 10;
        function privateFunction(){
            return false;
        }
//构造函数
        MyObject = function(){
        };
//公有/特权方法
        MyObject.prototype.publicMethod = function(){
            privateVariable++;
            return privateFunction();
        };
    })();

7.4.2 模块模式

• 为单例(只有一个实例的对象)创建私有变量和特权方法;
• 惯例是以对象字面量的方式来创建单例对象的;

    var singleton = {
        name : value,
        method : function () {
//这里是方法的代码
        }
    };

• 模块模式通过为单例添加私有变量和特权方法能够使其得到增强