Объекты JavaScript в примерах
Объекты являются краеугольным камнем JavaScript. Многие встроенные типы данных представлены как объекты. Чтобы быть успешным разработчиком JavaScript, нужно иметь четкое представление, как они работают. Строительные блоки объекта называются его полями или свойствами объекта JavaScript. Они применяются для описания любого аспекта объекта. Свойство может описывать длину списка, цвет неба или дату рождения человека. Создание объектов легкий процесс. Язык предоставляет синтаксис, известный как объектные литералы, которые обозначаются фигурными скобками.
Доступ к свойствам
Язык предоставляет две записи для доступа к свойствам. Первый и наиболее распространенный известен как точечное обозначение. При точечной нотации доступ к ресурсу можно получить, указав имя объекта хоста, за которым следует период и имя свойства. Например, когда object.foo изначально было присвоено значение one, тогда его значение станет 2 после выполнения оператора JavaScript объектов.
Альтернативный синтаксис для доступа известен как запись в виде скобок. В нотации за именем объекта следует набор квадратных скобок. В них имя свойства указывается как строка:
object["foo"] = object["foo"] + 1.
Она более выразительна, чем точечная нотация, поскольку позволяет переменной указывать все или часть имени свойства. Это возможно, потому что интерпретатор JavaScript объектов автоматически преобразует это выражение в строку и затем получает соответствующее свойство. Имена свойств создаются «на лету» путем конкатенации содержимого переменной f со строкой "oo":
var f = "f";
object[f + "oo"] = "bar".
Обозначение скобок позволяет именам свойств содержать символы, которые запрещены в точечной нотации. Например, следующий оператор полностью легален в скобках. Однако если пользователь попытается создать одно и то же имя свойства в точечной нотации, он столкнется с синтаксической ошибкой:
object["!@#$% &*()."] = true.
Доступ к свойствам вложенных JavaScript объектов можно получить путем связывания точек и/или скобок. Например, следующий объект содержит вложенный объект с именем baz, содержащий другой объект с именем foo, который имеет свойство с именем bar, содержащее значение пять:
var object = { baz: { foo: { bar: 5 } } }.
Следующие выражения получают доступ к вложенному свойству bar. В первом выражении используется точечная нотация, в то время как второе выражение использует квадратную нотацию. Третье выражение объединяет обе записи для достижения одного и того же результата:
- object.baz.foo.bar;
- object["baz"]["foo"]["bar"];
- object["baz"].foo["bar"].
Выражения, подобные показанным в предыдущем примере, могут привести к ухудшению производительности при неправильном использовании и вывести объект JavaScript из строя. Оценка каждого выражения точки или скобки требует времени. Если одно и то же свойство используется несколько раз, тогда имеет смысл получить доступ к свойству один раз, а затем сохранить значение в локальной переменной для всех будущих целей.
Функция, как метод
Когда функция используется как свойство объекта, она называется методом. Подобно свойствам, они указаны в нотации объектных литералов. Например:
var object = { sum: function(foo, bar) { return foo + bar; } }.
Методы JavaScript-объекта могут вызваться с использованием меток и скобок. Следующий пример вызывает sum() метод из предыдущего примера, используя обе записи:
- object.sum(1, 2);
- object["sum"](1, 2).
Обозначение литерала объекта полезно для создания новых объектов, но оно не может добавлять свойства или методы к существующим. К счастью, добавление новых данных так же просто, как создание оператора присваивания. Создается пустой объект. Затем с помощью операторов присваивания добавляются два свойства, foo, а bar, также метод baz:
- var object = {};
- object.foo = 1;
- object.bar = null;
- object.baz = function() { return "hello from baz()"; }.
Инкапсуляция программ
Основная идея объектно-ориентированного программирования состоит в том, чтобы разделить программы на более мелкие части и сделать каждую из них ответственной за управление своим собственным состоянием. Таким образом, некоторые знания о том, как работает часть программы, могут быть локальными для этой части. Кто-то, кто работает над остальной частью программы, не должен помнить или даже знать об этом. Всякий раз, когда эти локальные данные изменяются, необходимо обновлять только код непосредственно вокруг него.
Различные части такой программы взаимодействуют друг с другом через интерфейсы, ограниченные наборы функций или привязок, которые обеспечивают полезную функциональность на более абстрактном уровне, скрывая их точную реализацию. Такие части программы моделируются с использованием объектов. Их интерфейс состоит из определенного набора методов и свойств. Свойства, которые являются частью интерфейса, называются общедоступными. Остальные, которые не должны касаться внешнего кода, называются частными.
Многие языки предоставляют возможность различать публичные и частные свойства и не позволяют внешнему коду получить доступ к частным. JavaScript, опять-таки взявший минималистский подход, еще не достигнут. В настоящее время ведется работа по добавлению этого языка. Поэтому JavaScript-программисты будут успешно использовать эту идею. Как правило, доступный интерфейс описан в документации или комментариях. Также принято помещать символ подчеркивания (_) в начале имен свойств, чтобы указать, что эти свойства являются частными. Разделение интерфейса от реализации - отличная идея. Ее обычно называют инкапсуляцией.
Свойства
Объект со скобками {...} называется литералом объекта. Можно сразу поместить некоторые свойства в такие скобки {...}. Например, пары «ключ: значение и так далее»:
let user = { // an object name: "John", // by key "name" store value "John" age: 30 // by key "age" store value 30 }.
Свойство имеет ключ (также известный как «имя» или «идентификатор») перед двоеточием ":" и значение справа от него. В user-объекте есть два свойства. Результирующий user JavaScript объект с двумя подписанными файлами с надписью «имя» и «возраст». Можно добавлять, удалять и читать файлы из него в любое время. Значения свойств доступны с использованием точечной нотации. Оно может быть любого типа. Можно добавить логическое значение. Чтобы удалить свойство, используют delete в случае Error объекта JavaScript.
Все объекты ошибки JavaScript являются потомками Error объекта или унаследованным объектом:
- Syntax Error объект наследуется от Error объекта.
- JSON Parse ошибка определенного типа Syntax Error объекта.
Чтобы еще глубже погрузиться в понимание того, как приложения имеют дело с ошибками JavaScript, лучше ознакомится с Airbrake JavaScript - инструментом отслеживания ошибок для оповещений в реальном времени и мгновенным пониманием того, что пошло не так с кодом JavaScript.
Сообщения об ошибках, которые может получит пользователь перед тем как удалить JavaScript объект:
- Плохой символ управления в строковом литерале.
- Плохой символ в строковом литерале.
- Плохой выход Unicode.
- Плохой escape-символ.
- Unterminated string.
- Неожиданный не цифровой код.
- Отсутствуют цифры после десятичной точки.
- Unterminated дробное число.
- Отсутствуют цифры после индикатора степени.
- Отсутствуют цифры после знака экспонента.
- Экспоненциальная часть не имеет числа.
- Неожиданный конец данных.
- Неожиданное ключевое слово.
- Неожиданный символ.
- Конец данных при чтении содержимого объекта.
- Ожидаемое имя свойства или '}'.
Вычислительные свойства
Можно использовать квадратные скобки в объектном литерале. Это называется вычисленными свойствами. Пример приведен ниже.
Значение вычислимого свойства простое: [fruit] означает, что имя свойства должно быть взято из fruit. Итак, если посетитель входит "apple", bag станет {apple: 5}. Можно использовать более сложные выражения в квадратных скобках:
let fruit = 'apple';
let bag = {
[fruit + 'Computers']: 5 // bag.appleComputers = 5
};
Квадратные скобки намного мощнее, чем точечные обозначения. Они допускают имена и переменные свойств. Но они также более громоздки для написания. Поэтому бо́льшую часть времени, когда имена свойств известны и просты, используется точка. И если нужно что-то более сложное, то переключаются на квадратные скобки.
Резервирование слов
Переменная не может иметь имя, равное одному из зарезервированных слов, таких как «за», «пусть», «возвращать» и т. д. Но при сортировке объектов JavaScript нет такого ограничения.
В принципе, любое имя разрешено, но есть специальное: оно "__proto__" получает специальное обращение по историческим причинам. Например, нельзя установить его для значения, отличного от объекта:
let obj = {};
obj.__proto__ = 5;
alert(obj.__proto__); // [object Object], didn't work as intended
Как видно из кода, назначение примитива 5 игнорируется. Это может стать источником ошибок и даже уязвимостей, если оператор намерен хранить произвольные пары ключ-значение в объекте и разрешать посетителю указывать ключи. В этом случае посетитель может выбрать «proto» в качестве ключа и добавить в объект JavaScript. Существует способ сделать объекты обработанными __proto__ как регулярным свойством. Существует также другая карта структуры данных, которые поддерживают произвольные ключи.
Целочисленные свойства
Термин «целочисленное свойство» здесь означает строку, которая может быть преобразована из целого без изменения. Итак, например, «49» — это целочисленное имя свойства, потому что когда оно преобразуется в целое число и обратно, оно все то же. Но «+49» и «1.2» не являются таковыми. С другой стороны, если ключи не целочисленные, то они перечисляются в порядке создания. Пример ниже.
Чтобы исправить проблему с помощью телефонных кодов, можно «обмануть», сделав коды нецелыми. Добавление "+" (знака плюс) перед каждым кодом достаточно. Теперь он будет работать по назначению.
Отличие объектов от примитивов заключается в том, что они хранятся и копируются «по ссылке». Примитивные значения присваиваются и копируются «как целое значение». Переменная хранит «адрес в памяти», а не сам объект или «ссылку» на него. Можно использовать любую переменную для доступа и изменения его содержимого.
В приведенном выше примере показано, что существует только один объект и admin, чтобы войти в него. Затем, если позже будет использовать другой ключ (user), пользователь обнаружит изменения.
Операторы равенства == и строгого равенства === для объектов работают одинаково. Два объекта равны, только если они являются одним и тем же объектом. Для сравнений, подобных obj1 > obj2 или для сравнения с примитивом obj == 5, объекты преобразуются в примитивы. Честно говоря, такие сравнения необходимы очень редко и обычно являются результатом ошибки кодирования.
Проверка объекта JavaScript
Объекты имеют доступа к любому свойству. Тем не менее, если оно вообще не существует, это не будет ошибкой. Только доступ к несуществующему свойству возвращает undefined. Он предоставляет очень распространенный способ проверить свойство и сравнить с неопределенным. Ниже приведен пример.
Использование «in» для свойств, которые хранят undefined. Обычно строгая "=== undefined" проверка сравнения работает нормально. Есть особый случай, когда он терпит неудачу, а "in" работает правильно. Это когда свойство объекта существует, но сохраняет undefined.
В приведенном выше коде свойство obj.test технически существует. Поэтому in оператор работает правильно. Подобные ситуации случаются очень редко, потому что undefined обычно не назначаются. В основном используются null «неизвестные» или «пустые» значения. Таким образом, in оператор, фактически, является гостем в коде.
Цикл «for..in»
Для того, чтобы перемещаться по всем ключам от объекта к объекту, существует специальная форма цикла: for..in. Это совершенно другая вещь из for(;;) конструкции.
Ниже приведен пример.
Нужно обратить внимание, что все конструкторы «for» позволяют объявлять переменную looping внутри цикла как let key. Кроме того, вместо этого можно использовать другое имя переменной key.
Например, for(let prop in obj) также широко используется.
Существует альтернативная «квадратная скобка», которая работает с любой строкой.
При этом точка требует, чтобы ключи JavaScript-объекта был допустимым идентификатором переменной, то есть нет пробелов и других ограничений. Нужно обращать внимание, чтобы строка внутри скобок была правильно процитирована. Квадратные скобки также предоставляют способ получить имя свойства в результате любого выражения, в отличие от литеральной строки — из переменной:
let key = "likes birds";
// same as user["likes birds"] = true;
user[key] = true.
Здесь переменная key может быть рассчитана во время выполнения и зависит от пользовательского ввода, а затем будет использована для доступа к свойству. Это дает программистам большую гибкость. Точечная нотация не может использоваться аналогичным образом, так как будет перебор объекта JavaScript. Ниже приведен пример.
Объект Const
Объявленный объект const может быть изменен. Пример приведен ниже.
Может показаться, что объект JavaScript в строке (*) вызовет ошибку, но это не так. Это потому, что const фиксирует значение самого user. И здесь user хранит ссылку на один и тот же объект все время. Линия (*) идет внутри объекта, она не переназначается user. Const даст ошибку, если попытаться установить user и что-то еще. Клонирование и слияние, Object.assign создает еще одну ссылку на тот же объект, если нужно его дублировать. Это также выполнимо, но немного сложнее, потому что в JavaScript нет встроенного метода. На самом деле это необходимо редко. Копирование по ссылке применяется в большинстве случаев. Но если действительно это нужно, тогда необходимо создать JavaScript-объект и реплицировать структуру существующего, копируя его свойства на примитивном уровне. Ниже приведен пример.
И также можно использовать для этого метод Object.assign. Аргументы dest и src1, ..., srcN являются объектами. Он копирует свойства всех объектов src1, ..., srcNINTO dest. Другими словами, свойства всех аргументов, начиная со второго, копируются в 1-й. Затем он возвращается dest. Например, можно использовать его для объединения нескольких объектов в один.
И также можно использовать Object.assign для замены цикла простого клонирования. Он копирует все свойства user в пустой объект и возвращает его, так же как цикл, но короче. До сих пор предполагалось, что все свойства user примитивны. Но свойства могут быть ссылками на другие объекты.
Чтобы исправить это, нужно использовать цикл клонирования, который проверяет каждое значение user[key] и, если это объект, затем реплицирует его структуру. Это называется «глубоким клонированием».
Существует стандартный алгоритм глубокого клонирования, который обрабатывает вышеприведенный случай и более сложные случаи, называемые алгоритмом клонирования Structured. Чтобы не изобретать колесо, можно использовать рабочую реализацию из библиотеки lodash JavaScript, метод называется _.cloneDeep (obj).
Продвинутые методы
Если программист зацикливается над объектом и стремится получить все свойства в том же порядке, в каком они были добавлены, он может полагаться на «упорядочение по-особому», когда целочисленные свойства сортируются, а другие формируются в порядке создания JavaScript-объекта.
Продвинутые методы объекта имеют дело с концепциями, которые редко используются в JavaScripting. Это связано с тем, что в обычных сценариях эти мощные функции не нужны. Некоторые из этих методов могут не работать в старых браузерах, таких как ранние выпуски Netscape 4.
Использование прототипа могло быть применено для создания JavaScript-объектов и всех методов mycircle, а не только новых. Это дает смешанную нагрузку на производительность. Они не должны хранить отдельные копии методов для каждого экземпляра объекта, поэтому для работы может потребоваться меньше памяти, но для их поиска браузер должен искать текущие и родительские области. Это может привести к предельной задержке. Как правило, пользователь должен использовать то, что подходит для кода, а не основывать это решение на производительности, если только он не имеет дело с очень определенной контролируемой средой.
Возвращение true
В некоторых случаях может быть необходимо, чтобы свойство объекта было привязано к самому объекту или где-то в цепочке прототипа. В JavaScript все объекты используют метод hasOwnProperty, который возвращает true, если это свойство привязано к экземпляру отдельного объекта. В таком случае появляется возможность проверить, имеет ли конструктор объекта одно и то же свойство с тем же значением, что и сам экземпляр объекта. Это может дать неверный результат, если существуют отдельные свойства объекта JavaScript с одинаковым значением как для экземпляра объекта, так и для прототипа цепи. Метод hasOwnProperty принимает единственный параметр - имя свойства в виде строки.
Аналогичным образом можно создавать частные методы. Это просто функция, которая создается внутри функции конструктора. Кому-то это может показаться запутанным, но именно так все и работает. Частная функция может быть вызвана только самим конструктором или методами, которые определены в строке. Они могут использоваться как общедоступные методы, если назначены публичному конструктору и доступны с использованием открытых методов объектов Javascript.
function myob() { function cantBeSeen() { alert(secretValue);
} var secretValue = '';
this.method1 = function () { secretValue = 'no surprises';
cantBeSeen();
};
this.method2 = cantBeSeen;
} var oneOb = new myob();
oneOb.method1();
//alerts 'no surprises' oneOb.method2();
//alerts 'no surprises'.
Шаблон Command
Объекты Command допускают слабосвязанные системы, разделяя те, которые выдают запрос от объектов и, фактически, обрабатывают запрос. Эти запросы называются событиями, а код, обрабатывающий запросы, называется обработчиками событий.
Предположим, создаются приложения, поддерживающее действия буфера обмена Cut, Copy и Paste. Эти действия могут запускаться по-разному во всем приложении: системой меню, контекстным меню, например, щелчком правой кнопки мыши по текстовому полю или сочетанием клавиш. Объекты Command позволяют централизовать обработку этих действий, по одной для каждой операции, когда нужна только одна команда для обработки всех запросов Cut, одна для всех запросов на копирование и одна для всех запросов Paste.
Поскольку команды централизуют всю обработку, они также часто участвуют в обработке функций отмены для всего приложения. Значительные улучшения могут быть достигнуты путем применения современных методов JavaScript, приводящих к созданию более эффективных, надежных и поддерживаемых приложений.
Чтобы узнать, как это сделать, можно использовать шаблоны JavaScript + jQuery. Этот уникальный пакет включает оптимизированный JavaScript для всех шаблонов GoF с использованием более продвинутых функций, таких как пространства имен, прототипы, модули, функциональные объекты, закрытие, анонимные функции и другое. Если пользователям нужны новейшие инструменты и методы для шаблонов JavaScript, шаблонов jQuery и архитектур шаблонов, тогда это лучший вариант использования. Этот пакет содержит ценную, актуальную информацию для разработчиков JavaScript. Вот что в него включено:
- JavaScript-оптимизированные шаблоны GoF.
- Современные шаблоны проектирования JavaScript.
- Шаблоны проектирования Model-View.
- Шаблоны дизайна jQuery.
- Архитектурные шаблоны JavaScript-идиомы.
- Примеры приложений (MVC, SPA и т. д.)
Предложенные основы синтаксиса объектов JavaScript очень важны для начинающих программистов. Нужно сначала понять объекты, тогда будет знание объектно-ориентированного программирования. Крайне важно иметь глубокое понимание этого материала, поскольку это служит основой для остальной части языка JavaScript.