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

Я создал пространство имен который вдохновлен модулями Эрланга. Это очень функциональный подход, но именно так я пишу свой код 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();

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

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

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

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

недостатки

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

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

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

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

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

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

Я на 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;
};

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

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

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() {
    // ...
  }
  
})();

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

добавить это как сделать задачу "go", и вы можете "сделать 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.

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

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

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

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

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

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

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

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

$OHU.initialization();

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

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