Объекты - одно из основных понятий в JavaScript. Когда я только приступил к их изучению, они показались мне довольно простыми: всего лишь пары ключей и значений, как и описывалось в теории.
Лишь спустя некоторое время я начал понимать, что тема гораздо сложнее, чем я полагал. И тогда я стал изучать информацию из разных источников. Некоторые из них давали хорошее представление о предмете, но увидеть всю картину целиком я смог не сразу.
В этом посте я попытался охватить все аспекты работы с объектами в JS, не вдаваясь слишком глубоко в отдельные подробности, но и не упуская важные детали, которые помогут вам понять предмет и почувствовать себя увереннее во время его дальнейшего изучения.
Итак, давайте начнем с основ.
Объект
Объект в JavaScript - это просто набор свойств, каждое из которые представляет собой пару ключ-значение. Обратиться к ключам можно с помощью точечного (obj.a ) или скобочного обозначения (obj["a"] ).Помните, что скобки следует использовать, если ключ:
- не является допустимым JavaScript-идентификатором (в нем есть пробел, тире, начинается с цифры...)
- является переменной.
Прототип
У каждого объекта в JavaScript есть внутреннее свойство под названием Prototype . В большинстве браузеров вы можете обратиться к нему по обозначению __proto__ .Prototype - это способ обеспечить наследование свойств в JavaScript. Так можно делится функциональностью без дублирования кода в памяти. Способ работает за счет создания связи между двумя объектами.
Проще говоря, Prototype создает указатель с одного объекта на другой.
Цепочка прототипов
Каждый раз, когда JS ищет свойство в объекте и не находит его непосредственно у самого объекта, он проверяет наличие свойства в объекте-прототипе. Если свойства нет и в нем, то JS продолжит поиск в прототипе связанного объекта. Так будет продолжаться до тех пор, пока JS не найдет подходящее свойство или не достигнет конца цепочки.
Давайте рассмотрим пример:
Var cons = function () {
this.a = 1;
this.b = 2;
}
var obj = new cons();
cons.prototype.b = 3;
cons.prototype.c = 4;
cons
- это конструктор (просто функция, которую можно вызывать с помощью оператора new
).
На пятой строке мы создаем новый объект - новую копию cons . Сразу после создания obj также получает свойство прототипа.
А теперь мы добавляем свойства ("b", "c"
) прототипу объекта cons
.
Рассмотрим obj
:
obj.a // 1
- здесь все по-старому, obj.a
по-прежнему равен 1.
obj.c?
- у obj
нет свойства c
! Однако, как ранее упоминалось, JS теперь поищет его в прототипе obj
и вернет значение 4.
А теперь давайте подумаем, каково значение obj.b и каким оно станет, когда мы удалим obj.b ?
Obj.b равен 2. Мы назначили свойство b , но мы сделали это для прототипа cons , поэтому когда мы проверяем obj.b , то по-прежнему получаем 2. Однако сразу после удаления obj.b JS уже не сможет найти b у obj , и потому продолжит поиск в прототипе и вернет значение 3.
Создание объекта
Литерал объекта: let obj = {a: 1};Мы создали объект со следующей цепочкой прототипов: obj ---> Object.prototype ---> null
Как вы можете догадаться, object.prototype - это прототип объекта, а также конец цепочки прототипов.
Object.create():
var newObj = Object.create(obj);
У newObj
будет следующая цепочка прототипов: newObj ---> obj ---> Object.prototype ---> null
Конструктор. Как и в приведенном выше примере, конструктор - это просто JS-функция, позволяющая нам воспользоваться оператором new для создания новых ее экземпляров.
ES6 классы:
Class rectangle {
constructor(height, width) {
this.height = height;
this.width = width;
}
getArea() {
return this.height * this.width;
}
}
let square = new rectangle(2, 2);
Square
- экземпляр конструктора rectangle
, и поэтому мы можем вызвать square.getArea() //4
, square.width
, а также все функции, унаследованные от object.prototype
.
Какой из способов лучше? Если вы планируете создать несколько экземпляров, можно воспользоваться ES6 или конструктором. Если же вы планируете создать объект один раз, то лучше задать литерал, поскольку это самый простой способ.
И теперь, когда мы узнали о prototype и познакомились со всеми способами создания новых объектов, мы можем перейти к обсуждению одного из самых запутанных моментов, связанных с объектами.
Сравнение и изменение объектов
В JavaScript объекты относятся к ссылочному типуКогда мы создаем объект let obj = {a: 1}; , переменная obj получает адрес в памяти объекта, но не его значение! Крайне важно понимать эту разницу, поскольку в противном случае могут возникнуть ошибки. Когда мы создаем другой объект let newObj = obj , мы фактически создаем указатель на некую область памяти obj , а не абсолютно новый объект.
Это значит, что выполняя newObj.a = 2 , мы фактически изменяем obj таким образом, что obj.a становится равен 2!
Такой подход легко приводит к появлению багов, поэтому многие компании работают с неизменяемыми объектами. Вместо изменения уже созданного объекта вам придется опять создавать новый объект (копию оригинала) и вносить изменения уже в нем. Именно так работают важные библиотеки вроде Redux, и в целом это одна из основных концепций функционального программирования. Подробнее можно почитать .
Равенство
Из сказанного выше также вытекает, что два объекта никогда не могут быть равными, даже если они обладают одинаковыми свойствами. Это связано с тем, что JS по факту сравнивает расположение в памяти объектов, а два объекта никогда не находятся в одной ячейке памяти.
// Two distinct objects with the same properties are not equal
var fruit = {name: "apple"};
var fruitbear = {name: "apple"};
fruit === fruitbear; // return false
// here fruit and fruitbear are pointing to same object
var fruit = {name: "apple"};
var fruitbear = fruit;
fruit === fruitbear; // return true
Итак, вы скорее всего уже задались вопросом, как можно сравнить объекты или как производить с объектами различные манипуляции, учитывая требование к их неизменности.
Рассмотрим несколько возможностей.
Изменение объекта
Допустим, ясно, что по-хорошему нам не следует изменять объекты, поэтому мы хотим создать копию соответствующего объекта и изменить ее свойства. На помощь приходит Object.assign() .
Var obj = { a: 1, b: 2};
var newObj = Object.assign({}, obj,{a:2}) // {a: 2, b: 2 }
Если мы захотим изменить значение свойства a
объекта obj
, можно воспользоваться object.assign
для создания копии obj
и ее изменения.
В примере видно, что мы сначала создаем пустой объект, затем копируем значения obj и вносим наши изменения, в конечном счете получая новый и готовый к использованию объект.
Пожалуйста, обратите внимание, что этот способ не сработает для глубокого копирования. Говоря о глубоком копировании, мы имеем в виду, что нужно скопировать объект с одним или несколькими свойствами.
Const obj = {a: 1, b: { a: 1 } }; // b property is an object
Object.assign()
копирует свойства объекта, поэтому если значение свойства - это указатель на объект, то копируется только указатель.
Для глубокого копирования необходима рекурсивная операция. Здесь можно написать функцию или просто воспользоваться методом _.cloneDeep из библиотеки Lodash .
Сравнение объектов
Есть один классный прием работы с объектами - строчное преобразование. В следующем примере мы преобразовываем оба объекта в строки и сравниваем их:
JSON.stringify(obj1) === JSON.stringify(obj2)
Такой подход оправдан, поскольку в итоге мы сравниваем строки, представляющие собой указатель на тип-значение. Плохая новость - он не всегда срабатывает, главным образом потому, что тот или иной порядок свойств объекта не гарантируется.
Другое хорошее решение - воспользоваться методом _.isEqual из Lodash , выполняющим глубокое сравнение объектов.
И перед тем, как закончить, давайте пробежимся по некоторым часто возникающим вопросам на тему объектов. Это поможет глубже погрузиться в тему и применить полученные знания на практике.
Постарайтесь подумать над решением самостоятельно перед тем, как прочитать ответ.
Как узнать длину объекта?
Для получения ответа необходимо перебрать все свойства объекта одно за другим и посчитать их. Существует несколько способов выполнить подобную итерацию:- for in . Этот метод охватывает все счетные свойства объекта и цепочки его прототипов. Мы познакомились с прототипом (и, надеюсь, усвоили материал), поэтому должно быть ясно, что применение for in не всегда будет верным для получения свойств объекта.
- Object.keys . Этот способ возвращает массив с ключами всех собственных (принадлежащих указанному объекту) счетных свойств. Такой подход лучше, поскольку мы работаем только над свойствами объекта, не обращаясь к свойствам prototype . Бывают, однако, ситуации, когда вы присвоили атрибуту enumerable некоторого свойства значение false, и object.keys в итоге пропускает его, а вы получаете некорректный результат. Такое происходит редко, но в подобных случаях очень кстати придется getOwnPropertyNames .
- getOwnPropertyNames возвращает массив, содержащий все собственные ключи объекта (как счетные, так и несчетные).
- Object.values перебирает собственные счетные свойства и возвращает массив с соответствующими значениями .
- Object.entries перебирает собственные счетные свойства и возвращает массив с ключами и их значениями .
Один из таких методов - array.length . В итоге мы можем просто написать
Let objLength = Object.getOwnPropertyNames(obj).length;
Как проверить, пуст ли объект?
- JSON.stringify(myObj) === “{}” ?. Здесь мы снова используем инструмент строкового преобразования, позволяющий легко проверить, пуст ли объект (сравнивая строки, а не объекты).
- !Object.keys(myobj).length // true ?.? Как я упоминал, конвертирование ключей объекта в массив может быть очень полезным. Здесь мы пользуемся удобным свойством length , унаследованным от Array.prototype , проверяя с его помощью длину ключей в массиве. В JS 0 превращается в false, поэтому добавляя ! мы превращаем его в true. Любые другие числа будут превращаться в false.
В заключение
Надеюсь, теперь вы чувствуете себя увереннее в создании объектов и работе с ними. Давайте подытожим:- Помните, что объекты относятся к ссылочному типу, а значит, с ними рекомендуется работать без изменения оригинальных объектов.
- Подружитесь со свойством prototype и цепочкой прототипов.
- Познакомьтесь с инструментами-помощниками в работе с объектами. Помните, что можно превращать объекты в строки, получать массив с их ключами или просто перебирать их свойства с помощью набора методов, с которым мы познакомились.
Приветствую всех, кто читает данную публикацию. Сегодня я хочу разобрать с вами ключевой инструмент языка – объекты JavaScript. Напомню, что js является кроссбраузерным и функционирует во всех ОС (windows, mac os и т.д.). В отличие от объектно-ориентированных языков программирования, в js реализация объектов значительно отличается от привычного функционала и вариаций использования экземпляров, например, в C#.
Поэтому после прочтения текущей статьи вы познаете главные отличительные черты скриптовых объектов, узнаете, какими способами их можно создать, обновить и удалить. Также я затрону тему, касающуюся свойств, методов и конструкторов, расскажу о полезных командах и конечно же немного о наследовании. Думаю, пришло время приступать к обучению!
Что из себя представляет объект в JavaScript и какими возможностями обладает?
В js объектами являются простые ассоциативные массивы (их еще также называют хэшами).
Что же такое ассоциативный массив?
Это структура данных, в которой хранится какое-то количество информации, относящееся и описывающее определенный элемент. Все данные структурированы и связаны между собой как «ключ =>значение».
К примеру, вам нужно описать автомобили. Тогда вы создаете объект avto и описываете в массиве его характеристики. Я решил описать марку машины (name), ее цвет (color) и стоимость (price). Ниже я прикрепил код реализации описанного задания.
| 1 2 3 4 5 | var avto = { name: "BMW 116i", color: "black", price: 588000 }; |
var avto = { name: "BMW 116i", color: "black", price: 588000 };
Вот вы видите один из способов создания объекта с именем «avto». Name, color и price являются ключами, по которым в ходе написания приложения можно будет обращаться.
Этим примером я забежал вперед, поэтому сейчас разберем все по порядку.
Создать объект можно несколькими способами:
var avto = {}; или var avto = new Object ();
В обоих случаях создается пустой объект с известным именем, но первым вариантом пользуются гораздо чаще, так как его короче и удобнее писать.
Все про свойства
Теперь нужно заполнить пустой объект параметрами. Для этого необходимо добавить свойства, которые также выше я называл ключами. И опять-таки существует два способа объявления свойств.
Хочу отметить, что в JavaScript нет строгих рамок по созданию и инициализации таких параметров. Новые свойства могут появляться на протяжении всего кода, точно также как удаляться и обновляться.
Таким образом, можно сразу создать все ключи или же объявлять их по мере поступления. И даже если в ходе написания программы вы обратитесь к несуществующим ключам, ошибки не будет. В этом случае вернется “undefined”.
Первый способ.
Создание и обращение к свойствам через точку. Для реализации такого варианта нужно написать имя объекта, а после через точку приписать к нему наименование ключа и далее через знак равно присвоить какое-то значение:
avto.name = “ BMW 116i”
А вот в такой способ к существующим ключам вы добавите еще один элемент:
Этот способ используется тогда, когда имя свойства уже известно и нужно проделать определенные действия со значениями.
Второй способ.
Ничем не отличается от первого, если сравнивать их предназначения. Однако этот способ обладает небольшим преимуществом. Для такого варианта используются квадратные скобки:
avto[“name”] = “ BMW 116i”
А приятным добавлением является возможность создавать наименование свойств в виде любой строки. К примеру,
avto[“name of the car”] = “ BMW 116i”
Работа с ключами через квадратные скобки используется тогда, когда какие-то параметры вводятся пользователем и хранятся в переменных или когда заранее неизвестны названия свойств. Например, пользователь запрашивает стоимость выбранного автомобиля. В переменную записывается элемент, который был вызван, а в ответ передается цена:
var avto = {}; avto.name = "BMW_116i"; avto.price = 588000; var key = "price"; // была запрошена цена машины alert(avto);
Теперь перейдем к удалению свойств. Здесь все очень просто. Для удаления используется команда delete . Так, если к последнему примеру снизу дописать вот такие 2 строки:
delete avto.price;
alert (avto);
То с вызовом alert во второй раз диалоговое окно выдаст “undefined”.
Несколько слов о компактности
На текущем этапе я вам рассказал, как создать объект и описать его свойства. К этому я прикрепил контрольные примеры, однако самые внимательные из вас, дорогие читатели, заметили, что первый программный код несколько отличается от всех остальных.
А все потому что там используется компактное представление данных. Это очень популярный метод объявления ключей, так как он короче при написании и легче воспринимается визуально.
Давайте-ка переберем наши свойства
В JavaScript можно быстро перебрать созданные свойства. Для этого был предусмотрен специальный механизм, более известный как цикл .
Если вы знакомы с другими языками программирования, то знаете, что чаще всего циклы создаются при помощи слова for , далее в круглых скобках прописывается условие перебора элементов.
В js оно напоминает своим внешним видом цикл foreach из языка C#. Ознакомьтесь с общим видом конструкции:
for (var obj in object) { // выполнение перебора}
где obj отвечает за название перечисляемых ключей,
object – за их значения.
А теперь вот вам конкретный примерчик.
| 1 2 3 4 5 6 7 8 | var avto = { name: "BMW 116i", color: "black", price: 588000 }; for (var obj in object) { alert(obj + ":" + object) } |
var avto = { name: "BMW 116i", color: "black", price: 588000 }; for (var obj in object) { alert(obj + ":" + object) }
Настало время познакомиться с методами
В скриптовом языке предусмотрено создание методов. Это абсолютно простой механизм, с помощью которого в любое время к любому объекту можно дописать метод или методы, которые расширяют возможности созданных ассоциативных массивов. Их также называют свойствами-функциями.
Js сам по себе очень динамичный и удивительный в какой-то степени. Это заключается в том, как можно создавать элементы разных типов. При изучении этого языка не нужно запоминать сложных конструкций, так как множество объявлений очень схожи между собой.
Так, для создания метода, нужно объявить объект, а после начать писать команду, точь-в-точь напоминающую создание свойств. Однако после «=» пишется уже не значение, а ключевое слово function (переменная). А далее в фигурных скобках ведется перечисление действий.
Вот реализация данного механизма:
var avto ={} avto.name = “BMV” avto.year = 1999 avto.drive = function(k) { alert(«Автомобиль проехал»+n+« км. »)} avto.drive(300) avto.drive(450)
Как видите, этот пример содержит свойства и методы, вызов которых изначально идентичен.
В JS есть еще и конструкторы?
Так точно! В этом языке все, что использует ключевое слово «new », автоматически становится конструктором. Так, выше вы видели объявление пустого объекта в виде: avto = new Object ();. Это и есть конструктор.
Для наглядности рассмотрите представленные строки ниже.
var bob = new Object ();
bob.name = «Bob Smith»;
Однако это не весь арсенал возможностей. В js можно создавать свои собственные конструкторы и после использовать их для объявления новых объектов.
Итак, я хочу «смастерить» пользовательский конструктор для уже родных автомобилей. Заметьте, что имя надо писать с большой буквы. Это отличительная черта функций. Для этого я пишу вот такую программную реализацию:
function Avto (name, price) {
this.name = name;
this.price = price;
Теперь при создании неограниченного количества объектов и применения к ним этого конструктора, все они будут относиться к одному классу. Например:
var car1 = new Avto («BMW», 650000);
var car2 = new Avto («Audi», 520000);
В добавок к этому внутри конструктора можно создавать методы.
Особенности наследования в JavaScript
Обычно во многих языках наследование основывается на классах, которые могут наследовать друг друга. Тогда можно услышать такие выражения, как «класс-предок», «дочерний класс» и т.д.
Однако в js все иначе. Здесь наследуются объекты.
Все наследование основывается на внутренней ссылке между объектами, которая известна под именем «прототип». Если к методу приписать через точку «.prototype», а далее прописать имя прототипа, то все объекты выбранного метода будут наследоваться от этого прототипа.
Перейдем к примеру.
function Transport (name) { this.name = name this.canDrive = true } var transport = new Transport ("avto") // создали объект transport function Bike (name) { this.name = name } Bike.prototype = transport // указываем, что все новые объекты этого класса будут использовать в качестве прототипа transport bike1 = new Bike ("for_sport") bike2= new Bike ("for_child") console.log(bike1.name) console.log(bike2.name) console.log(bike1.canDrive)
На этом я, пожалуй, закончу. Я рассказал вам о фундаментальных аспектах скриптового языка. Однако это только поверхностные знания. Далее будем углубляться. А пока не забывайте вступать в ряды моих подписчиков и делиться ссылкой на статью с друзьями. Удачи!
Пока-пока!
С уважением, Роман Чуешов
Прочитано: 97 раз
Объекты JavaScript
В предыдущих уроках JavaScript вы видели, что имеется несколько встроенных объектов, например String, Date, Array, и другие. В дополнение к этим встроенным объектам, вы также можете создавать свои собственные.
Объект это специальный вид данных с набором свойств и методов.
Давайте проиллюстрируем это на примере: Персона (person) - это объект. Свойства - это значения, ассоциированные с объектом. Свойства персоны включают имя, рост, вес, возраст, цвет кожи, цвет глаз, и т.д. Все персоны имеют эти свойства, но значения этих свойств будут различаться от одной персоны к другой. Объекты также имеют методы. Методы - это действия, которые могут быть выполнены над объектами. Методы персоны могут включать eat() - есть, sleep() - спать, work() - работать, play() - играть, и т.д.
Свойства
Синтаксис доступа к свойству объекта:
Код выше сгенерирует следующий вывод:
Замечание: Параметры, передаваемые методу, заключаются в курглые скобки.
Пример вызова метода sleep() объекта personObj:
альтернативный синтаксис (использование объектных литералов):
2. Создание конструктора объекта
Создаем функцию, которая инициализирует объекты:
|
function person(firstname,lastname,age,eyecolor) { this.firstname=firstname; this.lastname=lastname; this.age=age; this.eyecolor=eyecolor; } |
Внутри функции вы должны присвоить значения свойствам используя конструкцию this.ИмяСвойства. Причина такого синтаксиса в том, что вы собираетесь использовать более одного экземпляра объекта (персоны) одновременно (и должно быть понятно, с каким конкретно объектом вы имеете дело). Поэтому слово "this" указывает на конкретный - текущий объект, свойства которого вы инициализируете в конструкторе.
Как только вы написали конструктор объекта, вы можете создавать новые экземпляры объекта, например:
Заметьте, что методы - это обычные функции, прикрепленные к объектам. Далее мы должны написать тело функции newlastname().
Посещение веб-ресурса - это конкретный URI в адресной строке браузера. Посетитель указывает адрес страницы, и она разбирается браузером на элементы дерева DOM - Document Object Model. Любая ссылка на этой странице указывает браузеру разобрать другую страницу и построить иное дерево объектов.
Браузер позволяет посетителю вернуться обратно или пройти вперед по цепочке страниц, которые уже были просмотрены в текущем сеансе работы.
Фактически действия пользователя - это перемещение между системами объектов, образуемых в процессе посещения страниц. Каждая страница - это собственное дерево DOM и, помимо того, JavaScript object"s - это объекты синтаксиса самого языка и пользовательских описаний.
DOM: загрузка, обновление и изменение
Есть три основных варианта, которые формируют объекты страницы веб-ресурса, как на уровне DOM и самого языка JavaScript, выполнившего конструкции создания переменных, так и на основании описаний, сделанных разработчиком:
- загрузка - посетитель пришел на страницу сайта;
- обновление - посетитель (кнопка браузера или Ctrl-F5);
- изменение элемента страницы, например (AJAX, скрипт, событие, ...).
Все три процесса кардинально различаются, но отличать особенности первых двух особенно важно. Трудно запретить посетителю обновлять страницу - это неискоренимая «пагубная» привычка посетителя, которую разработчику следует иметь ввиду.
Навигация по странице и за её пределы должна лежать исключительно в функционале самой страницы, а не в истории посещений браузера и функциях его кнопок. Многие сайты декларируют это важное требование, но посетители традиционно его нарушают.
Изменение страницы без перезагрузки на уровне отдельного её элемента (например, AJAX) - это обычное решение для динамичных страниц. Как правило, это используется для переходов по элементам страницы, изменения её объектов, управления диалогом с посетителем.
Фундаментальные объекты JavaScript
JavaScript основан на объектах. Практически все переменные языка - это объекты. Разработчик может формулировать собственные описания объектов, используя разнообразные варианты синтаксиса.
Всё, не являющееся "строкой", "числом", true, false, null или undefined, является объектом. В рамках синтаксиса языка этому можно не придавать значения, понимая под объектами только элементы DOM и собственные описания JavaScript Object"s. Фундаментальное строение языка в большинстве случаев для разработчика не имеет существенного практического значения.
Например, математические функции представлены объектом Math. Это удобно в рамках концепции языка, но для разработчика - это просто удобный синтаксис использования необходимого арсенала математических операций.
Важно правильно работать с DOM и корректно описывать собственные объекты. Синтаксис JavaScript object function"s и выражений для их применения - это форма записи логики необходимого алгоритма.
Строки, массивы и объекты
В основе всех объектов JavaScript лежит правило: "свойство" = "значение" и понятие ассоциативного массива. В самом простом случае object JavaScript - это совокупность пар "свойство" = "значение". При этом "значение" не всегда может быть числом, а свойство не всегда записано без кавычек.
Не следует злоупотреблять именованием свойств. Идеально, когда имена свойств содержат только символы латинского алфавита, удовлетворяют требованиям к именованию переменных и не являются ключевыми (в т. ч. зарезервированными) словами языка.
Никакого упорядочивания свойств не предполагается, но при создании или инициализации ассоциативного массива знать, как расположены его элементы, вполне допустимо. Использовать это обстоятельство не рекомендуется, но иметь ввиду - возможно.
Инициализировать массив свойств означает одновременно:
- создание массива;
- создание объекта.
В конкретном контексте применения можно рассматривать JavaScript object - как ассоциативный массив, а в ином месте алгоритма - как объект, назначать ему нужные методы, изменять значения его элементов.
Поскольку имена свойств и их значения при создании или изменении должны задаваться в формате строк, рекомендуется использовать строчную нотацию и кавычки.
Доступ к свойствам объекта
Получить и изменить значения свойств объекта можно конструкцией Object.keys: JavaScript формирует массив всех свойств объекта. Когда объекты создаются динамически, эта конструкция очень удобна, поскольку автоматически формирует список всех имеющихся в объекте свойств.
В данном примере выполнено описание двух массивов различным образом. В применении оба массива эквивалентны, поскольку содержат одноименные свойства и их значения. В цикле перебираются все свойства второго массива и формируется строка всех значений.
Аналогичного эффекта можно достичь в точечной нотации или скобочной:
- x1_Obj .NameLast;
- x1_Obj ["NameFirst" ].
Обе конструкции допустимы и дают нужный результат. В приведенном примере при задании массива через фигурные скобки "{}" может быть допущена ошибка в виде символа "," в конце перечисления (отмечено в примере красным кружочком). Обычно браузеры игнорируют лишний символ в перечислении, но лучше этого не делать.
Удаление свойств объекта
Поскольку объект - это ассоциативный массив, операция JavaScript delete object выполняется на уровне текущего объекта (при наследовании - это имеет значение) и рассматривается на коллекции свойств этого объекта.
В контексте приведенного примера можно использовать такие конструкции:
- delete x1_Obj .NameLast ;
- delete x2_Obj ["NameFirst" ];
Первая конструкция удаляет второй элемент первого объекта, вторая конструкция - первый элемент второго объекта. Оператор удаления не работает на свойствах прототипа и возвращает результатом значение false, если свойство не может быть удалено.
Свойства и методы объектов
Синтаксис JavaScript object properties и functions (методы) аналогичен общим канонам синтаксиса и семантики языка. По сути, дело обстоит как раз наоборот.
Свойства и методы объекта - это вариант описания информации и допускаемых с нею действий через объектно-ориентированную парадигму JavaScript.
В данном примере описан объект x3_Obj, у которого есть только два свойства: item и pos. Затем был добавлен метод hello() в виде функции. В результате интерпретацию этого описания в контексте значений свойств, JavaScript object values сделает так, как показано в окошке результата, то есть поместит тело функции (1) в качестве значения.
При прямом вызове свойства Hello() оно интерпретируется как метод (функция) и результатом (2) будет исполнение кода этого метода.
Ключевое слово this в объекте
Для ориентации в пространстве свойств объекта разработчик может использовать ключевое слово this и ссылаться через него на описанные им свойства для получения или изменения их значений.
Это только начало описания объекта с телом только конструктора. В этом примере выполнено описание объекта для работы с куками. Объект инициализируется в момент загрузки страницы конструкцией:
- var oCookie = new scCookies (cOwnerCode );
- oCookie .Init ();
В данном примере cOwnerCode - уникальный код посетителя. Если его нет, то в конструкторе объекта oCookie будет создан новый код. Неважно, что имел ввиду под авторизацией посетителя разработчик данного объекта, важно как ключевое слово this здесь используется для описания методов объекта и их вызова из других методов объекта:
- this .GetCookie = function (cName) { ... };
- this .SetCookie = function (cName, cValue) { ... }.
Так описаны методы объекта для чтения куки по её имени и записи значения куки с конкретным именем.
- this .GetCookie ("cOwner" );
- this .SetCookie ("cOwner" , cOwner );
Так они используются, если в результате первой конструкции значения не будет представлено, то вторая конструкция его устанавливает.
Пример объекта для работы с куками
Можно обсуждать, Object"s и парадигма объектно-ориентированного подхода языка, работающего в среде браузера. Это интересно, но в реальности нужна практика, а не теория. Обслуживать DOM страницы, предоставлять инструментарий для манипулирования объектами и перемещения по системам объектов - это сильная сторона JavaScript.
На объектно-ориентированной практике важно другое. Работа с куками практически на всех веб-ресурсах в порядке вещей. Реализовать это в формате объекта - отличная идея. В этом контексте инициализация объекта происходит в момент открытия страницы: страница загружена = объект куки существует и всё прочитал, а чего не было - создал.
В процессе работы со страницей посетитель совершает те или иные действия и браузер должен изменить или создать куки. Есть два метода объекта (обозначены выше), которые это делают.
Фактически объект куки возникает сразу после того, как браузер построит DOM и дополняет систему объектов JavaScript новым функционалом: прочитать и создать (изменить) куки.
На этом простом примере рассматривается как процедура создания реальных объектов, которые имеют исключительно собственные свойства и функционал (методы). Каждый объект делает свою работу и не участвует в общем алгоритме, не меняет данные других объектов или общего пространства имен.
При таком подходе разработчик обеспечивает создание системы уникальных объектов достаточных для описания и обслуживания решаемой задачи.
События страницы и объектов
Важный элемент функционирования DOM и JavaScript: object event"s - позволяющий получить информацию о событии в его обработчике. Практически каждому элементу страницы можно назначить собственный обработчик на одно или несколько событий.
Фактически разработчик JavaScript создает не один большой «кусок» кода, а множество описаний функций, объектов, структур данных и назначает конкретным элементам страницы обработчики событий.
Object event - это информация о событии, которое вызвало обработчик и возможность выполнения этим обработчиком адекватной реакции на это событие. Каждое событие отличается не только именем и местом возникновения, но и множеством других параметров.
В частности, события клавиатуры - это один набор параметров, события мышки - совсем другой спектр данных, а ответ сервера через AJAX вовсе планирует сам разработчик.
В каждом конкретном случае картина событий, которые могут возникнуть на странице, трансформируется в спектр включенных обработчиков, за пределами предусмотренных вариантов обработки конкретного набора событий страница не предпринимает никаких действий.
Создание и работа объектов
Браузер "трансформирует" URI, адрес веб-ресурса, указанный посетителем, в дерево DOM - систему объектов страницы этого веб-ресурса. При перемещении посетителя по ссылкам страницы браузер переходит на соответствующие деревья других страниц.
Это обстоятельство позволяет разработчику построить свою систему объектов как фундамент веб-ресурса, адекватно реагирующий на поведение посетителя. Если вычленить общий функционал, например:
- работа с куками;
- прием/передача данных (AJAX);
- всплывающие подсказки;
- внутренние сообщения (чат сайта);
- другие задачи;
то, созданные однажды, системы объектов можно использовать при разработке других сайтов. В этом существенное преимущество объектного подхода перед обычным применением JavaScript, как языка браузера, обеспечивающего функционирование страницы и реакцию на события.
Объекты - это законченные компоненты, которые можно оформлять в виде отдельных файлов и использовать в дальнейшем. Характерной особенностью такого подхода, является возможность обратной связи, когда обновленный, улучшенный объект может использоваться в предшествующей разработке, автоматически обновляя её функционал без доработки сайта.
