Вы часто слышали, что самые опытные разработчики реагирования предлагают использовать оператор спреда, чтобы скопировать массив вместо того, чтобы просто назначать его новой переменной. Это связано со специфическими типами данных, являющимися ссылочным типом в JavaScript, следовательно, смешным. Концепция мультипликации и неизменности в JavaScript необходима для того, чтобы понять, чтобы избежать ошибок. Давайте погрузиться глубже в идею мультипликации против неподумности в JavaScript.
Примитивные типы VS. Ссылки в JavaScript
Данные, назначенные переменной JavaScript, могут быть из двух типов, примитивного типа и тип ссылки. Существует разница в том, как JavaScript обрабатывает эти два типа данных. Чтобы узнать, как они обращаются по-другому, давайте сначала понять разницу между примитивными и ссылочными типами.
Примитивные типы
Примитивные типы представляют собой простые атомные кусочки данных в JavaScript. Примитивные типы всегда сохраняются и получают доступ к значению переменной, а не в качестве ссылки на другой объект. В JavaScript есть шесть примитивных типов:
- неопределенный
- ноль
- логический
- номер
- нить
- символ
Типы ссылок
Типы ссылок не являются простыми атомными значениями, но являются объектами, которые состоят из множественных свойств, назначенных им. Они хранятся в качестве ссылки в памяти, а не как независимые значения, назначенные переменным. В JavaScript есть три ссылочных типа:
- объекты
- массива
- функции
Как примитивные типы и типы ссылок хранятся в памяти
Как примитивные типы и ссылочные типы хранятся в памяти, является основой того, как они отличаются друг от друга. Давайте посмотрим на несколько примеров и попытайтесь понять, как они используют память по-разному.
Использование памяти при примитивных типах
Как выделено ранее, примитивные типы хранятся как одно атомное значение, назначенное для переменной в памяти. Давайте посмотрим на этот пример:
let name = 'john'; let name2 = name;
Глядя на приведенный выше пример, я создал имя переменной и назначил его значение Джон Отказ Теперь JavaScript сохранит это как одно атомное значение в памяти. Теперь, если я создаю новую переменную Имя2 и назначьте его значение имени переменной имени JavaScript и создаст новое пространство в памяти и выделяет одинаковое значение имени переменной и назначению его переменной Имя2 Отказ Новое значение, назначенное переменной Имя2 , полностью отдельно от переменной Имя И не имеет никакого ссылки на это вообще.
Использование памяти по ссылкам
Опорные значения – это объекты, хранящиеся в памяти и ссылках на объекты вместо выделенных мест в памяти, в отличие от примитивных типов. Давайте посмотрим на следующий пример, чтобы лучше понять, как опорные типы сохраняются в памяти JavaScript.
let person = {
name: 'john',
age: 22,
};
let person2 = person;
Давайте только что объявим переменную, называемую человека, который будет содержать объект, содержащий Имя и возраст объекта человека. Теперь я пойду вперед и создаю другую переменную по имени человек2 и назначить это то же самое человек объект. Именно здесь все начинают становиться отличаться по сравнению с примитивными типами. В этом случае JavaScript сохранит человек2 объект просто как ссылка на человек объект.
Если вы посмотрите на это изображение, вы поймете, что JavaScript здесь на самом деле указывает на тот же объект в памяти. Хотя он создал новую переменную, как значение, эта переменная только имеет отношение к тому же человек объект, который мы создали ранее.
Понимание неизменности и мультипликации примитивных и ссылочных типов в JavaScript
Поскольку мы сейчас ясно с примитивными и ссылками в JavaScript, мы можем легко понять концепцию мультиплизма и неизменности в JavaScript. Мультипликация может быть изменена или добавлена к тому, где Immutable означает что-то, что нельзя изменить или добавить. Примитивные значения в JavaScript не могут иметь никакого добавления к ним, они могут быть переназначены только, и, следовательно, все примитивные значения в JavaScript неизменяются. Давайте посмотрим это с примером.
let name = 'john'; let name2 = name; console.log(name); console.log(name2); /* * john * john */ let name2 = 'doe'; console.log(name); console.log(name2); /* * john * doe */
Расширение нашего предыдущего примера примитивных типов, давайте распечатаем значения как наших переменных, то есть Имя и Имя2 на консоль и посмотреть, что мы получаем. Как и ожидалось, оба переменной возвращает значение Джон Отказ Теперь давайте переназнаем Имя2 к DOE И снова распечатайте значения обоих переменных к консоли. Теперь вы видите, что ценность только Имя2 был повторно назначен JavaScript на DOE , но переменная Имя не изменился. Это шоу, что JavaScript обрабатывает эти 2 переменных отдельно, хотя Имя2 Первоначально был скопирован из переменной Имя Отказ Это доказывает, что примитивные значения в JavaScript, в этом случае строки, неизменны.
Давайте попробуем реплицировать тот же пример для типов опорных типов. Подбирая из нашего предыдущего примера, давайте распечатаем значения обоих человек и человек2 Объекты к консоли и посмотрите, что мы получаем.
let person = {
name: 'john',
age: 22,
};
let person2 = person;
console.log(person);
console.log(person2);
/*
* {
* name: 'john',
* age: 22,
* }
*
* {
* name: 'john',
* age: 22,
* }
*/
Мы видим два объекта, напечатанные на консоли с теми же свойствами. Теперь я изменим одну из свойств человек2 Объект и снова распечатайте их в консоль.
let person2.name = 'doe';
console.log(person);
console.log(person2);
/*
* {
* name: 'doe',
* age: 22,
* }
*
* {
* name: 'doe',
* age: 22,
* }
*/
Вы видите, что JavaScript изменил человека, а также человек2 Отказ Это потому, что человек2 Объект был создан путем ссылки человек объект. С помощью контрольных типов JavaScript создает ссылку на тот же объект, и объект остается смежным. Поскольку объект является смежным, он может быть изменен или может быть добавлен новое свойство.
Оператор распространения Оператор SPRECT был введен в ES6 ( больше информации о ES6 и позволяет безопасно скопировать свои объекты и создать новый экземпляр объекта, а не просто ссылаться на предыдущий объект. Давайте посмотрим на тот же пример и посмотрим, как мы можем Скопируйте объект и сохраните новый экземпляр объекта переменной.
let person = {
name: 'john',
age: 22,
};
let person2 = {...person};
let person2.name = 'doe';
console.log(person);
console.log(person2);
/*
* {
* name: 'john',
* age: 22,
* }
*
* {
* name: 'doe',
* age: 22,
* }
*/
Давайте возьмем один и тот же человек Объект, а вместо того, чтобы присвоить его непосредственно в переменную на этот раз, давайте использовать оператор SPRECT, чтобы скопировать его. Оператор спреда может быть использован префиксированием трех точек ... Перед объектом, который вы хотите скопировать и инкапсулировать его с помощью литерального синтаксиса объекта. Таким образом, JavaScript создает новый объект и сохраняет его в переменной человек2 Отказ Давайте попробуем изменить один из свойств человек2 Отказ Я изменим имя на DOE Отказ Теперь давайте распечатаем оба объекта к консоли и посмотрим, что мы получаем. Вы видите, на этот раз мы только изменили имя свойства человек2 Объект, а не человек объект. Это потому, что человек2 был создан и сохранен как новый объект, используя оператор по распространению, а не в качестве ссылки на человек объект.
Получить доступ к большему количеству таких историй на Cloudaffle Спасибо за чтение и, надеюсь, это было полезно! Я создал обширный JavaScript Chechsheet Отказ Он был спроектирован таким образом, когда вам легко относиться к каждому свойству и методу для различных объектов JavaScript. Это абсолютно бесплатно загружать с вышеуказанной ссылки ☺.