如何在 JavaScript 中声明命名空间？

Question

如何在 JavaScript 中创建命名空间，以便我的对象和函数不会被其他同名对象和函数覆盖？ 我使用了以下内容：

if (Foo == null || typeof(Foo) != "object") { var Foo = new Object();}

是否有更优雅或更简洁的方法来执行此操作？

Answer 1

我使用 在 Enterprise jQuery 站点上找到的方法：

这是他们的示例，展示了如何声明私有和私有。 公共属性和功能。 一切都是作为自动执行的匿名函数完成的。

(function( skillet, $, undefined ) {
    //Private Property
    var isHot = true;

    //Public Property
    skillet.ingredient = "Bacon Strips";

    //Public Method
    skillet.fry = function() {
        var oliveOil;

        addItem( "\t\n Butter \n\t" );
        addItem( oliveOil );
        console.log( "Frying " + skillet.ingredient );
    };

    //Private Method
    function addItem( item ) {
        if ( item !== undefined ) {
            console.log( "Adding " + $.trim(item) );
        }
    }
}( window.skillet = window.skillet || {}, jQuery ));

因此，如果您想访问公共成员之一，只需使用 skillet.fry() 或 skillet.ingredients 即可。

真正酷的是，您现在可以使用完全相同的语法来扩展命名空间。

//Adding new Functionality to the skillet
(function( skillet, $, undefined ) {
    //Private Property
    var amountOfGrease = "1 Cup";

    //Public Method
    skillet.toString = function() {
        console.log( skillet.quantity + " " +
                     skillet.ingredient + " & " +
                     amountOfGrease + " of Grease" );
        console.log( isHot ? "Hot" : "Cold" );
    };
}( window.skillet = window.skillet || {}, jQuery ));

第三个未定义参数

第三个未定义参数是值未定义变量的来源。 我不确定它今天是否仍然相关，但是在使用旧版浏览器/JavaScript 标准（ecmascript 5、javascript < 1.8.5 ~ firefox 4）时，全局范围变量 undefined 是可写的，所以任何人都可以重写它的值。 第三个参数（未传递值时）创建一个名为 undefined 的变量，该变量的作用域为名称空间/函数。 由于创建名称空间时未传递任何值，因此它默认为值 undefined。

Answer 2

我喜欢这个：

var yourNamespace = {

    foo: function() {
    },

    bar: function() {
    }
};

...

yourNamespace.foo();

Answer 3

另一种方法是这样的，我认为它比对象字面量形式的限制要少一些：

var ns = new function() {

    var internalFunction = function() {

    };

    this.publicFunction = function() {

    };
};

上面的内容非常像 模块模式 和 无论您是否喜欢，它都允许您将所有函数公开为公共函数，同时避免对象字面量的严格结构。

Answer 4

有更优雅或更简洁的方法吗？

是的。 例如：

var your_namespace = your_namespace || {};

那么你可以有

var your_namespace = your_namespace || {};
your_namespace.Foo = {toAlert:'test'};
your_namespace.Bar = function(arg) 
{
    alert(arg);
};
with(your_namespace)
{
   Bar(Foo.toAlert);
}

Answer 5

我通常在闭包中构建它：

var MYNS = MYNS || {};

MYNS.subns = (function() {

    function privateMethod() {
        // Do private stuff, or build internal.
        return "Message";
    }

    return {
        someProperty: 'prop value',
        publicMethod: function() {
            return privateMethod() + " stuff";
        }
    };
})();

自从写这篇文章以来，多年来我的风格发生了微妙的变化，我现在发现自己像这样编写闭包：

var MYNS = MYNS || {};

MYNS.subns = (function() {
    var internalState = "Message";

    var privateMethod = function() {
        // Do private stuff, or build internal.
        return internalState;
    };
    var publicMethod = function() {
        return privateMethod() + " stuff";
    };

    return {
        someProperty: 'prop value',
        publicMethod: publicMethod
    };
})();

通过这种方式，我发现公共 API 和实现更容易理解。 将 return 语句视为实现的公共接口。

Answer 6

因为您可能编写不同的 JavaScript 文件，然后在应用程序中组合或不组合它们，所以每个文件都需要能够恢复或构造命名空间对象，而不破坏其他文件的工作...

一个文件可能打算使用命名空间 < code>namespace.namespace1：

namespace = window.namespace || {};
namespace.namespace1 = namespace.namespace1 || {};

namespace.namespace1.doSomeThing = function(){}

