я использую подход, найденный на сайте 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 ));

третий undefined аргумент

третий undefined аргумент является источником переменной value undefined. Я не уверен, что это все еще актуально сегодня, но при работе со старыми браузерами / стандартами JavaScript (ecmascript 5, javascript undefined доступен для записи, поэтому любой может переписать его значение. Третий аргумент (если не передано значение) создает переменную с именем undefined что область действия пространства имен / функции. Поскольку значение не было передано при создании пространства имен, по умолчанию используется значение undefined.

другой способ сделать это, который я считаю немного менее ограничительным, чем литеральная форма объекта, заключается в следующем:

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 и позже комбинировать или не комбинировать их в приложении, каждый должен иметь возможность восстанавливать или создавать объект пространства имен, не повреждая работу других файлов...

один файл может использовать пространство имен 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(){}

эти два файла могут жить вместе или порознь, не сталкиваясь.

вот как это делает Стоян Стефанов в своем Шаблоны JavaScript книга, которую я нашел очень хорошей (она также показывает, как он делает комментарии, которые позволяют автоматически создавать документацию 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;
};

Я использую такой подход:

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);

это продолжение ссылки user106826 на пространство имен.js. Кажется, проект переместился в GitHub. Сейчас smith / namespacedotjs.

Я использую этот простой помощник JavaScript для моего крошечного проекта, и до сих пор он кажется легким, но достаточно универсальным для обработки пространства имен и загрузка модулей/классов. Было бы здорово, если бы это позволило мне импортировать пакет в пространство имен по моему выбору, а не только в глобальное пространство имен... вздох, но это к делу не относится.

Он позволяет объявить пространство имен, а затем определить объекты / модули в этом пространстве имен:

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

другой вариант-объявить пространство имен и его содержимое сразу:

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

дополнительные примеры использования, рассмотрим на примере.файл JS в источник.

пример:

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!";

Я создал пространство имен который вдохновлен модулями 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

})();

Если вам нужна частная область:

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();

else если вы никогда не будете использовать частную область:

var yourNamespace = {};

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

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

yourNamespace.publicMethod();

Я использую следующий синтаксис для пространств имен.

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/

шаблон модуля первоначально был определен как способ обеспечения как частной, так и публичной инкапсуляции для классов в обычной программной инженерии.

при работе с шаблоном модуля может оказаться полезным определить простой шаблон, который мы используем для начала работы с ним. Вот один, который охватывает интервал имен, общедоступные и частные переменные.

в 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.

во-вторых, он поддерживает частные данные-таким образом, в шаблоне модуля публичные части нашего кода могут касаться частных частей, однако внешний мир не может касаться частных частей класса.

недостатки

недостатками шаблона модуля является то, что, поскольку мы получаем доступ к публичным и частным членам по-разному, когда мы хотим изменить видимость, мы на самом деле нужно внести изменения в каждое место, где был использован член.

мы также не можем получить доступ к частным членам в методах, которые добавляются к объекту в более поздний момент. Тем не менее, во многих случаях шаблон модуля по-прежнему весьма полезен и при правильном использовании, безусловно, имеет потенциал для улучшения структуры нашего приложения.

Раскрывая Картина Модуля

теперь, когда мы немного знакомы с модулем pattern, давайте взглянем на немного улучшенную версию-показательный модульный шаблон Кристиана Хейльмана.

показательный шаблон модуля произошел, когда Хайльман был разочарован тем фактом, что ему пришлось повторить имя основного объекта, когда мы хотели вызвать один общедоступный метод из другого или получить доступ к общедоступным переменным.Ему также не нравилось требование шаблона модуля для переключения на буквальное обозначение объектов для вещей, которые он хотел обнародовать.

в результатом его усилий стал обновленный шаблон, в котором мы просто определяли все наши функции и переменные в частной области и возвращали анонимный объект с указателями на частную функциональность, которую мы хотели показать как общедоступную.

пример того, как использовать шаблон модуля выявления можно найти ниже

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" );

преимущества

этот шаблон позволяет синтаксису наших скриптов быть более последовательным. Он также делает в конце модуля более ясно, какие из наших функций и переменных могут быть доступны публично, что облегчает читаемость.

недостатки

