В JavaScript объекты являются королями: почти все является объектом или действует как объект. Разберитесь с объектами, и вы поймете JavaScript. Итак, давайте рассмотрим создание объектов в JavaScript.
Объект — это просто контейнер для коллекции именованных значений (или свойств). Прежде чем мы рассмотрим любой код JavaScript, давайте сначала рассмотрим это. Возьми себя, например. Используя простой язык, мы можем выразить в таблице «коди»:
| Свойство | Стоимость имущества |
| живой | Правда |
| возраст | 33 |
| Пол | мужчина |
Слово «cody» в таблице — это просто метка для группы имен свойств и соответствующих значений, которые составляют именно то, чем является cody. Как видно из таблицы, я живу, мне 33 года, и я мужчина.
JavaScript, однако, не говорит в таблицах. Он говорит в объектах, которые похожи на части, содержащиеся в таблице «cody». Перевод таблицы cody в реальный объект JavaScript будет выглядеть следующим образом:
Образец: sample1.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
<!DOCTYPE html><html lang=»en»><body><script>
// Create the cody object
var cody = new Object();
// then fill the cody object with properties (using dot notation).
cody.living = true;
cody.age = 33;
cody.gender = ‘male’;
console.log(cody);
</script></body></html>
|
Имейте это в виду: объекты — это просто контейнеры для свойств, каждый из которых имеет имя и значение. Это понятие контейнера свойств с именованными значениями (т. Е. Объекта) используется JavaScript в качестве строительных блоков для выражения значений в JavaScript. Объект cody — это значение, которое я выразил как объект JavaScript, создав объект, присвоив объекту имя, а затем присвоив объекту свойства.
До этого момента обсуждаемый нами объект cody имеет только статическую информацию. Поскольку мы имеем дело с языком программирования, мы хотим запрограммировать наш объект cody, чтобы он действительно что-то делал. В противном случае все, что у нас есть, — это база данных, похожая на JSON . Чтобы оживить объект cody, мне нужно добавить метод свойства. Методы свойства выполняют функцию. Точнее говоря , в JavaScript методы — это свойства, которые содержат объект Function() целью которого является работа с объектом, в котором содержится функция.
Если бы я обновил таблицу cody методом getGender, на простом английском языке это выглядело бы так:
| Свойство | Стоимость имущества |
| живой | Правда |
| возраст | 33 |
| Пол | мужчина |
| getGender | вернуть значение пола |
Используя JavaScript, метод getGender из обновленной таблицы Cody будет выглядеть так:
Образец: sample2.html
|
01
02
03
04
05
06
07
08
09
10
11
|
<!DOCTYPE html><html lang=»en»><body><script>
var cody = new Object();
cody.living = true;
cody.age = 33;
cody.gender = ‘male’;
cody.getGender = function () { return cody.gender;
console.log(cody.getGender());
</script></body></html>
|
Метод getGender , свойство объекта cody, используется для возврата одного из других значений свойства cody: значения «male», хранящегося в свойстве пола. Вы должны понимать, что без методов наш объект не будет делать ничего, кроме хранения статических свойств.
Коди-объект, который мы обсуждали до сих пор, называется объектом Object() . Мы создали объект cody, используя пустой объект, предоставленный нам, вызвав функцию конструктора Object() . Думайте о функциях конструктора как об шаблоне или обрезке печенья для создания предопределенных объектов. В случае объекта cody я использовал функцию конструктора Object() для создания пустого объекта, который я назвал cody. Поскольку cody — это объект, созданный из конструктора Object() , мы называем cody объектом Object() . Помимо создания простого Object() такого как cody, вам действительно нужно понять, что большинство значений, выраженных в JavaScript, являются объектами (примитивные значения, такие как «foo», 5 и true, являются исключением, но имеют эквивалентную оболочку объекты).
Учтите, что объект cody, созданный с помощью функции конструктора Object() самом деле не отличается от строкового объекта, созданного с помощью функции конструктора String() . Чтобы понять этот факт, рассмотрите и сопоставьте следующий код:
Образец: sample3.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
|
<!DOCTYPE html><html lang=»en»><body><script>
var myObject = new Object();
myObject[‘0’] = ‘f’;
myObject[‘1’] = ‘o’;
myObject[‘2’] = ‘o’;
console.log(myObject);
var myString = new String(‘foo’);
console.log(myString);
</script></body></html>
|
Как оказалось, myObject и myString оба. , , объекты! Они оба могут иметь свойства, наследовать свойства и созданы из функции конструктора. Переменная myString, содержащая строковое значение ‘foo’, кажется простой, но удивительно, что у нее есть структура объекта под ее поверхностью. Если вы изучите оба произведенных объекта, вы увидите, что они являются идентичными объектами по существу, но не по типу. Более того, я надеюсь, вы начнете видеть, что JavaScript использует объекты для выражения значений.
Вы можете счесть странным видеть строковое значение ‘foo’ в форме объекта, потому что обычно строка представляется в JavaScript как примитивное значение (например, var myString = 'foo'; ). Я специально использовал здесь строковое значение объекта, чтобы подчеркнуть, что объект может быть чем угодно, включая значения, которые мы обычно не воспринимаем как объект (например, строка, число, логическое значение). Кроме того, я думаю, что это помогает объяснить, почему некоторые говорят, что все в JavaScript может быть объектом.
JavaScript превращает функции конструктора String() и Object() в сам язык, чтобы сделать создание объекта String() и Object() тривиальным. Но вы, как программист языка JavaScript, также можете создавать не менее мощные функции конструктора. В следующем примере я продемонстрирую это путем определения нестандартной пользовательской функции конструктора Person() чтобы я мог создавать людей из нее.
Образец: sample4.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
<!DOCTYPE html><html lang=»en»><body><script>
// Define Person constructor function in order to create custom Person() objects later.
var Person = function (living, age, gender) {
this.living = living;
this.age = age;
this.gender = gender;
this.getGender = function () { return this.gender;
};
// Instantiate a Person object and store it in the cody variable.
var cody = new Person(true, 33, ‘male’);
console.log(cody);
/* The String() constructor function that follows, having been defined by JavaScript, has the same pattern.
// Instantiate a String object stored in the myString variable.
var myString = new String(‘foo’);
console.log(myString);
</script></body></html>
|
Пользовательская функция конструктора Person() может создавать объекты Person, так же как собственная функция конструктора String() может создавать строковые объекты. Конструктор Person() не менее способен и не более или менее податлив, чем собственный конструктор String() или любой из собственных конструкторов, найденных в JavaScript.
Вспомните, как объект cody, на который мы впервые посмотрели, был создан из Object() . Важно отметить, что функция конструктора Object() и новый конструктор Person() показанные в предыдущем примере кода, могут дать нам одинаковые результаты. Оба могут создавать идентичный объект с одинаковыми свойствами и методами свойств. Изучите два следующих раздела кода, чтобы показать, что codyA и codyB имеют одинаковые значения объектов, даже если они создаются разными способами.
Образец: sample5.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
<!DOCTYPE html><html lang=»en»><body><script>
// Create a codyA object using the Object() constructor.
var codyA = new Object();
codyA.living = true;
codyA.age = 33;
codyA.gender = ‘male’;
codyA.getGender = function () { return codyA.gender;
console.log(codyA);
/* The same cody object is created below, but instead of using the native Object() constructor to create a one-off cody, we first define our own Person() constructor that can create a cody object (and any other Person object we like) and then instantiate it with «new».
var Person = function (living, age, gender) {
this.living = living;
this.age = age;
this.gender = gender;
this.getGender = function () { return this.gender;
};
var codyB = new Person(true, 33, ‘male’);
console.log(codyB);
</script></body></html>
|
Основное различие между объектами codyA и codyB заключается не в самом объекте, а в функциях конструктора, используемых для создания объектов. Объект codyA был создан с использованием экземпляра конструктора Object() . Конструктор Person() создал codyB, но его также можно использовать как мощный, централизованно определенный объектный «завод», который будет использоваться для создания большего количества объектов Person() . Создание собственных конструкторов для создания пользовательских объектов также настраивает наследование прототипов для экземпляров Person() .
Оба решения привели к созданию одного и того же сложного объекта. Именно эти две модели чаще всего используются для построения объектов.
JavaScript на самом деле является просто языком, который предварительно упакован с помощью нескольких собственных конструкторов объектов, используемых для создания сложных объектов, которые выражают очень специфический тип значения (например, числа, строки, функции, объекты, массивы и т. Д.), А также необработанные материалы через объекты Function() для создания пользовательских конструкторов объектов (например, Person() ). Конечный результат не имеет значения, шаблон для создания объекта, как правило, создание сложного объекта.
Понимание создания, природы и использования объектов и их примитивных эквивалентов является предметом остальной части этой книги.
Конструкторы JavaScript создают и возвращают экземпляры объектов
Роль функции конструктора заключается в создании нескольких объектов, которые имеют определенные качества и поведение. По сути, функция конструктора — это средство для обрезки файлов cookie для создания объектов, которые имеют свойства по умолчанию и методы свойств.
Если бы вы сказали: «Конструктор — это не что иное, как функция», я бы ответил: «Вы правы, если функция не вызывается с использованием new ключевого слова». (Например, new String('foo') ). Когда это происходит, функция берет на себя особую роль, и JavaScript обрабатывает функцию как особую, устанавливая значение this функции для нового объекта, который создается. В дополнение к этому специальному поведению функция будет возвращать вновь созданный объект (то есть this ) по умолчанию вместо значения false . Новый объект, который возвращается из функции, считается экземпляром функции конструктора, которая его создает.
Снова рассмотрим конструктор Person() , но на этот раз внимательно прочитайте комментарии в следующем примере кода, поскольку они подчеркивают эффект new ключевого слова.
Образец: sample6.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
|
<!DOCTYPE html><html lang=»en»><body><script>
/* Person is a constructor function.
var Person = function Person(living, age, gender) {
// «this» below is the new object that is being created (ie this = new Object();)
this.living = living;
this.age = age;
this.gender = gender;
this.getGender = function () { return this.gender;
// When the function is called with the new keyword, «this» is returned instead of false.
};
// Instantiate a Person object named cody.
var cody = new Person(true, 33, ‘male’);
// cody is an object and an instance of Person()
console.log(typeof cody);
console.log(cody);
console.log(cody.constructor);
</script></body></html>
|
Код sample6.html использует пользовательскую функцию конструктора (т.е. Person() ) для создания объекта cody. Это ничем не отличается от конструктора Array() создающего объект Array() (например, new Array() ) в следующем коде.
Образец: sample7.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
<!DOCTYPE html><html lang=»en»><body><script>
// Instantiate an Array object named myArray.
var myArray = new Array();
// myArray is an object and an instance of the Array() constructor.
console.log(typeof myArray);
console.log(myArray);
console.log(myArray.constructor);
</script></body></html>
|
В JavaScript большинство значений (исключая примитивные значения) включают объекты, которые создаются или создаются из функции конструктора. Объект, возвращаемый конструктором, называется экземпляром. Убедитесь, что вы знакомы с этой семантикой, а также с шаблоном использования конструкторов для создания объектов.
Собственные конструкторы объектов JavaScript
Язык JavaScript содержит девять собственных (или встроенных) конструкторов объектов. Эти объекты используются JavaScript для конструирования языка, и под «конструированием» я подразумеваю, что эти объекты используются для выражения значений объектов в коде JavaScript, а также для управления некоторыми функциями языка. Таким образом, нативные конструкторы объектов многогранны в том смысле, что они создают объекты, но также используются для облегчения многих соглашений о программировании языков. Например, функции — это объекты, созданные из конструктора Function() , но они также используются для создания других объектов при вызове в качестве функций конструктора с использованием ключевого слова new .
Девять собственных конструкторов объектов, которые поставляются в комплекте с JavaScript:
-
Number() -
String() -
Boolean() -
Object() -
Array() -
Function() -
Date() -
RegExp() -
Error()
JavaScript в основном состоит из этих девяти объектов (а также из строковых, числовых и логических примитивных значений). Детальное понимание этих объектов является ключом к использованию уникальных возможностей программирования и гибкости языка JavaScript.
Math объект — это чудак здесь. Это скорее статический объект, чем функция конструктора, то есть вы не можете сделать это: var x = new Math() . Но вы можете использовать его так, как будто он уже Math.PI (например, Math.PI ). По правде говоря, Math — это просто пространство имен объектов, созданное JavaScript для размещения математических функций.
Нативные объекты иногда называют «глобальными объектами», поскольку они являются объектами, которые JavaScript сделал изначально доступными для использования. Не путайте термин «глобальный объект» с глобальным объектом «head», который является верхним уровнем цепочки областей видимости, например, объектом window во всех веб-браузерах.
Конструкторы Number() , String() и Boolean() не только создают объекты; они также предоставляют примитивное значение для строки, числа и логического значения, в зависимости от того, как используется конструктор. Если вы вызываете эти конструкторы напрямую, то возвращается сложный объект. Если вы просто выражаете число, строку или логическое значение в своем коде (примитивные значения, такие как 5, «foo» и true ), тогда конструктор возвратит примитивное значение вместо значения сложного объекта.
Функции конструктора пользовательских / ненативных объектов
Как вы видели в конструкторе Person() , мы можем создавать собственные функции конструктора, из которых мы можем создавать не один, а несколько пользовательских объектов.
В следующем примере я представляю знакомую функцию конструктора Person() :
Образец: sample8.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
|
<!DOCTYPE html><html lang=»en»><body><script>
var Person = function (living, age, gender) {
this.living = living;
this.age = age;
this.gender = gender;
this.getGender = function () { return this.gender;
};
var cody = new Person(true, 33, ‘male’);
console.log(cody);
var lisa = new Person(true, 34, ‘female’);
console.log(lisa);
</script></body></html>
|
Как видите, передавая уникальные параметры и вызывая функцию конструктора Person() , вы можете легко создать огромное количество уникальных объектов-людей. Это может быть очень удобно, когда вам нужно более двух или трех объектов, которые обладают одинаковыми свойствами, но с разными значениями. Если подумать, это именно то, что JavaScript делает с нативными объектами. The Person() следует тем же принципам, что и конструктор Array() . Таким образом, new Array('foo','bar') на самом деле ничем не отличается от new Person(true, 33, 'male') . Создание ваших собственных функций конструктора просто использует тот же шаблон, который сам JavaScript использует для своих собственных функций конструктора.
Это не обязательно, но при создании пользовательских функций конструктора, предназначенных для использования с оператором new, рекомендуется использовать первый символ имени конструктора в верхнем регистре: Person() а не person() .
Одна сложность в функциях конструктора — использование значения this внутри функции. Помните, что функция конструктора — это всего лишь резак печенья. При использовании с new ключевым словом он создаст объект со свойствами и значениями, определенными внутри функции конструктора. Когда используется new , значение this буквально означает новый объект или экземпляр, который будет создан на основе операторов внутри функции конструктора. С другой стороны, если вы создаете функцию конструктора и вызываете ее без использования ключевого слова new , значение this будет ссылаться на «родительский» объект, который содержит функцию. Более подробно об этой теме можно узнать в главе 6.
Можно отказаться от использования ключевого слова new и концепции функции конструктора, явно указав функции, возвращающей объект. Функция должна быть написана явно, чтобы построить Object() и вернуть его: var myFunction = function() {return {prop: val}}; ,
Создание конструкторов с использованием new оператора
Функция конструктора — это, в основном, шаблон печенья, используемый для создания предварительно настроенных объектов. Взять, к примеру, String() . Эта функция, когда используется с оператором new ( new String('foo') ), создает экземпляр строки на основе шаблона » String() «. Давайте рассмотрим пример.
Образец: sample9.html
|
1
2
3
4
5
6
7
|
<!DOCTYPE html><html lang=»en»><body><script>
var myString = new String(‘foo’);
console.log(myString);
</script></body></html>
|
В этом фрагменте мы создали новый строковый объект, который является экземпляром функции конструктора String() . Точно так же у нас есть строковое значение, выраженное в JavaScript.
Я не предлагаю вам использовать функции конструктора вместо их литеральных / примитивных эквивалентов var string="foo"; , Я, однако, предлагаю вам понять, что происходит за буквальными / примитивными ценностями.
Как упоминалось ранее, язык JavaScript имеет следующие собственные предопределенные конструкторы: Number() , String() , Boolean() , Object() , Array() , Function() , Date() , RegExp() и Error() , Мы можем создать экземпляр объекта из любой из этих функций конструктора, применив оператор new. В следующем примере я создаю эти девять собственных объектов JavaScript.
Образец: sample10.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
<!DOCTYPE html><html lang=»en»><body><script>
// Instantiate an instance for each native constructor using the new keyword.
var myNumber = new Number(23);
var myString = new String(‘male’);
var myBoolean = new Boolean(false);
var myObject = new Object();
var myArray = new Array(‘foo’, ‘bar’);
var myFunction = new Function(«x», «y», «return x*y»);
var myDate = new Date();
var myRegExp = new RegExp(‘\bt[az]+\b’);
var myError = new Error(‘Darn!’);
// Log/verify which constructor created the object.
console.log(myNumber.constructor);
console.log(myString.constructor);
console.log(myBoolean.constructor);
console.log(myObject.constructor);
console.log(myArray.constructor);
console.log(myFunction.constructor);
console.log(myDate.constructor);
console.log(myRegExp.constructor);
console.log(myError.constructor);
</script></body></html>
|
Используя оператор new , мы сообщаем интерпретатору JavaScript, что нам нужен объект, который является экземпляром соответствующей функции конструктора. Например, в примере кода функция конструктора Date() используется для создания объектов даты. Функция конструктора Date() является средством для обрезки файлов cookie для объектов даты. То есть он создает объекты даты из шаблона по умолчанию, определенного функцией конструктора Date() .
На этом этапе вы должны быть хорошо знакомы с созданием экземпляров объектов из собственных функций конструктора (например, new String('foo') ) и пользовательских функций конструктора (например, new Person(true, 33, 'male') ).
Имейте в виду, что Math является статическим контейнером объектов для других методов и не является конструктором, использующим оператор new .
Создание сокращенных или буквальных значений из конструкторов
JavaScript предоставляет сокращенные «литералы» для производства большинства значений нативных объектов без необходимости использовать new Foo() или new Bar() . По большей части буквальный синтаксис выполняет то же самое, что и использование оператора new . Исключения составляют: Number() , String() и Boolean() см. Примечания после следующего примера.
Если вы пришли из других областей программирования, вы, вероятно, более знакомы с буквальным способом создания объектов. В следующем примере я создаю собственные конструкторы JavaScript с помощью оператора new а затем создаю соответствующие литеральные эквиваленты.
Образец: sample11.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
<!DOCTYPE html><html lang=»en»><body><script>
var myNumber = new Number(23);
var myNumberLiteral = 23;
var myString = new String(‘male’);
var myStringLiteral = ‘male’;
var myBoolean = new Boolean(false);
var myBooleanLiteral = false;
var myObject = new Object();
var myObjectLiteral = {};
var myArray = new Array(‘foo’, ‘bar’);
var myArrayLiteral = [‘foo’, ‘bar’];
var myFunction = new Function(«x», «y», «return x*y»);
var myFunctionLiteral = function (x, y) { return x * y };
var myRegExp = new RegExp(‘\bt[az]+\b’);
var myRegExpLiteral = /\bt[az]+\b/;
// Verify that literals are created from same constructor.
console.log(myNumber.constructor, myNumberLiteral.constructor);
console.log(myString.constructor, myStringLiteral.constructor);
console.log(myBoolean.constructor, myBooleanLiteral.constructor);
console.log(myObject.constructor, myObjectLiteral.constructor);
console.log(myArray.constructor, myArrayLiteral.constructor);
console.log(myFunction.constructor, myFunctionLiteral.constructor);
console.log(myRegExp.constructor, myRegExpLiteral.constructor);
</script></body></html>
|
То, что вам нужно убрать здесь, это тот факт, что в общем случае использование литералов просто скрывает основной процесс, идентичный использованию оператора new . Может быть, еще важнее, это гораздо удобнее!
Хорошо, все немного сложнее в отношении строки примитива, числа и логических значений. В этих случаях буквальные значения приобретают характеристики примитивных значений, а не сложных значений объектов. Смотрите примечания, которые следуют.
При использовании литеральных значений для String() , Number() и Boolean() фактический сложный объект никогда не создается, пока значение не будет обработано как объект. Другими словами, вы имеете дело с примитивным типом данных, пока не попытаетесь использовать методы или получить свойства, связанные с конструктором (например, var charactersInFoo = 'foo'.length ). Когда это происходит, JavaScript создает объект-обертку для литерального значения за сценой, позволяя рассматривать это значение как объект. Затем, после вызова метода, JavaScript отбрасывает объект-обертку, и значение возвращается к литеральному типу. Вот почему string, number и Boolean считаются примитивными (или простыми) типами данных. Я надеюсь, что это проясняет неверное представление «все в JavaScript — это объект» из концепции «все в JavaScript может действовать как объект».
Примитивные (иначе говоря, простые) значения
Значения JavaScript 5, ‘foo’, true и false , а также null и undefined считаются примитивными, поскольку они неприводимы. То есть число — это число, строка — это строка, логическое значение — либо true либо false , а null и undefined — это просто null и undefined . Эти значения по своей природе просты и не представляют собой значения, которые могут состоять из других значений.
Изучите следующий код и спросите себя, могут ли строка, число, логические, null и undefined значения быть более сложными. Сравните это с тем, что вы знаете об экземпляре Object() экземпляре Array() или действительно любом сложном объекте.
Образец: sample12.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
<!DOCTYPE html><html lang=»en»><body><script>
var myString = ‘string’
var myNumber = 10;
var myBoolean = false;
var myNull = null;
var myUndefined = undefined;
console.log(myString, myNumber, myBoolean, myNull, myUndefined);
/* Consider that a complex object like array or object can be made up of multiple primitive values, and thus becomes a complex set of multiple values.
var myObject = {
myString: ‘string’,
myNumber: 10,
myBoolean: false,
myNull: null,
myUndefined: undefined
};
console.log(myObject);
var myArray = [‘string’, 10, false, null, undefined];
console.log(myArray);
</script></body></html>
|
Проще говоря, примитивные значения представляют самую низкую форму (то есть самую простую) данных и информации, доступных в JavaScript.
В отличие от создания значений с буквальным синтаксисом, когда значение String() , Number() или Boolean() создается с использованием ключевого слова new, фактически создаваемый объект является сложным объектом.
Важно понимать, что конструкторы String() , Number() и Boolean() являются конструкторами двойного назначения, используемыми для создания литеральных / примитивных значений, а также сложных значений. Эти конструкторы не всегда возвращают объекты, но вместо этого при использовании без оператора « new » могут возвращать примитивное представление фактического значения сложного объекта.
Примитивные значения не являются объектами
null и undefined значения являются такими тривиальными значениями, что они не требуют ни функции конструктора, ни использования оператора new чтобы установить их в качестве значения JavaScript. Чтобы использовать null или undefined , все, что вам нужно сделать, это использовать их, как если бы они были оператором. Остальные примитивные значения string, number и Boolean, в то время как технически возвращаемые из функции конструктора, не являются объектами.
В следующем примере я сравниваю разницу между значениями примитивов и остальными объектами JavaScript.
Образец: sample13.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
<!DOCTYPE html><html lang=»en»><body><script>
// No object is created when producing primitive values;
var primitiveString1 = «foo»;
var primitiveString2 = String(‘foo’);
var primitiveNumber1 = 10;
var primitiveNumber2 = Number(’10’);
var primitiveBoolean1 = true;
var primitiveBoolean2 = Boolean(‘true’);
// Confirm the typeof is not object.
console.log(typeof primitiveString1, typeof primitiveString2);
console.log(typeof primitiveNumber1, typeof primitiveNumber2);
console.log(typeof primitiveBoolean1, typeof primitiveBoolean2);
// Using a constructor and the «new» keyword for creating objects.
var myNumber = new Number(23);
var myString = new String(‘male’);
var myBoolean = new Boolean(false);
var myObject = new Object();
var myArray = new Array(‘foo’, ‘bar’);
var myFunction = new Function(«x», «y», «return x * y»);
var myDate = new Date();
var myRegExp = new RegExp(‘\\bt[az]+\\b’);
var myError = new Error(‘Darn!’);
// Logs ‘object object object object object function object function object’.
console.log(
typeof myNumber,
typeof myString,
typeof myBoolean,
typeof myObject,
typeof myArray,
typeof myFunction, // BE AWARE typeof returns function for all function objects.
typeof myDate,
typeof myRegExp, // BE AWARE typeof returns function for RegExp()
typeof myError
);
</script></body></html>
|
Из предыдущего примера кода я бы хотел, чтобы вы узнали, что примитивные значения не являются объектами. Примитивные значения отличаются тем, что они используются для представления простых значений.
Как примитивные значения хранятся / копируются в JavaScript
Чрезвычайно важно понимать, что примитивные значения хранятся и обрабатываются как «номинал». Это может звучать просто, но это означает, что если я myString строковое значение «foo» в переменной с именем myString , то значение «foo» будет буквально хранится в памяти как таковой. Почему это важно? Как только вы начинаете манипулировать (например, копировать) значениями, вы должны быть вооружены этими знаниями, потому что примитивные значения копируются буквально.
В следующем примере мы сохраняем копию значения myString ('foo') в переменной myStringCopy, и ее значение буквально копируется. Даже если мы изменим исходное значение, скопированное значение, на которое ссылается переменная myStringCopy , останется неизменным.
Образец: sample14.html
|
01
02
03
04
05
06
07
08
09
10
11
|
<!DOCTYPE html><html lang=»en»><body><script>
var myString = ‘foo’ // Create a primitive string object.
var myStringCopy = myString;
var myString = null;
/*The original value from myString was copied to myStringCopy.
console.log(myString, myStringCopy);
</script></body></html>
|
Концепция, которую нужно здесь отбросить, заключается в том, что примитивные значения хранятся и управляются как неприводимые значения. Ссылаясь на них переводит их значение. В предыдущем примере мы скопировали или клонировали значение myString в переменную myStringCopy . Когда мы обновили значение myString значение myStringCopy все еще имело копию старого значения myString . Запомните это и противопоставьте механику здесь сложным объектам (обсуждается в следующем разделе).
Примитивные значения равны по значению
Примитивы можно сравнить, чтобы увидеть, совпадают ли их значения буквально. Как следует из логики, если сравнивать переменную, содержащую числовое значение 10, с другой переменной, содержащей числовое значение 10, JavaScript будет считать их равными, поскольку 10 равно 10 (т. 10 === 10 ). То же самое, конечно, применимо, если вы сравните примитивную строку «foo» с другой примитивной строкой со значением «foo». Сравнение скажет, что они равны друг другу в зависимости от их значения (то есть 'foo' === 'foo' ).
В следующем коде я демонстрирую концепцию «равно по значению» с использованием примитивных чисел, а также сопоставляю это с объектом комплексного числа.
Образец: sample15.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
|
<!DOCTYPE html><html lang=»en»><body><script>
var price1 = 10;
var price2 = 10;
var price3 = new Number(’10’);
var price4 = price3;
console.log(price1 === price2);
/* Logs false because price3 contains a complex number object and price 1 is a primitive value.
console.log(price1 === price3);
// Logs true because complex values are equal by reference, not value.
console.log(price4 === price3);
// What if we update the price4 variable to contain a primitive value?
price4 = 10;
console.log(price4 === price3);
</script></body></html>
|
Идея, которую нужно здесь убрать, заключается в том, что при сравнении примитивы проверяют, равны ли выраженные значения. Когда строка, число или логическое значение создается с использованием new ключевого слова (например, new Number('10') ), значение больше не является примитивным. Таким образом, сравнение не работает так же, как если бы значение было создано с помощью буквального синтаксиса. Это неудивительно, учитывая, что примитивные значения хранятся по значению (т. 10 === 10 ), в то время как сложные значения хранятся по ссылке (т. Е. Содержит ли price3 и price4 ссылку на одно и то же значение).
Значения String, Number и Boolean Primitive действуют как объекты, когда используются как объекты
Когда примитивное значение используется, как если бы это был объект, созданный конструктором, JavaScript преобразует его в объект, чтобы ответить на имеющееся выражение, но затем отбрасывает свойства объекта и изменяет его обратно на примитивное значение. В следующем коде я беру примитивные значения и демонстрирую, что происходит, когда значения обрабатываются как объекты.
Образец: sample16.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
<!DOCTYPE html><html lang=»en»><body><script>
// Produce primitive values.
var myNull = null;
var myUndefined = undefined;
var primitiveString1 = «foo»;
var primitiveString2 = String(‘foo’);
var primitiveNumber1 = 10;
var primitiveNumber2 = Number(’10’);
var primitiveBoolean1 = true;
var primitiveBoolean2 = Boolean(‘true’);
/* Access the toString() property method (inherited by objects from object.prototype) to demonstrate that the primitive values are converted to objects when treated like objects.
// Logs «string string»
console.log(primitiveString1.toString(), primitiveString2.toString());
// Logs «number number»
console.log(primitiveNumber1.toString(), primitiveNumber2.toString());
// Logs «boolean boolean»
console.log(primitiveBoolean1.toString(), primitiveBoolean2.toString());
/* This will throw an error and not show up in Firebug Lite, as null and undefined do not convert to objects and do not have constructors.
console.log(myNull.toString());
console.log(myUndefined.toString());
</script></body></html>
|
В этом примере кода все примитивные значения (кроме null и undefined ) преобразуются в объекты, чтобы использовать метод toString() , а затем возвращаются к примитивным значениям после вызова и возврата метода.
Комплексные (иначе композитные) ценности
Собственные конструкторы Object() , Array() , Function() , Date() , Error() и RegExp() являются сложными, поскольку они могут содержать одно или несколько примитивных или комплексных значений. По сути, сложные значения могут состоять из множества различных типов объектов JavaScript. Можно сказать, что сложные объекты имеют неизвестный размер в памяти, потому что сложные объекты могут содержать любое значение, а не конкретное известное значение. В следующем коде мы создаем объект и массив, в котором размещены все примитивные объекты.
Образец: sample17.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
|
<!DOCTYPE html><html lang=»en»><body><script>
var object = {
myString: ‘string’,
myNumber: 10,
myBoolean: false,
myNull: null,
myUndefined: undefined
};
var array = [‘string’, 10, false, null, undefined];
/* Contrast this to the simplicity of the primitive values below.
var myString = ‘string’;
var myNumber = 10;
var myBoolean = false; var myNull = null; var myUndefined = undefined;</script></body></html>
|
Концепция, которую следует здесь отбросить, заключается в том, что сложные значения представляют собой совокупность значений и отличаются по сложности и составу от примитивных значений.
Термин «сложный объект» также был выражен в других работах как «составные объекты» или «ссылочные типы». Если это не очевидно, все эти имена описывают природу значения JavaScript, исключая примитивные значения. Примитивные значения не «ссылаются на значение «и не может представлять собой составной элемент (т. е. вещь, состоящую из нескольких частей или элементов) других значений, в то время как сложные объекты» ссылаются по значению «и могут содержать или инкапсулировать другие значения.
Как сложные значения хранятся / копируются в JavaScript
Чрезвычайно важно понимать, что сложные значения хранятся и обрабатываются по ссылке. При создании переменной, содержащей сложный объект, значение сохраняется в памяти по адресу. Когда вы ссылаетесь на сложный объект, вы используете его имя (то есть переменную или свойство объекта), чтобы получить значение по этому адресу в памяти. Последствия значительны, если учесть, что происходит при попытке скопировать сложное значение. В следующем примере мы создаем объект, хранящийся в переменной myObject. Затем значение в myObjectкопируется в переменную copyOfMyObject. На самом деле, это не копия объекта, а скорее копия адреса объекта.
Образец: sample18.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
<!DOCTYPE html><html lang=»en»><body><script>
var myObject = {};
var copyOfMyObject = myObject; // Not copied by value, just the reference is copied. myObject.foo = 'bar'; // Manipulate the value stored in myObject. */
console.log(myObject, copyOfMyObject); // Logs 'Object { foo="bar"} Object { foo="bar"}'</script></body></html>
|
Вам нужно понять, что в отличие от примитивных значений, которые копируют значение, объекты (или сложные значения) хранятся по ссылке. Таким образом, ссылка (или адрес) копируется, но не фактическое значение. Это означает, что объекты вообще не копируются. Как я уже сказал, копируется адрес или ссылка на объект в стеке памяти. В нашем примере кода myObjectи copyOfMyObjectуказать на тот же объект, хранящийся в памяти.
Идея, которую нужно здесь убрать, заключается в том, что при изменении комплексного значения, поскольку оно сохраняется по ссылке, вы меняете значение, сохраненное во всех переменных, которые ссылаются на комплексное значение. В нашем примере кода оба myObjectи copyOfMyObjectизменяются при обновлении объекта, хранящегося в любой переменной.
Когда значения String(), Number()и Boolean()создаются с использованием нового ключевого слова или преобразуются в сложные объекты за сценой, значения продолжают храниться / копироваться по значению. Таким образом, хотя примитивные значения могут рассматриваться как сложные значения, они не принимают качество копирования посредством ссылки.
Чтобы действительно сделать копию объекта, вы должны извлечь значения из старого объекта и вставить их в новый объект.
Сложные объекты равны по ссылке
При сравнении сложных объектов они равны только тогда, когда они ссылаются на один и тот же объект (т.е. имеют один и тот же адрес). Две переменные, содержащие идентичные объекты, не равны друг другу, так как на самом деле они не указывают на один и тот же объект.
В следующем примере, objectFooи objectBarобладают теми же свойствами и являются, по сути, идентичными объектами, но когда его спросили , если они равны по ===, JavaScript говорит нам , что они не являются.
Образец: sample19.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
|
<!DOCTYPE html><html lang=»en»><body><script>
var objectFoo = { same: 'same' }; var objectBar = { same: 'same' }; // Logs false, JS does not care that they are identical and of the same object type. console.log(objectFoo === objectBar); // How complex objects are measured for equality. var objectA = { foo: 'bar' }; var objectB = objectA; console.log(objectA === objectB); // Logs true because they reference the same object.</script></body></html>
|
Концепция, которую следует здесь отбросить, состоит в том, что переменные, которые указывают на сложный объект в памяти, равны только потому, что они используют один и тот же «адрес». И наоборот, два независимо созданных объекта не равны, даже если они одного типа и обладают точно такие же свойства.
Сложные объекты имеют динамические свойства
Новая переменная, которая указывает на существующий сложный объект, не копирует объект. Вот почему сложные объекты иногда называют ссылочными объектами. Сложный объект может иметь столько ссылок, сколько вы хотите, и они всегда будут ссылаться на один и тот же объект, даже если объект, на который ссылаются, изменяется.
Образец: sample20.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
<!DOCTYPE html><html lang=»en»><body><script>
var objA = { property: 'value' }; var pointer1 = objA; var pointer2 = pointer1; // Update the objA.property, and all references (pointer1 and pointer2) are updated. objA.property = null; // Logs 'null null null' because objA, pointer1, and pointer2 all reference the same object. console.log(objA.property, pointer1.property, pointer2.property);</script></body></html>
|
Это учитывает динамические свойства объекта, потому что вы можете определить объект, создать ссылки, обновить объект, и все переменные, ссылающиеся на объект, будут «получать» это обновление.
typeofОператор Б О примитивных и сложных значений
typeofОператор может быть использован для возврата типа значения вы имеете дело с. Но значения, возвращаемые из него, не совсем соответствуют или, что некоторые могут сказать, логично. Следующий код демонстрирует возвращаемые значения от использования typeofоператора.
Образец: sample21.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
<!DOCTYPE html><html lang=»en»><body><script>
// Primitive values. var myNull = null; var myUndefined = undefined; var primitiveString1 = "string"; var primitiveString2 = String('string'); var primitiveNumber1 = 10; var primitiveNumber2 = Number('10'); var primitiveBoolean1 = true; var primitiveBoolean2 = Boolean('true'); console.log(typeof myNull); // Logs object? WHAT? Be aware... // Logs undefined.
console.log(typeof primitiveString1, typeof primitiveString2); // Logs string string. console.log(typeof primitiveNumber1, typeof primitiveNumber2); // Logs number number console.log(typeof primitiveBoolean1, typeof primitiveBoolean2); // Logs boolean boolean. // Complex values. var myNumber = new Number(23); var myString = new String('male'); var myBoolean = new Boolean(false); var myObject = new Object(); var myArray = new Array('foo', 'bar'); var myFunction = new Function("x", "y", "return x * y"); var myDate = new Date(); var myRegExp = new RegExp('\\bt[az]+\\b'); var myError = new Error('Darn!'); console.log(typeof myNumber); // Logs object. console.log(typeof myString); // Logs object. console.log(typeof myBoolean); // Logs object. console.log(typeof myObject);
console.log(typeof myArray); // Logs object. console.log(typeof myFunction); // Logs function? WHAT? Be aware... console.log(typeof myDate); // Logs object. console.log(typeof myRegExp); // Logs function? WHAT? Be aware... console.log(typeof myError); // Logs object.</script></body></html>
|
При использовании этого оператора для значений вы должны знать о потенциальных возвращаемых значениях, учитывая тип значения (примитивное или сложное), с которым вы имеете дело.
Динамические свойства допускают изменяемые объекты
Сложные объекты состоят из динамических свойств. Это позволяет изменять определенные пользователем объекты и большинство собственных объектов. Это означает, что большинство объектов в JavaScript могут быть обновлены или изменены в любое время. Из-за этого мы можем изменить собственную предварительно сконфигурированную природу самого JavaScript, увеличив его собственные объекты. Тем не менее, я не говорю вам сделать это; на самом деле я не думаю, что вы должны. Но давайте не будем омрачать то, что возможно, мнениями.
Это означает, что можно сохранять свойства собственных конструкторов и добавлять новые методы к собственным объектам с добавлением к их объектам-прототипам.
В следующем коде я изменяю String()функцию конструктора и String.prototype.
Образец: sample22.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
|
<!DOCTYPE html><html lang=»en»><body><script>
// Augment the built-in String constructor Function() with the augmentedProperties property. String.augmentedProperties = []; if (!String.prototype.trimIT) { // If the prototype does not have trimIT() add it. String.prototype.trimIT = function () { return this.replace(/^\s+|\s+$/g, ''); }
// Now add trimIT string to the augmentedProperties array. String.augmentedProperties.push('trimIT'); }
var myString = ' trim me '; console.log(myString.trimIT()); // Invoke our custom trimIT string method, logs 'trim me'. console.log(String.augmentedProperties.join()); // Logs 'trimIT'.</script></body></html>
|
Я хочу показать, что объекты в JavaScript являются динамическими. Это позволяет объектам в JavaScript быть мутированными. По сути, весь язык может быть преобразован в пользовательскую версию (например, trimITстроковый метод). Опять же, я не рекомендую это, я просто указываю, что это является частью природы объектов в JavaScript.
Осторожный!Если вы изменяете внутреннюю работу JavaScript, у вас потенциально может быть собственная версия JavaScript для работы. Действуйте осторожно, так как большинство людей предположит, что JavaScript везде одинаков.
Все экземпляры конструктора имеют свойства конструктора, которые указывают на их функцию конструктора
Когда constructorсоздается какой-либо объект, свойство создается за сценой как свойство этого объекта или экземпляра. Это свойство указывает на функцию конструктора, которая создала объект. В следующем примере кода мы создаем Object()объект, сохраненный в fooпеременной, а затем проверяем, constructorдоступно ли свойство для созданного нами объекта.
Образец: sample23.html
|
1
2
3
4
5
6
7
8
|
<!DOCTYPE html><html lang=»en»><body><script>
var foo = {};
console.log(foo.constructor === Object) // Logs true, because object() constructed foo. console.log(foo.constructor) // Points to the Object() constructor function.</script></body></html>
|
Это может быть полезно: если я работаю с каким-то экземпляром, и я не вижу, кто или что его создал (особенно если это кто-то, использующий другой код), я могу определить, является ли он массивом, объектом или чем-то еще.
В следующем примере вы можете видеть, что я создал большинство предварительно сконфигурированных объектов, которые включены в язык JavaScript. Обратите внимание, что использование литеральных или примитивных значений не означает, что constructorуказатель не разрешается, когда примитивное литеральное значение рассматривается как объект.
Образец: sample24.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
<!DOCTYPE html><html lang=»en»><body><script>
var myNumber = new Number('23'); var myNumberL = 23; // Literal shorthand. var myString = new String('male'); var myStringL = 'male'; // Literal shorthand. var myBoolean = new Boolean('true'); var myBooleanL = true; // Literal shorthand. var myObject = new Object(); var myObjectL = {}; // Literal shorthand. var myArray = new Array(); var myArrayL = []; // Literal shorthand. var myFunction = new Function(); var myFunctionL = function () { }; // Literal shorthand. var myDate = new Date(); var myRegExp = new RegExp('/./'); var myRegExpL = /./; // Literal shorthand. var myError = new Error(); console.log( // All of these return true. myNumber.constructor === Number, myNumberL.constructor === Number, myString.constructor === String, myStringL.constructor === String, myBoolean.constructor === Boolean, myBooleanL.constructor === Boolean, myObject.constructor === Object, myObjectL.constructor === Object, myArray.constructor === Array, myArrayL.constructor === Array, myFunction.constructor === Function, myFunctionL.constructor === Function, myDate.constructor === Date, myRegExp.constructor === RegExp, myRegExpL.constructor === RegExp, myError.constructor === Error );
</script></body></html>
|
constructorСвойство также работает на определяемые пользователем функции конструктора. В следующем примере мы определяем функцию CustomConstructor()конструктора, затем, используя ключевое слово new, вызываем функцию для создания объекта. Получив наш объект, мы можем использовать constructorсвойство.
Образец: sample25.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
<!DOCTYPE html><html lang=»en»><body><script>
};
var instanceOfCustomObject = new CustomConstructor(); // Logs true.
console.log(instanceOfCustomObject.constructor === CustomConstructor); // Returns a reference to CustomConstructor() function. // Returns 'function() { return 'Wow!'; };' console.log(instanceOfCustomObject.constructor);</script></body></html>
|
Вы можете быть смущены тем, почему примитивные значения имеют свойства конструктора, которые указывают на функции конструктора, когда объекты не возвращаются. Используя примитивное значение, конструктор по-прежнему вызывается, поэтому сохраняется связь с примитивными значениями и функциями конструктора. Тем не менее, конечный результат является примитивным значением.
Если вы хотите, чтобы constructorсвойство регистрировало фактическое имя конструктора для пользовательских функций конструктора, вы должны присвоить функции конструктора фактическое имя (например, var Person = function Person(){};).
Убедитесь, что объект является экземпляром определенной функции конструктора
Используя instanceofоператор, мы можем определить (истина или ложь), является ли объект экземпляром определенной функции конструктора.
В следующем примере мы проверяем, является ли объект InstanceOfCustomObjectэкземпляром CustomConstructorфункции конструктора. Это работает как с пользовательскими объектами, так и с собственными объектами, созданными newоператором.
Образец: sample26.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
|
<!DOCTYPE html><html lang=»en»><body><script>
// User-defined object constructor. };
// Instantiate an instance of CustomConstructor. var instanceOfCustomObject = new CustomConstructor(); // Logs true.
// Works the same as a native object. console.log(new Array('foo') instanceof Array) // Logs true.</script></body></html>
|
При работе с instanceofоператором следует обратить внимание на то, что он будет возвращаться trueкаждый раз, когда вы спрашиваете, является ли объект экземпляром Object, поскольку все объекты наследуются от Object()конструктора.
instanceofОператор вернет ложь , когда дело с примитивными значениями, объект левереджа упаковщики (например, 'foo' instanceof String // returns false). Если бы строка 'foo'была создана с newоператором, instanceofоператор вернул бы true. Итак, имейте в виду, что на instanceofсамом деле работает только со сложными объектами и экземплярами, созданными из функций конструктора, которые возвращают объекты.
Экземпляр, созданный из конструктора, может иметь собственные независимые свойства (свойства экземпляра)
В JavaScript объекты могут быть расширены в любое время (например, динамические свойства). Как упоминалось ранее, а точнее, JavaScript имеет изменяемые объекты. Это означает, что объекты, созданные из функции конструктора, могут быть дополнены свойствами.
В следующем примере кода я создаю экземпляр из Array()конструктора, а затем дополняю его собственным свойством.
Образец: sample27.html
|
1
2
3
4
5
6
7
8
|
<!DOCTYPE html><html lang=»en»><body><script>
var myArray = new Array(); myArray.prop = 'test'; console.log(myArray.prop) // Logs 'test'.</script></body></html>
|
Это может быть сделано с Object(), RegExp()или любым из других непримитивных конструкторов даже Boolean().
Образец: sample28.html
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
<!DOCTYPE html><html lang=»en»><body><script>
// This can be done with any of the native constructors that actually produce an object. var myString = new String(); var myNumber = new Number(); var myBoolean = new Boolean(true); var myObject = new Object(); var myArray = new Array(); var myFunction = new Function('return 2+2'); var myRegExp = new RegExp('\bt[az]+\b'); myString.prop = 'test'; myNumber.prop = 'test'; myBoolean.prop = 'test'; myObject.prop = 'test'; myArray.prop = 'test'; myFunction.prop = 'test'; myRegExp.prop = 'test'; // Logs 'test', 'test', 'test', 'test', 'test', 'test', 'test'. console.log(myString.prop, myNumber.prop, myBoolean.prop, myObject.prop, myArray.prop, myFunction.prop, myRegExp.prop); // Be aware: Instance properties do not work with primitive/literal values. var myString = 'string'; var myNumber = 1; var myBoolean = true; myString.prop = true; myNumber.prop = true; myBoolean.prop = true; // Logs undefined, undefined, undefined. console.log(myString.prop, myNumber.prop, myBoolean.prop);</script></body></html>
|
Добавление свойств к объектам, созданным из функции конструктора, иногда происходит. Помните, экземпляры объектов, созданные из функций конструктора, являются просто старыми объектами.
Имейте в виду, что помимо своих собственных свойств экземпляры могут иметь свойства, унаследованные от цепочки прототипов. Или, как мы только что видели в предыдущем примере кода, свойства добавляются в конструктор после создания экземпляра. Это подчеркивает динамическую природу объектов в JavaScript.
Семантика «объектов JavaScript» и » Object()объектов»
Не путайте общий термин «объекты JavaScript», который относится к понятию объектов в JavaScript, с Object()объектами. Object()Объект (например, var myObject = new Object()) представляет собой очень специфический тип значения выражены в JavaScript. Точно так же, как Array()объект — это тип объекта, называемый массивом, Object()объект — это тип объекта, называемый объектом. Суть в том, что Object()функция конструктора создает пустой контейнер универсального объекта, который называется Object()объектом. Аналогично, Array()функция конструктора создает объект массива, и мы называем эти объекты Array()объектами.
В этой книге термин «объекты JavaScript» используется для обозначения всех объектов в JavaScript, поскольку большинство значений в JavaScript могут действовать как объекты. Это связано с тем, что большинство значений JavaScript создаются из встроенной функции конструктора, которая создает очень специфический тип объекта.
Вывод
Что вам нужно помнить, так это то, что Object()объект — это особая ценность. Это общий пустой объект. Не путайте это с термином «объекты JavaScript», который используется для обозначения большинства значений, которые могут быть выражены в JavaScript как объект.