另一个文件可能想要使用命名空间 namespace.namespace2：

namespace = window.namespace || {};
namespace.namespace2 = namespace.namespace2 || {};

namespace.namespace2.doSomeThing = function(){}

这两个文件可以共存或分开而不会发生冲突。

Answer 7

以下是 Stoyan Stefanov 在他的JavaScript Patterns一书中的做法，其中我发现非常好（它还展示了他如何进行允许自动生成 API 文档的注释，以及如何向自定义对象的原型添加方法）：

/**
* My JavaScript application
*
* @module myapp
*/

/** @namespace Namespace for MYAPP classes and functions. */
var MYAPP = MYAPP || {};

/**
* A maths utility
* @namespace MYAPP
* @class math_stuff
*/
MYAPP.math_stuff = {

    /**
    * Sums two numbers
    *
    * @method sum
    * @param {Number} a First number
    * @param {Number} b Second number
    * @return {Number} Sum of the inputs
    */
    sum: function (a, b) {
        return a + b;
    },

    /**
    * Multiplies two numbers
    *
    * @method multi
    * @param {Number} a First number
    * @param {Number} b Second number
    * @return {Number} The inputs multiplied
    */
    multi: function (a, b) {
        return a * b;
    }
};

/**
* Constructs Person objects
* @class Person
* @constructor
* @namespace MYAPP
* @param {String} First name
* @param {String} Last name
*/
MYAPP.Person = function (first, last) {

    /**
    * First name of the Person
    * @property first_name
    * @type String
    */
    this.first_name = first;

    /**
    * Last name of the Person
    * @property last_name
    * @type String
    */
    this.last_name = last;
};

/**
* Return Person's full name
*
* @method getName
* @return {String} First name + last name
*/
MYAPP.Person.prototype.getName = function () {
    return this.first_name + ' ' + this.last_name;
};

Answer 8

我使用这种方法：

var myNamespace = {}
myNamespace._construct = function()
{
    var staticVariable = "This is available to all functions created here"

    function MyClass()
    {
       // Depending on the class, we may build all the classes here
       this.publicMethod = function()
       {
          //Do stuff
       }
    }

    // Alternatively, we may use a prototype.
    MyClass.prototype.altPublicMethod = function()
    {
        //Do stuff
    }

    function privateStuff()
    {
    }

    function publicStuff()
    {
       // Code that may call other public and private functions
    }

    // List of things to place publically
    this.publicStuff = publicStuff
    this.MyClass = MyClass
}
myNamespace._construct()

// The following may or may not be in another file
myNamespace.subName = {}
myNamespace.subName._construct = function()
{
   // Build namespace
}
myNamespace.subName._construct()

外部代码可以是：

var myClass = new myNamespace.MyClass();
var myOtherClass = new myNamepace.subName.SomeOtherClass();
myNamespace.subName.publicOtherStuff(someParameter);

Answer 9

这是 user106826 的 Namespace.js 链接的后续内容。 该项目似乎已转移到 GitHub。 现在是 smith/namespacedotjs。

我一直在我的小项目中使用这个简单的 JavaScript 帮助器，到目前为止，它似乎很轻，但功能多样，足以处理命名空间和加载模块/类。 如果它允许我将包导入到我选择的命名空间中，而不仅仅是全局命名空间，那就太好了……叹息，但这不是重点。

它允许您声明命名空间，然后在该命名空间中定义对象/模块：

Namespace('my.awesome.package');
my.awesome.package.WildClass = {};

另一种选择是立即声明命名空间及其内容：

Namespace('my.awesome.package', {
    SuperDuperClass: {
        saveTheDay: function() {
            alert('You are welcome.');
        }
    }
});

有关更多用法示例，请查看 源代码。

Answer 10

示例：

var namespace = {};
namespace.module1 = (function(){

    var self = {};
    self.initialized = false;

    self.init = function(){
        setTimeout(self.onTimeout, 1000)
    };

    self.onTimeout = function(){
        alert('onTimeout')
        self.initialized = true;
    };

    self.init(); /* If it needs to auto-initialize, */
    /* You can also call 'namespace.module1.init();' from outside the module. */
    return self;
})()

您可以选择声明一个 local 变量，same，如 self 并根据需要分配 local.onTimeout它是私人的。

Answer 11

模块模式最初被定义为一种为传统软件工程中的类提供私有和公共封装的方法。

使用模块模式时，我们可能会发现定义一个用于开始使用它的简单模板很有用。 这是一个涵盖名称空间、公共和私有变量的内容。