недостатком этого шаблона является то, что если частная функция ссылается на публичную функцию, эта публичная функция не может быть переопределена, если необходим патч. Это связано с тем, что функция private будет продолжать ссылаться на частную реализацию, а шаблон не применяется к публичным членам, только к функции.

после переноса нескольких моих библиотек в разные проекты и постоянного изменения пространства имен верхнего уровня (статически именованного) я переключился на использование этой небольшой вспомогательной функции (с открытым исходным кодом) для определения пространств имен.

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

описание преимуществ на my блоге. Вы можете захватить здесь исходный код.

одним из преимуществ, которое мне действительно нравится, является изоляция между модулями относительно порядка загрузки. Вы может ссылаться на внешний модуль перед его загрузкой. И ссылка на объект, которую вы получите, будет заполнена, когда код будет доступен.

Я 7 лет опоздал на вечеринку, но сделал совсем немного работы вокруг этого 8 лет назад:

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

важно иметь возможность легко и эффективно создавать несколько вложенных пространств имен, чтобы держать сложное веб-приложение организованным и управляемый, при уважении глобального пространства имен JavaScript (предотвращение загрязнения пространства имен), и с не clobbering любые существующие объекты в пути пространства имен при этом.

из вышесказанного, это было мое решение около-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;
};

это не создает пространство имен, но предоставляет функцию для создания пространств имен.

это можно сконденсировать к minified ОДН-вкладышу:

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;
};

теперь я бы опасался разоблачения 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);

в более большом применении, это только нужно быть определенным раз на начало загрузки страницы (для клиентских веб-приложений). Дополнительные файлы могут затем повторно использовать функцию пространства имен, если они сохранены (включены как "необязательные" в приведенном выше). В худшем случае, если эта функция повторно объявлена несколько раз-это всего несколько строк кода, и меньше, если минимизировать.

вы должны проверить пространство имен.js отсюда!

мой любимый шаблон стал в последнее время это:

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 предоставляется.

шаблон использования выражений функций в таких случаях приводит к невозможности узнать, какие методы подвергаются, не просматривая весь код.

Мне нравится решение Jaco Pretorius, но я хотел сделать ключевое слово "this" немного более полезным, указав его на объект module/namespace. Моя версия сковороды:

(function ($, undefined) {

    console.log(this);

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

довольно продолжение ответа 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

мы можем использовать его самостоятельно таким образом:

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

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

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

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

Я думаю, что вы все использовать слишком много кода для такой простой задачи. Нет необходимости делать РЕПО для этого. Вот однострочная функция.

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 в любом случае, как только я получаю около 1000 строк, потому что я могу эффективно комментировать большие полосы кода, удаляя одну строку в makefile. Это позволяет легко возиться с вещами. Кроме того, с помощью этого метода пространство имен появляется только один раз в прелюдии, поэтому его легко изменить, и вам не нужно повторять его внутри кода библиотеки.

сценарий оболочки для живого развития браузер при использовании 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);
});

Пример Файла.js

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

только второй файл должен быть включен в страницу. Его зависимости (file Здравствуйте.js в этом примере) будет автоматически загружен и экспортированы объекты из этих зависимостей будут использоваться для заполнения аргументов функции обратного вызова.

вы можете найти связанный проект в пакеты JS.

моя привычка использовать функция 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();

ссылка на это: JavaScript: создание объекта с помощью объекта.create ()

в JavaScript нет предопределенных методов для использования пространств имен. В JavaScript мы должны создать свои собственные методы для определения пространств имен. Вот процедура, которой мы следуем в Oodles technologies.

зарегистрировать пространство имен Ниже приведена функция регистрации пространства имен

//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;

в основном это создаст структуру пространств имен, как показано ниже в бэкэнде:

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

в приведенной выше функции вы зарегистрировали пространство имен с именем "oodles.HomeUtilities" и "oodles.GlobalUtilities". Чтобы вызвать эти пространства имен, мы делаем переменную, т. е. var $OHU и var $OGU.

эти переменные не что иное, как псевдоним для инициализации пространства имен. Теперь, когда вы объявляете функцию, принадлежащую HomeUtilities вы объявите его как следующее:

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

выше-инициализация имени функции, и она помещается в пространство имен $OHU. и вызывать эту функцию в любом месте в файлах скриптов. Просто используйте следующий код.

$OHU.initialization();

аналогично, с другими пространствами имен.

надеюсь, что это помогает.