Объекты в JavaScript
Объект в JavaScript – это тип данных, который состоит из пар «ключ:значение». Такие пары иногда состоят из свойств (которые могут содержать любой тип данных, включая строки, числа и логические данные) или методов, которые являются функциями, содержащимися внутри объекта.
Объекты в JavaScript – это автономные элементы, которые можно сравнить с объектами в реальной жизни. Например, книга – это объект, для описания которого можно использовать название, имя автора, количество страниц, жанр и т.п. Точно так же автомобиль можно описать по цвету, модели и мощности. Массивы JavaScript также являются объектами.
Читайте также:
Объекты являются неотъемлемым и основополагающим аспектом большинства программ JavaScript. Например, объект учетной записи пользователя может содержать такие данные, как имена пользователей, пароли и адреса электронной почты. Другим распространенным вариантом использования объектов в JavaScript является корзина для покупок веб-магазина; она может состоять из массива объектов, содержащих всю соответствующую информацию для каждого элемента: название товара, цена, вес, информация о доставке.
Данный мануал научит вас создавать объекты, а также работать со свойствами и методами объектов: добавлять, удалять, извлекать и итерировать их.
Создание объекта
Объект в JavaScript – это отдельный тип данных. Как и любой другой тип данных, объект можно присвоить переменной.
В JavaScript есть два метода создания объектов:
Для примера попробуйте создать пустой объект с помощью этих методов. Сначала попробуйте создать объект через объектный литерал:
// Initialize object literal with curly brackets
const objectLiteral = <>;
Объектный литерал инициализирует объект фигурными скобками.
Теперь используйте конструктор объекта.
// Initialize object constructor with new Object
const objectConstructor = new Object();
Конструктор объектов инициализирует новый объект с помощью new Object().
Оба этих метода создают пустой объект. Объектные литералы – более распространенный и предпочтительный метод, поскольку он реже приводит к несоответствиям данных и неожиданным результатам.
Для примера создайте в переменной gimli объект, описывающий персонажа:
Объект gimli имеет три свойства. Каждое свойство представлено в виде пары «ключ:значение». К примеру, ключу weapon соответствует значение axe. Также в объекте есть один метод – greet, значение которого представлено содержимым функции.
В методе greet вы можете заметить ключевое слово this. При использовании слова this внутри объекта оно ссылается на текущий объект, в данном случае на gimli.
Введите gimli в консоль, и это выведет весь объект:
Этот вывод может отображаться по-разному в зависимости от того, какую консоль вы используете, но вы должны обратить внимание на то, что все значения, переданные объекту, отображаются на выходе.
Свойства и методы объектов
У объектов могут быть свойства и методы.
Свойство – это связь между именем (ключом) и значением в объекте. Свойство может содержать любой тип данных. Обычно свойство относится к характеристике объекта.
Метод – это функция, которая является значением свойства объекта и, следовательно, задачей, которую может выполнять объект.
Чтобы быстро понять разницу между свойствами и методами объекта, запомните: свойства выражаются именами существительными, а методы – глаголами. В предыдущем примере использовались свойства name, race и weapon – все они выражены существительными. А, например, fight() или talk() – это глаголы, которые могут использоваться как определение функции метода.
Доступ к свойствам объекта
Доступ к свойствам объекта можно получить двумя способами:
Вернемся к объекту gimli:
Чтобы извлечь значение свойства weapon, можно использовать точечную нотацию. Для этого введите имя переменной объекта, затем точку и свойство или метод.
// Retrieve the value of the weapon property
gimli.weapon;
«axe»
Нотация gimli.weapon выводит искомое значение. Также эти данные можно извлечь с помощью скобочной нотации. Этот метод работает аналогично индексации и извлечению строк: чтобы извлечь значение, поместите ключ в квадратные скобки.
// Retrieve the value of the weapon property
gimli[«weapon»];
«axe»
Методы точечной и скобочной нотации используются регулярно. Точечная нотация – более быстрый и удобочитаемый метод, но он имеет больше ограничений. Скобочная нотация позволяет получить доступ к именам свойств, хранящимся в переменной; этот метод необходимо использовать, если свойство объекта содержит какой-либо специальный символ.
Чтобы извлечь метод объекта, вызовите его так же, как обычную функцию, просто привязанную к переменной объекта.
gimli.greet();
“Hi, my name is Gimli!”
В приведенном выше примере показано, что при вызове метода greet() возвращается его строковое значение.
Теперь можно попробовать изменить объект.
Добавление и изменение свойств объекта
Чтобы добавить новое свойство в объект, присвойте новое значение с помощью оператора =.
Например, можно добавить в объект gimli новое свойство age, которое будет содержать числовой тип. Для добавления нового свойства объекта можно использовать точечную и скобочную нотацию.
// Add new age property to gimli
gimli.age = 139;
// Add new age property to gimli
gimli[«age»] = 139;
Извлечь значение можно также через точечную и скобочную нотацию:
Таким же образом можно добавить в объект новый метод:
Создав новый метод объекта, можно вызвать его:
gimli.fight();
«Gimli attacks with an axe.»
Также можно изменить свойство объекта, присвоив новое значение существующему свойству.
// Update weapon from axe to battle axe
gimli.weapon = «battle axe»;
Чтобы просмотреть все свойства и методы объекта, введите:
Оператор присваивания позволяет добавлять и изменять свойства и методы объектов.
Удаление свойств из объекта
Чтобы удалить свойство, используйте ключевое слово delete.
К примеру, попробуйте удалить свойство weapon из объекта gimli:
// Remove weapon from gimli
delete gimli.weapon;
true
Если свойство было успешно удалено или указанного свойства не существует в объекте, операция оценивается как true.
Убедитесь, что свойство удалено:
Теперь попробуйте итерировать свойства объекта.
Итерация свойств объекта
JavaScript предоставляет встроенный тип цикла for, который специально предназначен для итерации свойств объекта. Этот цикл называется for…in.
Ниже приведена упрощенная версия объекта gimli.
const gimli = <
name: «Gimli»,
race: «dwarf»,
weapon: «battle axe»,
>;
С помощью for…in можно перебрать все свойства gimli и вывести их в консоль. Через скобочную нотацию можно получить значение свойства в качестве переменной, в данном случае key.
// Iterate through properties of gimli
for (let key in gimli) <
console.log(gimliЧто такое объект в javascript);
>
Gimli
dwarf
battle axe
Можно также извлечь сам ключ свойства. С помощью строкового метода можно преобразовать ключи в верхний регистр:
// Get keys and values of gimli properties
for (let key in gimli) <
console.log(key.toUpperCase() + ‘:’, gimliЧто такое объект в javascript);
>
NAME: Gimli
RACE: dwarf
WEAPON: battle axe
Цикл for…in не следует путать с циклом for…of, который используется исключительно для типа объекта Array.
Метод Object.keys() возвращает массив ключей объекта:
// Initialize method on gimli object to return property keys
Object.keys(gimli);
[«name», «race», «weapon»]
Этот метод позволяет работать с ключами объекта в виде массива.
Заключение
Объекты – чрезвычайно полезная часть языка программирования JavaScript. Это один из основных методов написания кода в JavaScript, который позволяет удобным образом организовать связанные данные. Списки дел, корзины покупок, учетные записи пользователей и местоположения на веб-карте – вот лишь несколько примеров объектов JavaScript.
Теперь вы знаете разницу между свойствами и методами объектов, а также умеете добавлять, удалять, изменять и итерировать свойства. Больше об объектах в JavaScript можно узнать здесь.
Объекты
Объект является неупорядоченной коллекцией свойств, каждое из которых имеет имя и значение. Имена свойств являются строками, поэтому можно сказать, что объекты отображают строки в значения. Такое отображение строк в значения может называться по-разному: возможно, вы уже знакомы с такой фундаментальной структурой данных, как «хеш», «словарь» или «ассоциативный массив». Однако объект представляет собой нечто большее, чем простое отображение строк в значения.
Любое значение в языке JavaScript, не являющееся строкой, числом, true, false, null или undefined, является объектом. И даже строки, числа и логические значения, не являющиеся объектами, могут вести себя как неизменяемые объекты (имеют объекты-обертки String, Number и т.п.).
Свойство имеет имя и значение. Именем свойства может быть любая строка, включая и пустую строку, но объект не может иметь два свойства с одинаковыми именами. Значением свойства может быть любое значение, допустимое в языке JavaScript, или (в ECMAScript 5) функция чтения или записи (или обе).
В дополнение к именам и значениям каждое свойство имеет ряд ассоциированных с ним значений, которые называют :
Атрибут writable определяет доступность значения свойства для записи.
Атрибут enumerable определяет доступность имени свойства для перечисления в цикле for/in.
Атрибут configurable определяет возможность настройки, т.е. удаления свойства и изменения его атрибутов.
До появления стандарта ECMAScript 5 все свойства в объектах, создаваемые программой, доступны для записи, перечисления и настройки. В ECMAScript 5 предусматривается возможность настройки атрибутов ваших свойств.
В дополнение к свойствам каждый объект имеет три :
Атрибут prototype содержит ссылку на другой объект, от которого наследуются свойства.
Атрибут class содержит строку с именем класса объекта и определяет тип объекта.
Флаг extensible (в ECMAScript 5) указывает на возможность добавления новых свойств в объект.
Наконец, ниже приводится описание некоторых терминов, которые помогут нам различать три обширные категории объектов в языке JavaScript и два типа свойств:
Объект базового языка
Это объект или класс объектов, определяемый спецификацией ECMAScript. Массивы, функции, даты и регулярные выражения (например) являются объектами базового языка.
Объект среды выполнения
Это объект, определяемый средой выполнения (такой как веб-браузер), куда встроен интерпретатор JavaScript. Объекты HTMLElement, представляющие структуру веб-страницы в клиентском JavaScript, являются объектами среды выполнения. Объекты среды выполнения могут также быть объектами базового языка, например, когда среда выполнения определяет методы, которые являются обычными объектами Function базового языка JavaScript.
Пользовательский объект
Любой объект, созданный в результате выполнения программного кода JavaScript.
Собственное свойство
Это свойство, определяемое непосредственно в данном объекте.
Унаследованное свойство
Это свойство, определяемое прототипом объекта.
Создание объектов
Объекты можно создавать с помощью литералов объектов, ключевого слова new и (в ECMAScript 5) функции Object.create().
Литералы объектов
Ниже приводится несколько примеров создания объектов:
В ECMAScript 5 (и в некоторых реализациях ECMAScript 3) допускается использовать зарезервированные слова в качестве имен свойств без кавычек. Однако в целом имена свойств, совпадающие с зарезервированными словами, в ECMA-Script 3 должны заключаться в кавычки. В ECMAScript 5 последняя запятая, следующая за последним свойством в литерале объекта, игнорируется. В большинстве реализаций ECMAScript 3 завершающие запятые также игнорируются, но IE интерпретирует их наличие как ошибку.
Создание объектов с помощью оператора new
Оператор new создает и инициализирует новый объект. За этим оператором должно следовать имя функции. Функция, используемая таким способом, называется и служит для инициализации вновь созданного объекта. Базовый JavaScript включает множество встроенных конструкторов для создания объектов базового языка. Например:
Помимо этих встроенных конструкторов имеется возможность определять свои собственные функции-конструкторы для инициализации вновь создаваемых объектов. О том, как это делается, рассказывается в следующей статье.
Object.create()
Стандарт ECMAScript 5 определяет метод Object.create(), который создает новый объект и использует свой первый аргумент в качестве прототипа этого объекта. Дополнительно Object.create() может принимать второй необязательный аргумент, описывающий свойства нового объекта.
Object.create() является статической функцией, а не методом, вызываемым относительно некоторого конкретного объекта. Чтобы вызвать эту функцию, достаточно передать ей желаемый объект-прототип:
Чтобы создать объект, не имеющий прототипа, можно передать значение null, но в этом случае вновь созданный объект не унаследует ни каких-либо свойств, ни базовых методов, таких как toString() (а это означает, что этот объект нельзя будет использовать в выражениях с оператором +):
Если в программе потребуется создать обычный пустой объект (который, например, возвращается литералом <> или выражением new Object()), передайте в первом аргументе Object.prototype:
Возможность создавать новые объекты с произвольными прототипами (скажем иначе: возможность создавать «наследников» от любых объектов) является мощным инструментом, действие которого можно имитировать в ECMAScript 3 с помощью функции, представленной в примере ниже:
Реализация функции inherit() приобретет больше смысла, как только мы познакомимся с конструкторами в следующей статье. А пока просто считайте, что она возвращает новый объект, наследующий свойства объекта в аргументе. Обратите внимание, что функция inherit() не является полноценной заменой для Object.create(): она не позволяет создавать объекты без прототипа и не принимает второй необязательный аргумент, как Object.create().
Получение и изменение свойств
Получить значение свойства можно с помощью операторов точки (.) и квадратных скобок ([]). Слева от оператора должно находиться выражение, возвращающее объект. При использовании оператора точки справа должен находиться простой идентификатор, соответствующий имени свойства. При использовании квадратных скобок в квадратных скобках должно указываться выражение, возвращающее строку, содержащую имя требуемого свойства:
Чтобы создать новое свойство или изменить значение существующего свойства, также используются операторы точки и квадратные скобки, как в операциях чтения значений свойств, но само выражение помещается уже слева от оператора присваивания:
Если объект имеет свойства, имена которых совпадают с зарезервированными словами, для доступа к ним необходимо использовать форму записи с квадратными скобками: o[«for»] и o[«class»]. Стандарт ECMAScript 5 ослабляет это требование (как это уже сделано в некоторых реализациях ECMAScript 3) и допускает возможность использования зарезервированных слов после оператора точки.
Прототипы
Объекты, созданные с помощью ключевого слова new и вызова конструктора, в качестве прототипа получают значение свойства prototype функции-конструктора. Поэтому объект, созданный выражением new Object(), наследует свойства объекта Object.prototype, как если бы он был создан с помощью литерала в фигурных скобках <>. Аналогично прототипом объекта, созданного выражением new Array(), является Array.prototype, а прототипом объекта, созданного выражением new Date(), является Date.prototype.
Наследование
Объекты в языке JavaScript обладают множеством «собственных свойств» и могут также наследовать множество свойств от объекта-прототипа. Чтобы разобраться в этом, необходимо внимательно изучить механизм доступа к свойствам. В примерах этого раздела для создания объектов с определенными прототипами используется функция inherit(), показанная выше.
Предположим, что программа обращается к свойству x объекта obj. Если объект obj не имеет собственного свойства с таким именем, выполняется попытка отыскать свойство x в прототипе объекта obj. Если объект-прототип не имеет собственного свойства с этим именем, но имеет свой прототип, выполняется попытка отыскать свойство в прототипе прототипа. Так продолжается до тех пор, пока не будет найдено свойство x или пока не будет достигнут объект, не имеющий прототипа. Как видите, атрибут prototype объекта создает цепочку, или связанный список объектов, от которых наследуются свойства.
Теперь предположим, что программа присваивает некоторое значение свойству x объекта obj. Если объект obj уже имеет собственное свойство (не унаследованное) с именем x, то операция присваивания просто изменит значение существующего свойства. В противном случае в объекте obj будет создано новое свойство с именем x. Если прежде объект obj наследовал свойство x, унаследованное свойство теперь окажется скрыто вновь созданным собственным свойством с тем же именем.
Существует одно исключение из этого правила, когда операция присваивания значения свойству терпит неудачу или приводит к созданию/изменению свойства оригинального объекта. Если объект obj наследует свойство x и доступ к этому свойству осуществляется посредством методов доступа, то вместо создания нового свойства x в объекте obj производится вызов метода записи нового значения. Однако обратите внимание, что метод записи вызывается относительно объекта obj, а не относительно прототипа, в котором определено это свойство, поэтому, если метод записи определяет какие-либо свойства, они будут созданы в объекте obj, а цепочка прототипов опять останется неизменной.
Ошибки доступа к свойствам
Выражения обращения к свойствам не всегда возвращают или изменяют значение свойства. В этом разделе описываются ситуации, когда операции чтения или записи свойства терпят неудачу.
Попытка обращения к несуществующему свойству не считается ошибкой. Если свойство x не будет найдено среди собственных или унаследованных свойств объекта obj, выражение обращения к свойству obj.x вернет значение undefined.
Однако попытка обратиться к свойству несуществующего объекта считается ошибкой. Значения null и undefined не имеют свойств, и попытки обратиться к свойствам этих значений считаются ошибкой:
Если нет уверенности, что user и user.password являются объектами (или ведут себя подобно объектам), нельзя использовать выражение user.password.length, так как оно может возбудить исключение. Ниже демонстрируются два способа защиты против исключений подобного рода:
Попытки установить значение свойства для других значений не всегда оканчиваются успехом: некоторые свойства доступны только для чтения и не позволяют изменять их значения. Кроме того, некоторые объекты не позволяют добавлять в них новые свойства. Однако самое интересное, что подобные неудачи, как правило, не приводят к возбуждению исключения:
Этот исторически сложившийся недостаток JavaScript исправлен в строгом режиме, определяемом стандартом ECMAScript 5. Все неудачные попытки изменить значение свойства в строгом режиме приводят к исключению TypeError.
Правила, позволяющие определить, когда попытка выполнить операцию присваивания завершится успехом, а когда неудачей, просты и понятны, но их сложно выразить в достаточно краткой форме. Попытка присвоить значение свойству p объекта obj потерпит неудачу в следующих случаях:
Объект obj имеет собственное свойство p, доступное только для чтения: нельзя изменить значение свойства, доступного только для чтения. (Обратите, однако, внимание на метод defineProperty(), который представляет собой исключение, позволяющее изменять значения настраиваемых свойств, доступных только для чтения.)
Объект obj имеет унаследованное свойство p, доступное только для чтения: унаследованные свойства, доступные только для чтения, невозможно переопределить собственными свойствами с теми же именами.
Объект obj не имеет собственного свойства p; объект obj не наследует свойство p с методами доступа и атрибут extensible объекта obj имеет значение false. Если свойство p отсутствует в объекте obj и для него не определен метод записи, то операция присваивания попытается добавить свойство p в объект obj. Но поскольку объект obj не допускает возможность расширения, то попытка добавить в него новое свойство потерпит неудачу.
Удаление свойств
Оператор delete удаляет только собственные свойства и не удаляет унаследованные. (Чтобы удалить унаследованное свойство, необходимо удалять его в объекте-прототипе, в котором оно определено. Такая операция затронет все объекты, наследующие этот прототип.)
Выражение delete возвращает значение true в случае успешного удаления свойства или когда операция удаления не привела к изменению объекта (например, при попытке удалить несуществующее свойство). Выражение delete также возвращает true, когда этому оператору передается выражение, не являющееся выражением обращения к свойству:
Оператор delete не удаляет ненастраиваемые свойства, атрибут configurable которых имеет значение false. (Однако он может удалять настраиваемые свойства нерасширяемых объектов.) Ненастраиваемыми являются свойства встроенных объектов, а также свойства глобального объекта, созданные с помощью инструкций объявления переменных и функций. Попытка удалить ненастраиваемое свойство в строгом режиме вызывает исключение TypeError. В нестрогом режиме (и в реализациях ECMAScript 3) в таких случаях оператор delete просто возвращает false:
Проверка существования свойств
Оператор in требует, чтобы в левом операнде ему было передано имя свойства (в виде строки) и объект в правом операнде. Он возвращает true, если объект имеет собственное или унаследованное свойство с этим именем:
Метод hasOwnProperty() объекта проверяет, имеет ли объект собственное свойство с указанным именем. Для наследуемых свойств он возвращает false:
Метод propertyIsEnumerable() накладывает дополнительные ограничения по сравнению с hasOwnProperty(). Он возвращает true, только если указанное свойство является собственным свойством, атрибут enumerable которого имеет значение true. Свойства встроенных объектов не являются перечислимыми. Свойства, созданные обычной программой на языке JavaScript, являются перечислимыми, если не был использован один из методов ECMAScript 5, представленных ниже, которые делают свойства неперечислимыми.
Однако оператор in отличает ситуации, которые неотличимы при использовании представленного выше приема на основе обращения к свойству. Оператор in отличает отсутствие свойства от свойства, имеющего значение undefined.
Перечисление свойств
Вместо проверки наличия отдельных свойств иногда бывает необходимо обойти все имеющиеся свойства или получить список всех свойств объекта. Обычно для этого используется цикл for/in, однако стандарт ECMAScript 5 предоставляет две удобные альтернативы.
Инструкция цикла for/in выполняет тело цикла для каждого перечислимого свойства (собственного или унаследованного) указанного объекта, присваивая имя свойства переменной цикла. Встроенные методы, наследуемые объектами, являются неперечислимыми, а свойства, добавляемые в объекты вашей программой, являются перечислимыми (если только не использовались функции, описываемые ниже, позволяющие сделать свойства неперечислимыми). Например:
Некоторые библиотеки добавляют новые методы (или другие свойства) в объект Object.prototype, чтобы они могли быть унаследованы и быть доступны всем объектам. Однако до появления стандарта ECMAScript 5 отсутствовала возможность сделать эти дополнительные методы неперечислимыми, поэтому они оказывались доступными для перечисления в циклах for/in. Чтобы решить эту проблему, может потребоваться фильтровать свойства, возвращаемые циклом for/in. Ниже приводятся два примера реализации такой фильтрации:
В дополнение к циклу for/in стандарт ECMAScript 5 определяет две функции, перечисляющие имена свойств. Первая из них, Object.keys(), возвращает массив имен собственных перечислимых свойств объекта.
Методы чтения и записи свойств
Когда программа пытается получить значение свойства с методами доступа, интерпретатор вызывает метод чтения (без аргументов). Возвращаемое этим методом значение становится значением выражения обращения к свойству. Когда программа пытается записать значение в свойство, интерпретатор вызывает метод записи, передавая ему значение, находящее справа от оператора присваивания. Этот метод отвечает за «установку» значения свойства. Значение, возвращаемое методом записи, игнорируется.
В отличие от свойств с данными, свойства с методами доступа не имеют атрибута writable. Если свойство имеет оба метода, чтения и записи, оно доступно для чтения/записи. Если свойство имеет только метод чтения, оно доступно только для чтения. А если свойство имеет только метод записи, оно доступно только для записи (такое невозможно для свойств с данными) и попытки прочитать значение такого свойства всегда будут возвращать undefined.
Самый простой способ определить свойство с методами доступа заключается в использовании расширенного синтаксиса определения литералов объектов:
Свойства с методами доступа определяются как одна или две функции, имена которых совпадают с именем свойства и с заменой ключевого слова function на get и/или set.
Обратите внимание, что не требуется использовать двоеточие для отделения имени свойства от функции, управляющей доступом к свойству, но по-прежнему необходимо использовать запятую после тела функции, чтобы отделить метод от других методов или свойств с данными.
Для примера рассмотрим следующий объект, представляющий декартовы координаты точки на плоскости. Для представления координат X и Y в нем имеются обычные свойства с данными, а также свойства с методами доступа, позволяющие получить эквивалентные полярные координаты точки:
Обратите внимание на использование ключевого слова this в методах чтения и записи выше. Интерпретатор будет вызывать эти функции, как методы объекта, в котором они определены, т.е. в теле функции this будет ссылаться на объект точки. Благодаря этому метод чтения свойства r может ссылаться на свойства x и y, как this.x и this.y.
Свойства с методами доступа наследуются так же, как обычные свойства с данными, поэтому объект p, определенный выше, можно использовать как прототип для других объектов точек. В новых объектах можно определять собственные свойства x и y, и они будут наследовать свойства r и theta.
Атрибуты объекта
Все объекты имеют атрибуты prototype, class и extensible. Все эти атрибуты описываются в подразделах ниже.
Атрибут prototype
Атрибут prototype объекта определяет объект, от которого наследуются свойства. Важно понимать, что когда в программном коде встречается ссылка prototype, она обозначает обычное свойство объекта, а не атрибут prototype.
Атрибут prototype устанавливается в момент создания объекта. Для объектов, созданных с помощью литералов, прототипом является Object.prototype. Прототипом объекта, созданного с помощью оператора new, является значение свойства prototype конструктора. А прототипом объекта, созданного с помощью Object.create(), становится первый аргумент этой функции (который может иметь значение null).
Стандартом ECMAScript 5 предусматривается возможность определить прототип любого объекта, если передать его методу Object.getPrototypeOf(). В ECMAScript 3 отсутствует эквивалентная функция, но зачастую определить прототип объекта obj можно с помощью выражения obj.constructor.prototype.
Объекты, созданные с помощью оператора new, обычно наследуют свойство constructor, ссылающееся на функцию-конструктор, использованную для создания объекта. И как уже говорилось выше, функции-конструкторы имеют свойство prototype, которое определяет прототип объектов, созданных с помощью этого конструктора.
Обратите внимание, что объекты, созданные с помощью литералов объектов или Object.create(), получают свойство constructor, ссылающееся на конструктор Object(). Таким образом, constructor.prototype ссылается на истинный прототип для литералов объектов, но обычно это не так для объектов, созданных вызовом Object.create().
Чтобы определить, является ли один объект прототипом (или звеном в цепочке прототипов) другого объекта, следует использовать метод isPrototypeOf(). Чтобы узнать, является ли p прототипом obj, нужно записать выражение p.isPrototypeOf(obj). Например:
Атрибут class
Поэтому, чтобы определить класс объекта, можно попробовать вызвать метод toString() этого объекта и извлечь из результата подстроку с восьмого по предпоследний символ. Вся хитрость состоит в том, что многие методы наследуют другие, более полезные реализации метода toString(), и чтобы вызвать нужную версию toString(), необходимо выполнить косвенный вызов с помощью метода Function.call().
В примере ниже определяется функция, возвращающая класс любого объекта, переданного ей:
Этой функции classof() можно передать любое значение, допустимое в языке JavaScript. Числа, строки и логические значения действуют подобно объектам, когда относительно них вызывается метод toString(), а значения null и undefined обрабатываются особо.
Атрибут extensible
Атрибут extensible объекта определяет, допускается ли добавлять в объект новые свойства. В ECMAScript 3 все встроенные и определяемые пользователем объекты неявно допускали возможность расширения, а расширяемость объектов среды выполнения определялась каждой конкретной реализацией. В ECMAScript 5 все встроенные и определяемые пользователем объекты являются расширяемыми, если они не были преобразованы в нерасширяемые объекты, а расширяемость объектов среды выполнения по-прежнему определяется каждой конкретной реализацией.
Стандарт ECMAScript 5 определяет функции для получения и изменения признака расширяемости объекта. Чтобы определить, допускается ли расширять объект, его следует передать методу Object.isExtensible(). Чтобы сделать объект нерасширяемым, его нужно передать методу Object.preventExtensions(). Обратите внимание, что после того как объект будет сделан нерасширяемым, его нельзя снова сделать расширяемым. Отметьте также, что вызов preventExtensions() оказывает влияние только на расширяемость самого объекта. Если новые свойства добавить в прототип нерасширяемого объекта, нерасширяемый объект унаследует эти новые свойства.
Назначение атрибута extensible заключается в том, чтобы дать возможность «фиксировать» объекты в определенном состоянии, запретив внесение изменений. Атрибут объектов extensible часто используется совместно с атрибутами свойств configurable и writable, поэтому в ECMAScript 5 определяются функции, упрощающие одновременную установку этих атрибутов.