在 JavaScript 中，模块模式用于进一步模拟类的概念，以便我们能够在单个对象中包含公共/私有方法和变量，从而将特定部分屏蔽在全局范围之外。 这会减少我们的函数名称与页面上其他脚本中定义的其他函数发生冲突的可能性。

var myNamespace = (function () {

  var myPrivateVar, myPrivateMethod;

  // A private counter variable
  myPrivateVar = 0;

  // A private function which logs any arguments
  myPrivateMethod = function( foo ) {
      console.log( foo );
  };

  return {

    // A public variable
    myPublicVar: "foo",

    // A public function utilizing privates
    myPublicFunction: function( bar ) {

      // Increment our private counter
      myPrivateVar++;

      // Call our private method using bar
      myPrivateMethod( bar );

    }
  };

})();

优点

为什么模块模式是一个不错的选择？ 对于初学者来说，对于来自面向对象背景的开发人员来说，它比真正的封装的想法要干净得多，至少从 JavaScript 的角度来看是这样。

其次，它支持私有数据 - 因此，在模块模式中，我们代码的公共部分能够触及私有部分，但是外界无法触及类的私有部分。

缺点

模块模式的缺点是，由于我们以不同的方式访问公共和私有成员，因此当我们希望更改可见性时，我们实际上必须对使用该成员的每个位置进行更改。

我们也无法在稍后添加到对象的方法中访问私有成员。 也就是说，在许多情况下，模块模式仍然非常有用，并且如果正确使用，肯定有可能改进我们应用程序的结构。

显示模块模式

现在我们对模块模式有了一些了解，让我们看一下稍微改进的版本 - Christian Heilmann 的显示模块模式。

揭示模块模式的出现是因为当我们想要从另一个公共方法调用一个公共方法或访问公共变量时，Heilmann 对他必须重复主对象的名称感到沮丧。他也不喜欢模块模式必须切换的要求反对他希望公开的事物的字面符号。

他的努力结果是一种更新的模式，我们只需在私有范围中定义所有函数和变量，并返回一个匿名对象，其中包含指向我们希望公开的私有功能的指针。

如何使用揭示模块模式的示例如下

var myRevealingModule = (function () {

        var privateVar = "Ben Cherry",
            publicVar = "Hey there!";

        function privateFunction() {
            console.log( "Name:" + privateVar );
        }

        function publicSetName( strName ) {
            privateVar = strName;
        }

        function publicGetName() {
            privateFunction();
        }


        // Reveal public pointers to
        // private functions and properties

        return {
            setName: publicSetName,
            greeting: publicVar,
            getName: publicGetName
        };

    })();

myRevealingModule.setName( "Paul Kinlan" );

优点

此模式使我们的脚本的语法更加一致。 它还使得在模块末尾更加清楚我们的哪些函数和变量可以公开访问，从而简化了可读性。

缺点

此模式的缺点是，如果私有函数引用公共函数，则在需要修补程序时无法覆盖该公共函数。 这是因为私有函数将继续引用私有实现，并且该模式不适用于公共成员，仅适用于函数。

引用私有变量的公共对象成员也受上述无补丁规则注释的约束。

Answer 12

如果您需要私有范围：

var yourNamespace = (function() {

  //Private property
  var publicScope = {};

  //Private property
  var privateProperty = "aaa"; 

  //Public property
  publicScope.publicProperty = "bbb";

  //Public method
  publicScope.publicMethod = function() {
    this.privateMethod();
  };

  //Private method
  function privateMethod() {
    console.log(this.privateProperty);
  }

  //Return only the public parts
  return publicScope;
}());

yourNamespace.publicMethod();

否则如果您永远不会使用私有范围：

var yourNamespace = {};

yourNamespace.publicMethod = function() {
    // Do something...
};

yourNamespace.publicMethod2 = function() {
    // Do something...
};

yourNamespace.publicMethod();

Answer 13

您可以声明一个简单的函数来提供名称空间。

function namespace(namespace) {
    var object = this, tokens = namespace.split("."), token;

    while (tokens.length > 0) {
        token = tokens.shift();

        if (typeof object[token] === "undefined") {
            object[token] = {};
        }

        object = object[token];
    }

    return object;
}

// Usage example
namespace("foo.bar").baz = "I'm a value!";

Answer 14

我迟到了 7 年，但 8 年前为此做了很多工作：

