JavaScript - преимущества объектного литерала

Ответ 1

Как сказал Russ Cam, вы избегаете загрязнения глобального пространства имен, что очень важно в эти дни для объединения скриптов из нескольких мест (TinyMCE и т.д.).

Как сказал Алекс Секстон, он также создает хорошую организацию кода.

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

var MyThingy = (function() {

    function doSomethingCool() {
        ...
    }

    function internalSomething() {
        ....
    }

    function anotherNiftyThing() {
        // Note that within the scoping function, functions can
        // call each other direct.
        doSomethingCool();
        internalSomething();
    }

    return {
        doSomethingCool: doSomethingCool,
        anotherNiftyThing: anotherNiftyThing
    };
})();

Внешнее использование:

MyThingy.doSomethingCool();

Функция определения области охвата охватывает все ваши функции, а затем вы вызываете ее немедленно и сохраняете ее возвращаемое значение. Преимущества:

• Функции объявляются нормально и, следовательно, имеют имена. (Принимая во внимание, что в формате {name: function() { ... }} все ваши функции анонимны, хотя свойства, ссылающиеся на них, имеют имена.) Инструменты справки по именам помогают вам, от отображения стеков вызовов в отладчике, сообщать вам, какая функция выбрала исключение. (Обновление в 2015 году: последняя спецификация JavaScript, ECMAScript 6-е издание, определяет большое количество способов, с помощью которых движок JavaScript должен вызывать имя функции. Один из них - это когда функция назначается свойству, как в нашем примере {name: function() { ... }}. двигатели реализуют ES6, эта причина исчезнет.)
• Предоставляет вам свободу использования частных функций, используемых только вашим модулем (например, мой internalSomething выше). Никакой другой код на странице не может вызвать эти функции; они действительно частные. Только те, которые вы экспортируете в конце, в операторе return, видны вне функции обзора.
• Легко возвращать разные функции в зависимости от среды, если реализация просто полностью изменяется (например, материал IE-vs-W3C, SVG или Canvas и т.д.).

Пример возврата различных функций:

var MyUtils = (function() {
    function hookViaAttach(element, eventName, handler) {
        element.attachEvent('on' + eventName, handler);
    }

    function hookViaListener(element, eventName, handler) {
        element.addEventListener(eventName, handler, false);
    }

    return {
        hook: window.attachEvent ? hookViaAttach : hookViaListener
    };
})();

MyUtils.hook(document.getElementById('foo'), 'click', /* handler goes here */);

Ответ 2

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

Например, этот литерал объекта

var obj = {
              find : function(elem) { /* find code */ },
              doSomething: function() { /* doSomething code */ },
              doSomethingElse: function() { /* doSomethingElse code */ }
          }

по сравнению с

function find(elem) { /* find code */ },
function doSomething() { /* doSomething code */ },
function doSomethingElse() { /* doSomethingElse code */ }

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

obj.doSomething();

Ответ 3

Ребекка Мурфи провела беседу об объектных литералах в этом году на jQuery Conference. Одна из лучших причин их использования - просто хорошая организация кода.

Вот Ребекка написала на Object Literal Pattern: http://rmurphey.com/blog/2009/10/15/using-objects-to-organize-your-code/

Ответ 4

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

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

Вы можете легко написать литерал как

var obj = {}
var find = function(elem) { /* find code */ },
var doSomething = function() { /* doSomething code */ },
var doSomethingElse = function() { /* doSomethingElse code */ }

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

(function() {
function find(elem) { /* find code */ },
function doSomething() { /* doSomething code */ },
function doSomethingElse() { /* doSomethingElse code */ }
})();

который не создавал бы эти глобальные объекты (все это объект в JS)

таким образом вы все равно не создаете множество глобальных объектов.

На мой взгляд, объекты литералов имеют два преимущества. Один из них используется многими плагинами, такими как jQuery, чтобы люди были familier, и их легко читать. Легко передавать данные в плагин. Легко создавать как публичные, так и частные методы....

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

Я, конечно, ошибаюсь...