Объекты в JavaScript

    JavaScript предоставляет массу способов использовать объектно-ориентированное программирование. Для этого существуют следующие приёмы:
    • Оператор new
    • Литеральная нотация
    • Конструкторы объектов
    • Прототипы
    • Ассоциативные массивы



    Используем оператор new



    Это, наверное, самый легкий способ создания объекта. Вы просто создаете имя объекта и приравниваете его к новому объекту Javascript.


    //Создаем наш объект
    var MyObject = new Object();
    //Переменные
    MyObject.id = 5; //Числовая свойство
    MyObject.name = "Sample"; //Строковое свойство
    //Функции
    MyObject.getName = function()
    {
        return this.name;
    } 
    


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


    //Используем наш объект
    alert(MyObject.getName()); 
    


    Литеральная нотация



    Литеральная нотация является несколько непривычным способом определения новых объектов, но достаточно легким для понимания. Литеральная нотация работает с версии Javascript 1.3.


    //Создаем наш объект с использованием литеральной нотации
    MyObject = {
        id : 1,
        name : "Sample",
        boolval : true,
        getName : function()
        {
            return this.name;
        }
    } 
    


    Как видите, это довольно просто.


    Объект = {
    идентификатор : значение;
    ...
    } 
    


    Использовать такое достаточно легко.


    alert(MyObject.getName()); 
    


    Конструкторы объектов



    Конструкторы объектов — это мощное средство для создания объектов, которые можно использовать множество раз. Конструктор объекта — это, по сути, обычная функция Javascript, которой так же можно передавать различные параметры.


    function MyObject(id, name)
    {
    
    } 
    


    Если проводить параллели с ООП, то это — функция-конструтор. С помощью неё мы и будем создавать наш объект.


    var MyFirstObjectInstance = new MyObject(5,"Sample");
    var MySecondObjectInstace = new MyObject(12,"Othe Sample"); 
    


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


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


    function MyObject(id, name)
    {
        //Значения переданные пользователем
        this._id = id;
        this._name = name;
        //Значение по умолчанию
        this.defaultvalue = "MyDefaultValue"; 
    } 
    


    Аналогичным образом мы можем создавать и функции.


    function MyObject(id,name)
    {
        this._id = id;
        this._name = name;
        this.defaultvalue = "MyDefaultValue"; 
        
        //Получение текущего значения
        this.getDefaultValue = function()
        {
            return this.defaultvalue;
        }
        
        //Установка нового значения
        this.setDefaultValue = function(newvalue)
        {
            this.defaultvalue = newvalue;
        }
        
        //Произвольная функция
        this.sum = function(a, b)
        {
            return (a+b);
        }
    } 
    


    Я считаю, что это один из мощнейших механизмов Javascript.


    Использование прототипов



    Прототипы в Javascript`е появились С JavaScript1.3/JScript2.0/ECMAScript 3rd Edition. С помощью прототипов можно добавлять новые свойства и параметры к уже существующим объектам.


    Объект - Класс - Экземпляр класса 
    


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


    Создание объекта здесь ничем не отличается от аналогичного процесса при создании объекта с помощью конструкторов.


    function MyObject(id, name)
    {
        //Устанавливаем значения
        this._id = id;
        this._name = name;
    } 
    


    Если вдруг мы захотим создать новое свойство для объекта MyObject, то сделать это можно будет следующим образом:


    var MyInstance = new MyObject(5,"some value");
    MyInstance.newproperty = true; 
    


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


    var MyInstance = new MyObject(5,"some value");
    MyInstance.prototype.newproperty = false;
    MyInstance.newproperty = true; 
    


    Это не является лучшим решением использования прототипов — это просто пример. Почему это не является лучшим решением? Потому что код будет трудно сопровождать, если свойства объектов не как положено (в самом объекте), а в произвольном месте скрипта.


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


    Как и следовало ожидать, помимо свойств можно создавать и методы. Вот простой пример того, как это сделать.


    //Используем наш <b>объект</b>, а не <b>экземпляр</b>.
    MyObject.prototype.getId = function()
    {
        return this._id;
    } 
    


    Механизм прототипов мощен не только по вышеперечисленным возможностям, но и потому, что можно улучшать собственные объекты Javascript, такие как String, Array, и другие. Приведу простой пример:


    //Функция получения количества слов в строке
    function getWordsCount()
    {
        return this.split(" ").length;
    }
    
    //Назначаем функцию прототипу
    String.prototype.getWordsCount = getWordsCount;
    
    //Пример использования:
    var mystring = "My Test String";
    alert(mystring.getWordsCount()); //Должно вывести число 3 
    


    Ассоциативные массивы



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


    var MyObject = new Array();
    MyObject["id"] = 5;
    MyObject["name"] = "SampleName"; 
    



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

    Похожие публикации

    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама

    Комментарии 11

      +1
      Не буду скрывать, подчерпнул кое-что новое :)
      Низкий поклон за ликбез!
      Уже в избранном :)
        +3
        >Javascript, помимо стандартных возможностей, предоставляет массу способов
        Ниже вы описываете всё те же стандартные возможности, ничего "помимо" этого...

        >Числовая переменная
        Лучше всё-таки стараться не смешивать свойства и переменные, переменные в javascript - это свойства, но свойства - совсем не обязательно переменные.

        >вы можете работать только с одним вновь созданным объектом
        Работать можно и с одним, и со всеми, Object - обычный конструктор, плодящий объекты.

        >Литеральная нотация работает в версии Javascript 1.2 и выше
        С JavaScript1.3/JScript2.0/ECMAScript 3rd Edition

        >Создаем наш объект с использованием литеральной нотации
        Пары разделяются запятыми, а не точкой с запятой, как в вашем примере.

        >имя_переменной : содержание переменной
        Слева ни в коем случае не переменные, а идентификаторы/строки/числа, разница, думаю, очевидна.

        >С помощью прототипов можно добавлять новые свойства и параметры
        Параметры не при чём, это термин из арсенала функций.

        >MyInstance.prototype.newproperty = false;
        Совершенно не так, у объекта, созданного конструктором, нет свойства 'prototype'.

        >экземпляр класса наследует все свойства и методы класса
        В javascript 1.x нет классов (со всеми из этого вытекающими).

        >Как и в ООП
        >Если проводить параллели с ООП
        Вы напрасно сравниваете по тексту javascript с OOP в целом, будучи object-based языком, javascript уже там, если уж сравнивать, так против class-based языков и их особенностей.

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

        >Итак, мы рассмотрели способы создания объектов
        Из пяти "способов создания" к делу относятся только первые два.
          0
          несмотря на то что я согласен с вышесказанным, все-таки критику не мешало бы разбавить. Тема тяжела для новичка и мало кто об этом пишет.
            0
            Спасибо за замечания, давайте разбираться.

            >Ниже вы описываете всё те же стандартные возможности, ничего "помимо" этого...
            Стандартные - это использование функций.

            >Работать можно и с одним, и со всеми, Object - обычный конструктор, плодящий объекты.
            MyObject мы не можем создать еще один раз

            >Слева ни в коем случае не переменные, а идентификаторы/строки/числа, разница, думаю, очевидна.
            Имя - разве не идентификатор?

            >В javascript 1.x нет классов (со всеми из этого вытекающими).
            Читали текст выше? Это из параллели с ООП

            >Из пяти "способов создания" к делу относятся только первые два.
            Конструкторы - это тоже средство создания таких элементов, которые объединяют свойста и методы. Так почему же только два?
              0
              >Пары разделяются запятыми, а не точкой с запятой, как в вашем примере.
              Именно точкой с запятой.
                0
                А нет, ошибся. извиняюсь.
                0
                Исправил указанные ошибки.
                0
                не_правильно:
                MyObject = {
                id : 1;
                name : "Sample";
                boolval : true;
                getName : function()
                {
                return this.name;
                }
                }

                правильно:
                MyObject = {
                id : 1,
                name : "Sample",
                boolval : true,
                getName : function()
                {
                return this.name;
                }
                }
                  +1
                  "самых мощнейших" --> "самых мощных" | "мощнейших"
                    0
                    Поправил
                    0
                    http://disaen.com/misc/inheritance/

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

                    Самое читаемое