• http://blogger.ziesemer.com/2008/05/javascript-namespace-function.html
• http://blogger.ziesemer.com/2007/10/respecting-javascript-global-namespace.html

能够轻松高效地创建多个嵌套命名空间，以保持复杂的 Web 应用程序的组织性和可管理性，同时尊重 JavaScript 全局命名空间（防止命名空间污染），并且在执行此操作时不会破坏命名空间路径中的任何现有对象。

从上面来看，这是我在 2008 年左右的解决方案：

var namespace = function(name, separator, container){
  var ns = name.split(separator || '.'),
    o = container || window,
    i,
    len;
  for(i = 0, len = ns.length; i < len; i++){
    o = o[ns[i]] = o[ns[i]] || {};
  }
  return o;
};

这不是创建名称空间，而是提供创建名称空间的函数。

这可以压缩为精简的一行：

var namespace=function(c,f,b){var e=c.split(f||"."),g=b||window,d,a;for(d=0,a=e.length;d<a;d++){g=g[e[d]]=g[e[d]]||{}}return g};

使用示例：

namespace("com.example.namespace");
com.example.namespace.test = function(){
  alert("In namespaced function.");
};

或者，作为一个语句：

namespace("com.example.namespace").test = function(){
  alert("In namespaced function.");
};

然后执行为：

com.example.namespace.test();

如果您不需要旧版浏览器的支持，则更新版本：

const namespace = function(name, separator, container){
    var o = container || window;
    name.split(separator || '.').forEach(function(x){
        o = o[x] = o[x] || {};
    });
    return o;
};

现在，我会持怀疑态度将命名空间暴露给全局命名空间本身。 （太糟糕了，基础语言没有为我们提供这个！）所以我通常会在闭包中使用它，例如：

(function(){
	const namespace = function(name, separator, container){
		var o = container || window;
		name.split(separator || '.').forEach(function(x){
			o = o[x] = o[x] || {};
		});
		return o;
	};
	const ns = namespace("com.ziesemer.myApp");
	
	// Optional:
	ns.namespace = ns;
	
	// Further extend, work with ns from here...
}());

console.log("\"com\":", com);

在较大的应用程序中，只需在页面加载开始时定义一次（对于基于客户端的 Web 应用程序）。 如果保留的话，其他文件可以重用命名空间函数（在上面作为“可选”包含在内）。 最坏的情况是，如果这个函数被重新声明几次，那么它就只有几行代码，如果缩小的话，代码就会更少。

Answer 15

我创建了命名空间，它的灵感来自于 Erlang 的模块。 这是一种非常实用的方法，但这就是我最近编写 JavaScript 代码的方式。

它为闭包提供了一个全局命名空间，并公开了该闭包中定义的集合函数。

(function(){

  namespace("images", previous, next);
  // ^^ This creates or finds a root object, images, and binds the two functions to it.
  // It works even though those functions are not yet defined.

  function previous(){ ... }

  function next(){ ... }

  function find(){ ... } // A private function

})();

Answer 16

将我的几个库移植到不同的项目，并且必须不断更改顶级（静态命名）命名空间后，我转而使用这个小型（开源）辅助函数来定义命名空间。

global_namespace.Define('startpad.base', function(ns) {
    var Other = ns.Import('startpad.other');
    ....
});

有关好处的描述请参见我的博客文章。 您可以此处获取源代码。

我真正喜欢的好处之一是模块之间在加载顺序方面的隔离。 您可以在加载外部模块之前对其进行引用。 当代码可用时，您获得的对象引用将被填充。

Answer 17

我对命名空间使用以下语法。

var MYNamespace = MYNamespace|| {};

 MYNamespace.MyFirstClass = function (val) {
        this.value = val;
        this.getValue = function(){
                          return this.value;
                       };
    }

var myFirstInstance = new MYNamespace.MyFirstClass(46);
alert(myFirstInstance.getValue());

jsfiddle：http://jsfiddle.net/rpaul/4dngxwb3/1/

Answer 18

我认为你们对于这样一个简单的问题都使用了太多的代码。
无需为此创建回购协议。
这是一个单行函数。

namespace => namespace.split(".").reduce((last, next) => (last[next] = (last[next] || {})), window);

尝试一下 ：

// --- definition ---
const namespace = name => name.split(".").reduce((last, next) => (last[next] = (last[next] || {})), window);

// --- Use ----
const c = namespace("a.b.c");
c.MyClass = class MyClass {};

// --- see ----
console.log("a : ", a);

Answer 19

ES6 模块命名空间导入

