深入理解JavaScript：五种对象创建与设计模式（上）

命名空间模式

在大型JavaScript项目中，全局变量的滥用往往导致命名冲突和维护困难。命名空间模式通过创建层级化的对象容器来减少直接挂载在全局作用域下的变量数量。直接逐层书写冗长的属性路径既繁琐又容易出错，因此通常配合一个辅助函数来实现自动创建的层级结构。

以下代码演示了如何定义一个安全的命名空间初始化流程，并通过 namespace 方法动态生成深层嵌套的对象：

// 安全地初始化顶级命名空间
var MYAPP = MYAPP || {};

// 核心命名空间函数
MYAPP.namespace = function (ns_string) {
    var parts = ns_string.split('.'),
        parent = MYAPP,
        i;

    // 如果名称以顶级命名空间开头，则跳过该部分
    if (parts[0] === "MYAPP") {
        parts = parts.slice(1);
    }

    for (i = 0; i < parts.length; i += 1) {
        // 如果该层级不存在则创建新对象
        if (typeof parent[parts[i]] === "undefined") {
            parent[parts[i]] = {};
        }
        // 向下移动父级引用
        parent = parent[parts[i]];
    }
    return parent;
};

调用此方法后，可以极大地简化对象的定义过程：

// 一次性创建深层结构并赋值给局部变量
var module2 = MYAPP.namespace('MYAPP.modules.module2');
console.log(module2 === MYAPP.modules.module2); // true

// 支持非常长的命名路径
MYAPP.namespace('once.upon.a.time.there.was.this.long.nested.property');

定义依赖模式

当一个函数或模块需要引用其他外部资源（如第三方库或工具函数）时，明确列出这些依赖是良好的工程习惯。将这些引用提取为局部变量，不仅便于后续统一替换或移除依赖，还能在缩略词较长时提高代码的可读性。

示例代码如下：

var myFunction = function () {
    // 提前定义好依赖的局部变量
    var event = YAHOO.util.Event,
        dom = YAHOO.util.dom;

    // 后续代码直接使用局部变量 event 和 dom
    // ...具体逻辑...
};

私有属性和私有方法

原生JavaScript没有提供直接的语法来定义类的私有成员，但我们可以利用闭包特性来实现这一目标。在构造函数内部定义的变量和方法，无法通过实例直接访问，从而形成了真正的私有属性。

下面展示了如何通过构造函数建立私有变量 name，并通过公有方法对外提供服务：

function Gadget() {
    // name 是私有变量
    var name = 'iPod';
    
    // getName 是公有方法
    this.getName = function () {
        return name;
    };
}

var toy = new Gadget();
console.log(toy.name);       // undefined，外部无法直接访问私有属性
console.log(toy.getName());  // "iPod"，通过公有方法正常获取

此外，也可以利用立即执行函数（IIFE）结合全局引用来暴露对象的部分功能：

(function () {
    var name = "my, oh my"; // 自由对象中的私有变量

    // 实现公有部分（注意此处没有 var，使其成为全局/外层引用）
    myobj = {
        getName: function () {
            return name; // 通过闭包捕获私有变量
        }
    };
})();

揭示模式（Revelation Pattern）

揭示模式是对模块模式的一种变体，主要用于处理复杂的逻辑隐藏。它不像传统的返回对象方式那样在函数末尾统一return，而是先在外部声明变量，然后在内部赋值公有方法。这种方式可以让开发者先详细定义所有内部细节（包括私有辅助函数），最后再决定哪些方法对外可见。

以下是一个模拟数组操作的揭示模式示例，其中 isArray 和 indexOf 均为公有，而中间的计算逻辑对调用者完全透明：

var myarray;

(function () {
    var astr = "[object Array]",
        toString = Object.prototype.toString;

    function isArray(a) {
        return toString.call(a) === astr;
    }

    function indexOf(haystack, needle) {
        var i = 0,
            max = haystack.length;
        for (; i < max; i += 1) {
            if (haystack[i] === needle) {
                return i;
            }
        }
        return -1;
    }

    // 在这里将具体的内部实现映射到公开的API
    myarray = {
        isArray: isArray,
        indexOf: indexOf,
        inArray: indexOf // inArray 作为 indexOf 的别名
    };
}());

// 测试使用
console.log(myarray.isArray([1, 2]));          // true
console.log(myarray.indexOf(["a", "b", "z"], "z")); // 2

值得注意的是，这种模式下如果对引用的某个公开方法重新赋值（例如 myarray.indexOf = null;），并不会影响依然指向原函数的别名的调用行为。

链模式（Chain Pattern）

链模式允许在一个对象上连续调用多个方法，使代码看起来像一条连贯的语句。实现该模式的核心思想非常简单：确保每个修改对象状态的方法都返回 this 关键字（即当前对象本身）。

通过链式调用，可以将原本分散的多行逻辑浓缩为一行：

var obj = {
    value: 1,
    increment: function () {
        this.value += 1;
        return this; // 返回自身以支持链式调用
    },
    add: function (v) {
        this.value += v;
        return this; // 返回自身以支持链式调用
    },
    shout: function () {
        console.log(this.value);
    }
};

// 链式调用写法
obj.increment().add(3).shout(); // 控制台输出 5

当然，如果不需要紧凑的代码风格，仍然可以按照常规步骤单独依次调用各个方法。

以上就是深入理解JavaScript对象创建模式的详细内容，更多关于JavaScript高级应用技巧的资料请关注本站其它相关文章！