JavaScriptでネームスペースを宣言するにはどうすればよいですか。
自分のオブジェクトや関数が他の同じ名前のオブジェクトや関数によって上書きされないように、JavaScriptでネームスペースを作成する方法を教えてください。私は以下を使った：
if (Foo == null || typeof(Foo) != "object") { var Foo = new Object();}
もっとエレガントで簡潔な方法はありますか。
私はこれが好き：
var yourNamespace = {
foo: function() {
},
bar: function() {
}
};
...
yourNamespace.foo();
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 ));
3番目のundefined引数
3番目の
undefined引数は、値undefinedの変数のソースです。今日でもまだ妥当かどうかはわかりませんが、古いブラウザやJavaScript標準（ecmascript 5、javascript <1.8.5〜firefox 4）で作業している間は、グローバルスコープ変数undefinedは書き込み可能なので、誰でも値を書き換えることができます。 3番目の引数（値が渡されない場合）は、名前空間/関数を範囲とするundefinedという名前の変数を作成します。ネームスペースを作成したときに値が渡されなかったため、デフォルトの値はundefinedです。
これを行うもう1つの方法は、オブジェクトリテラル形式よりも少し制限が少ないと私が考えているものです。
var ns = new function() {
var internalFunction = function() {
};
this.publicFunction = function() {
};
};
上のものは モジュールパターン そして あなたが好きであるかどうかにかかわらず - それはあなたがオブジェクトリテラルの堅い構造を避けながらあなたがパブリックとしてすべての関数を公開することを可能にします。
もっとエレガントで簡潔な方法はありますか。
はい。例えば：
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);
}
私は通常それをクロージャーの中に作ります：
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ステートメントは、実装に対するパブリックインターフェイスとして考えてください。
JavaScriptの異なるファイルを書いて、後でそれらをアプリケーションで結合したり結合しなかったりするので、それぞれが他のファイルの作業を損なうことなく名前空間オブジェクトを回復または構築できる必要があります。
1つのファイルが名前空間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(){}
これら2つのファイルは衝突することなく一緒にまたは離れて存在することができます。
Stoyan Stefanovが彼のJavaScriptパターンbookでそれをどのように行っているかを説明します。カスタムオブジェクトのプロトタイプに対するメソッド）：
/**
* 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;
};
これは、user106826のNamespace.jsへのリンクのフォローアップです。プロジェクトは GitHub に移動したようです。今は smith/namespacedotjs です。
私は小さなプロジェクトにこの単純なJavaScriptヘルパーを使用してきましたが、これまでのところ、軽量でありながら名前空間 と モジュール/クラスのロードを処理するのに十分に汎用性があります。グローバルネームスペースだけでなく、自分の選んだネームスペースにパッケージをインポートすることができれば素晴らしいでしょう。
名前空間を宣言してから、その名前空間内のオブジェクト/モジュールを定義することができます。
Namespace('my.awesome.package');
my.awesome.package.WildClass = {};
もう1つの選択肢は、名前空間とその内容を一度に宣言することです。
Namespace('my.awesome.package', {
SuperDuperClass: {
saveTheDay: function() {
alert('You are welcome.');
}
}
});
その他の使用例については、 ソース にあるexample.jsファイルを参照してください。
私はこのアプローチを使います：
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);
サンプル：
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を割り当てることができます。
名前空間を提供するための簡単な関数を宣言できます。
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!";
プライベートスコープが必要な場合：
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();
Erlangのモジュールに触発されたnamespaceを作成しました。それは非常に機能的なアプローチですが、それが私が最近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
})();
Moduleパターンはもともと、従来のソフトウェア工学のクラスにプライベートとパブリックの両方のカプセル化を提供する方法として定義されました。
Moduleパターンを扱うとき、私たちがそれを始めるために使う簡単なテンプレートを定義することが役に立つかもしれません。これは名前空間、パブリック変数、プライベート変数をカバーするものです。
JavaScriptでは、Moduleパターンを使用してクラスの概念をさらにエミュレートし、パブリック/プライベートメソッドと変数の両方を単一のオブジェクト内に含めることで、特定の部分をグローバルスコープから保護することができます。これにより、関数名がページ上の追加のスクリプトで定義されている他の関数と競合する可能性が減少します。
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 );
}
};
})();
利点
なぜModuleパターンが良い選択なのでしょうか。初心者にとって、少なくともJavaScriptの観点からすると、オブジェクト指向のバックグラウンドから開発者が来るのは、本当のカプセル化のアイデアよりもずっとクリーンです。
第二に、それはプライベートデータをサポートします - そのため、Moduleパターンでは、私たちのコードのパブリックな部分はプライベートな部分に触れることができますが、外の世界はクラスのプライベートな部分に触れることができません。
デメリット
Moduleパターンの不利な点は、公開メンバーと非公開メンバーの両方に異なる方法でアクセスするため、可視性を変更したい場合、メンバーが使用されている場所ごとに実際に変更を加える必要があることです。
また、後でオブジェクトに追加されたメソッドでプライベートメンバにアクセスすることもできません 。そうは言っても、多くの場合、Moduleパターンは依然として非常に有用であり、正しく使用されると、確かにアプリケーションの構造を改善する可能性があります。
明らかにするモジュールのパターン
モジュールパターンについてもう少し詳しく説明したので、少し改良されたバージョンであるChristian HeilmannのRevealing Moduleパターンを見てみましょう。
あるモジュールから別のパブリックメソッドを呼び出すとき、またはパブリック変数にアクセスするときに、メインオブジェクトの名前を繰り返さなければならないという事実にHeilmannが不満を抱いていたため、Revealing Moduleパターンが登場しました。彼が公表したいことのための文字表記法に反対すること。
彼の努力の結果、私たちがすべての関数と変数をプライベートスコープで定義し、パブリックとして公開したいプライベート機能へのポインタを持つ匿名オブジェクトを返すという更新されたパターンが生まれました。
明らかにするモジュールパターンを使用する方法の例は以下で見つけることができます
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" );
利点
このパターンにより、私たちのスクリプトの構文はより一貫性のあるものになります。また、モジュールの最後にある関数や変数のどれに公にアクセスできるのかがわかりやすくなり、読みやすくなります。
デメリット
このパターンの欠点は、プライベート関数がパブリック関数を参照している場合、パッチが必要な場合にそのパブリック関数をオーバーライドできないことです。これは、プライベート関数が引き続きプライベート実装を参照し、パターンがパブリックメンバーには適用されず、関数にのみ適用されるためです。
プライベート変数を参照するパブリックオブジェクトメンバも、上記のパッチなしのルールノートに従います。
名前空間には次の構文を使用します。
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/ /
私はパーティーに7年遅れています、しかしこの8年前にかなりの仕事をしました：
- http://blogger.ziesemer.com/2008/05/javascript-namespace-function.html
- http://blogger.ziesemer.com/2007/10/respecting-javascript-global-namespace.html
JavaScriptのグローバルネームスペースを尊重しながら（ネームスペースの汚染を防止しながら）、またネームスペースパス内の既存のオブジェクトを壊さないようにしながら、複雑で複雑なWebアプリケーションを整理し管理しやすいように複数のネストネームスペースを簡単かつ効率的に作成できることが重要です。 。
上記から、これは私の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.");
};
あるいは、1つのステートメントとして：
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;
};
さて、私はnamespaceをグローバル名前空間自体に公開することに戸惑います。 （残念ながら、ベース言語ではこれが提供されていません！）そのため、私は通常これを自分自身でクロージャーとして使用します。
(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アプリケーションの場合）。追加のファイルは、保持されていればネームスペース関数を再利用できます（上記の「オプション」として含まれています）。最悪の場合、この関数が数回再宣言された場合 - ほんの数行のコードで、縮小された場合は少なくなります。
私のライブラリのいくつかを異なるプロジェクトに移植し、常にトップレベルの（静的に命名された）名前空間を変更しなければならなかったので、私は名前空間を定義するのにこの小さな（オープンソースの）ヘルパー関数を使うことに切り替えました。
global_namespace.Define('startpad.base', function(ns) {
var Other = ns.Import('startpad.other');
....
});
利点の説明は私の ブログ投稿 にあります。 ソースコードはこちらから入手できます 。
私が本当に好きな利点の1つは、ロード順序に関してモジュール間の分離です。ロードされる前に外部モジュールを参照することができます。そして、あなたが取得したオブジェクト参照は、コードが利用可能になったときに記入されます。
Namespace.jsoutをチェックする必要があります。
私はJaco Pretoriusの解決策が好きですが、モジュール/名前空間オブジェクトを指すことで "this"キーワードをもう少し便利にしたいと思いました。私のバージョンのフライパン：
(function ($, undefined) {
console.log(this);
}).call(window.myNamespace = window.myNamespace || {}, jQuery);
私のお気に入りのパターンは最近これになっています：
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が公開されているのかを確認する方がはるかに簡単です。
このような場合に関数式を使用するパターンでは、コード全体を調べずにどのメソッドが公開されているかを知ることができません。
このようにしてそれを独立して使用することができます。
var A = A|| {};
A.B = {};
A.B = {
itemOne: null,
itemTwo: null,
};
A.B.itemOne = function () {
//..
}
A.B.itemTwo = function () {
//..
}
Ionuț G. Stanの答えをかなりフォローアップしていますが、var ClassFirst = this.ClassFirst = function() {...}を使用することによって整理されていないコードの利点を示しています。
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
私はあなたが皆そのような単純な問題のために多すぎるコードを使用すると思います。そのためのレポを作る必要はありません。これが単一行関数です。
namespace => namespace.split(".").reduce((last, next) => (last[next] = (last[next] || {})), window);
それを試してみてください ：
// --- definition ---
const namespace = namespace => namespace.split(".").reduce((last, next) => (last[next] = (last[next] || {})), window);
// --- Use ----
let myNamespace = namespace("a.b.c");
myNamespace.MyClass = class MyClass {};
// --- see ----
console.log("a : ", a);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();
Makefileの中の1行を削除することで、大量のコードを効果的にコメントアウトすることができるので、1000行に達すると、とにかくMakefileを使用することを好みます。それはものをいじるのが簡単になります。また、このテクニックを使うと、名前空間はプレリュードの中に一度しか現れないので、変更するのは簡単で、ライブラリコードの中でそれを繰り返す必要はありません。
メイクファイルを使用するときのブラウザでのライブ開発のためのシェルスクリプト：
while (true); do make; sleep 1; done
これをmakeタスクとして 'go'として追加すると、コードを作成しながらビルドを最新の状態に保つために 'make go'を実行できます。
私は他の言語でパッケージやユニットがするのと同じように機能するもう一つの名前空間ライブラリを書きました。それはあなたが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!"
});
2番目のファイルだけをページに含める必要があります。その依存関係（この例ではfile hello.js ）が自動的にロードされ、それらの依存関係からエクスポートされたオブジェクトがコールバック関数の引数を生成するために使用されます。
関連プロジェクトはパッケージJSにあります。
JavaScriptでは、名前空間を使用するための事前定義メソッドはありません。 JavaScriptでは、ネームスペースを定義するための独自のメソッドを作成する必要があります。これが私たちがOodlesテクノロジーズで従う手順です。
ネームスペースを登録する以下はネームスペースを登録する機能です。
//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]];
}
}
名前空間を登録するには、引数を'.'（ドット）で区切った名前空間として上記の関数を呼び出します。例えば、あなたのアプリケーション名がうどんだとしましょう。次の方法で名前空間を作ることができます
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();
他のネームスペースも同様です。
それが役に立てば幸い。
私の習慣は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(); else 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();