// circle.js
export { name, draw, reportArea, reportPerimeter };

// main.js
import * as Circle from './modules/circle.js';

// draw a circle
let circle1 = Circle.draw(myCanvas.ctx, 75, 200, 100, 'green');
Circle.reportArea(circle1.radius, reportList);
Circle.reportPerimeter(circle1.radius, reportList);

这会获取所有导出在circle.js中可用的内容，并使它们作为对象Circle的成员可用，从而有效地为其提供了自己的命名空间。

Answer 20

我最喜欢的模式最近变成了这样：

var namespace = (function() {
  
  // expose to public
  return {
    a: internalA,
    c: internalC
  }

  // all private
  
  /**
   * Full JSDoc
   */
  function internalA() {
    // ...
  }
  
  /**
   * Full JSDoc
   */
  function internalB() {
    // ...
  }
  
  /**
   * Full JSDoc
   */
  function internalC() {
    // ...
  }
  
  /**
   * Full JSDoc
   */
  function internalD() {
    // ...
  }
  
})();

当然，return 可以放在最后，但如果后面只有函数声明，就更容易看出命名空间的全部内容以及公开的 API。

在这种情况下使用函数表达式的模式会导致在不检查整个代码的情况下无法知道公开了哪些方法。

Answer 21

我喜欢 Jaco Pretorius 的解决方案，但我想通过将“this”关键字指向模块/命名空间对象来使其更有用。
我的煎锅版本：

(function ($, undefined) {

    console.log(this);

}).call(window.myNamespace = window.myNamespace || {}, jQuery);

Answer 22

JavaScript 还没有命名空间的本机表示，但 TypeScript 有。

例如，您可以使用以下 TS 代码 (

namespace Stack {
    export const hello = () => console.log('hi')
}

Stack.hello()

如果可以的话”如果你不更新你的代码到 TS，你至少可以使用 TS 在为命名空间生成 JS 输出时使用的模式，如下所示：

var Stack;
(function (Stack) {
    Stack.hello = () => console.log('hi');
})(Stack || (Stack = {}));
Stack.hello();

进一步阅读：

• TS - 命名空间
• TS - 命名空间和模块

Answer 23

如果使用 Makefile，您可以执行此操作。

// prelude.hjs
billy = new (
    function moduleWrapper () {
    const exports = this;

// postlude.hjs
return exports;
})();

// someinternalfile.js
function bob () { console.log('hi'); }
exports.bob = bob;

// clientfile.js
billy.bob();

无论如何，一旦达到大约 1000 行，我更喜欢使用 Makefile，因为我可以通过删除 makefile 中的一行来有效地注释掉大段代码。 它使得摆弄东西变得很容易。 此外，使用这种技术，名称空间仅在前奏中出现一次，因此很容易更改，并且您不必在库代码中不断重复它。

使用 makefile 时在浏览器中进行实时开发的 shell 脚本：

while (true); do make; sleep 1; done

将其添加为 make 任务“go”，您可以“make go”以在编码时保持构建更新。

Answer 24

这是 Ionuş G. Stan 答案的后续，但通过使用 var ClassFirst = this.ClassFirst = function() {...} 展示了整洁代码的好处，它利用了 JavaScript 的闭包减少同一命名空间中的类的命名空间混乱。

var Namespace = new function() {
    var ClassFirst = this.ClassFirst = function() {
        this.abc = 123;
    }

    var ClassSecond = this.ClassSecond = function() {
        console.log("Cluttered way to access another class in namespace: ", new Namespace.ClassFirst().abc);
        console.log("Nicer way to access a class in same namespace: ", new ClassFirst().abc);
    }
}

var Namespace2 = new function() {
    var ClassFirst = this.ClassFirst = function() {
        this.abc = 666;
    }

    var ClassSecond = this.ClassSecond = function() {
        console.log("Cluttered way to access another class in namespace: ", new Namespace2.ClassFirst().abc);
        console.log("Nicer way to access a class in same namespace: ", new ClassFirst().abc);
    }
}

new Namespace.ClassSecond()
new Namespace2.ClassSecond()

输出：

Cluttered way to access another class in namespace: 123
Nicer way to access a class in same namespace: 123
Cluttered way to access another class in namespace: 666
Nicer way to access a class in same namespace: 666

Answer 25

我编写了另一个命名空间库，其工作方式更像其他语言中的包/单元。 它允许您创建 JavaScript 代码包以及来自其他代码的包的引用：

文件 hello.js

Package("hello", [], function() {
  function greeting() {
    alert("Hello World!");
  }
  // Expose function greeting to other packages
  Export("greeting", greeting);
});

文件 Example.js

Package("example", ["hello"], function(greeting) {
  // Greeting is available here
  greeting();  // Alerts: "Hello World!"
});

仅第二个文件需要包含在页面中。 它的依赖项（本例中的文件hello.js）将自动加载，并且从这些依赖项导出的对象将用于填充回调函数的参数。

您可以在Packages JS中找到相关项目。

Answer 26

我们可以这样独立使用：

var A = A|| {};
A.B = {};

A.B = {
    itemOne: null,
    itemTwo: null,
};

A.B.itemOne = function () {
    //..
}

A.B.itemTwo = function () {
    //..
}

Answer 27

在 JavaScript 中，没有预定义的方法来使用命名空间。 在 JavaScript 中，我们必须创建自己的方法来定义名称空间。 这是我们在 Ooodles 技术中遵循的过程。

注册命名空间
以下是注册命名空间的函数

//Register NameSpaces Function
function registerNS(args){
 var nameSpaceParts = args.split(".");
 var root = window;

 for(var i=0; i < nameSpaceParts.length; i++)
 {
  if(typeof root[nameSpaceParts[i]] == "undefined")
   root[nameSpaceParts[i]] = new Object();

  root = root[nameSpaceParts[i]];
 }
}

要注册命名空间，只需调用上述函数，并将参数作为命名空间，以 '.' （点）分隔。
例如
让你的应用程序名称是oodles。 您可以通过以下方法创建命名空间

registerNS("oodles.HomeUtilities");
registerNS("oodles.GlobalUtilities");
var $OHU = oodles.HomeUtilities;
var $OGU = oodles.GlobalUtilities;

基本上，它将在后端创建如下所示的 NameSpaces 结构：

var oodles = {
    "HomeUtilities": {},
    "GlobalUtilities": {}
};

在上面的函数中，您注册了一个名为 "oodles.HomeUtilities" 和 "oodles.GlobalUtilities" 的命名空间“。 为了调用这些命名空间，我们创建一个变量，即 var $OHU 和 var $OGU。

这些变量只不过是初始化命名空间的别名。
现在，每当您声明一个属于 HomeUtilities 的函数时，您将按如下方式声明它：

$OHU.initialization = function(){
    //Your Code Here
};

上面是函数名称初始化，并将其放入命名空间 $OHU 中。 并在脚本文件中的任何位置调用此函数。 只需使用以下代码即可。

$OHU.initialization();

类似地，还有另一个命名空间。

希望能帮助到你。

Answer 28

我的习惯是使用function myName()作为属性存储，然后var myName作为“方法”持有者......

无论这是否足够合法，打败我！ 我一直依赖我的 PHP 逻辑，一切都很顺利。 :D

function myObj() {
    this.prop1 = 1;
    this.prop2 = 2;
    this.prop3 = 'string';
}

var myObj = (
 (myObj instanceof Function !== false)
 ? Object.create({

     $props: new myObj(),
     fName1: function() { /* code..  */ },
     fName2: function() { /* code ...*/ }
 })
 : console.log('Object creation failed!')
);

if (this !== that) myObj.fName1(); 否则 myObj.fName2();

您还可以通过“反之亦然”的方式在对象创建之前进行检查，这样要好得多：

function myObj() {
    this.prop1 = 1;
    this.prop2 = 2;
    this.prop3 = 'string';
}

var myObj = (
    (typeof(myObj) !== "function" || myObj instanceof Function === false)
    ? new Boolean()
    : Object.create({
        $props: new myObj(),
        init: function () { return; },
        fName1: function() { /* code..  */ },
        fName2: function() { /* code ...*/ }
    })
);

if (myObj instanceof Boolean) {
    Object.freeze(myObj);
    console.log('myObj failed!');
    debugger;
}
else
    myObj.init();

参考此：JavaScript：使用 Object.create() 创建对象

Answer 29

JavaScript 默认不支持命名空间。 因此，如果您创建任何元素（函数、方法、对象、变量），那么它就会成为全局元素并污染全局命名空间。 让我们以定义两个没有任何命名空间的函数为例，

function func1() {
    console.log("This is a first definition");

}
function func1() {
    console.log("This is a second definition");
}
func1(); // This is a second definition

它总是调用第二个函数定义。 在这种情况下，命名空间将解决名称冲突问题。