Это третий класс в нашей серии javascript. Если вы не читали предыдущие блоги, сначала ознакомьтесь с ними. На этом занятии мы подведем итог тому, что мы изучали на предыдущих занятиях, и главная цель этого блога — глубоко изучить следующие вопросы:
1. Изменчивость или неизменяемость?
2 , Можно ли обнулить переменную любого типа? если можно, каковы потери?
3. null и undefined — это одно и то же?
4. Строгое и свободное сравнение?
Давайте начнем изучать команду.
Изменчивость VS неизменность
Изменчивость: переменная является изменяемой, если мы вносим изменения в копию исходной переменной, тогда они отражаются в исходной переменной.
Неизменяемость: переменная является неизменной, если мы вносим изменения в копию, они не должны влиять на исходную.
Пример :
var a = 10 ; //variable declaration and initialization var b; //variable declaration b = a ;
как вы думаете, что будет содержать b? b будет содержать 10 . что, если мы изменим b на 20, изменится ли также значение a?
console.log("a: " + a);
console.log("b: " + b)
b = 20;
console.log("b: " + b );
console.log("a: " + a );
//Output
>a: 10
>b: 10
>b: 20
>a: 10
Итак, мы увидели, что если мы изменим b, то а не изменится. Этот тип переменной называется переменной изменяемого типа или переменной типа значения. потому что значение a копируется в b. и этот тип переменной также известен как переменная примитивного или первичного типа.
давайте подумаем об этом коде:
var arr = [10,20,30,40,50]; //Array declaration and initialization
var arr2 = null;
console.log("before copy arr: ",arr);
console.log("before copy arr2: ",arr2);
arr2 = arr;
console.log("after copy arr: ",arr);
console.log("after copy arr2: ",arr2);
arr2[0]=1000;
console.log("after change in arr2, arr: ",arr);
console.log("after change in arr2, arr2: ",arr2);
//Output
< before copy arr: [ 10, 20, 30, 40, 50 ]
< before copy arr2: null
< after copy arr: [ 10, 20, 30, 40, 50 ]
< after copy arr2: [ 10, 20, 30, 40, 50 ]
< after change in arr2, arr: [ 1000, 20, 30, 40, 50 ]
< after change in arr2, arr2: [ 1000, 20, 30, 40, 50 ]
Здесь мы увидели, что копируем массив arr в массив arr2. Но arr, содержащий адрес массива «[10,20,30,40,50]». предположим, что адрес массива «[10,20,30,40,50]» равен 88, тогда arr будет содержать 88. когда мы пишем arr2 = arr, тогда arr2 получает значение arr, равное 88. Таким образом, оба имеют одинаковую ссылку, поэтому оба указывают на один и тот же массив, который находится в адресе 88. поэтому, когда мы изменили значение индекса 0 в arr2, это также можно увидеть с помощью arr, потому что они указывают на одно и то же. Этот тип переменной называется изменяемой, ссылочной, вторичной, или непримитивной переменной типа.
Давайте посмотрим на этот код:
console.log(arr == arr2); console.log(arr === arr2); //Output < true < true
почему arr == arr2 дает истину? потому что и arr, и arr2 содержат 88, что является ссылкой, поэтому свободное сравнение не должно выполнять приведение типов, а также значение также одинаковое, равное 88, поэтому свободное сравнение дает истину. И поскольку тип и значение одинаковы, строгое сравнение также дает истину.
Таким образом, массивы являются изменяемыми по своей природе в JavaScript. Но когда-нибудь нам может понадобиться неизменность в массиве, что мы тогда будем делать? то мы будем использовать оператор спреда.
мы можем использовать оператор распространения следующим образом:
arr2 = [...arr]; // ... is spread operator console.log(arr2); console.log(arr); console.log(arr == arr2); console.log(arr === arr2); //Output < [ 1000, 20, 30, 40, 50 ] < [ 1000, 20, 30, 40, 50 ] < false < false
Итак, теперь мы можем видеть, когда мы используем оператор распространения для копирования arr в arr2, свободное и строгое сравнение дает false, потому что оператор распространения создает новый массив, в котором упомянутый массив в этом случае arr все скопированные элементы и этот вновь созданный адрес массива отличается, который хранится в arr2. Таким образом, здесь есть два разных массива с одинаковым значением. Оба имеют разные адреса, поэтому мы получили ложные результаты в обоих сравнениях. Предположим, что адрес массива «[ 1000, 20, 30, 40, 50]» равен 88, который хранится в переменной arr. когда мы делаем это «arr2 = arr»значение arr, равное 88, копируется в arr2, но когда мы делаем это «arr2=[…arr]»движок JavaScript создает новый массив с тем же элементом упомянутого массива с другим адресом, предположительно 67, который будет храниться в arr2. поэтому и arr2, и arr имеют разные значения, поэтому в результате мы получили false. поэтому, если это разные массивы, поэтому, если мы изменим один, это не отразится на другом.
Давайте посмотрим:
arr2[0]=10; console.log(arr2); console.log(arr); //output < [ 10, 20, 30, 40, 50 ] < [ 1000, 20, 30, 40, 50 ]
Итак, мы увидели то, что изучали.
Переход к следующей теме.
Можно ли обнулить переменную любого типа? если можно то какие потери?
null:null — это значение, а также примитивный тип данных. Значение null представляет преднамеренное отсутствие какого-либо значения объекта. Итак, если мы хотим аннулировать объект, мы можем использовать null следующим образом:
var arr = [10,20,30,40,50]; console.log(arr); arr=null; console.log(arr); cosole.log(typeof arr); //Object < [ 10, 20, 30, 40, 50 ] < null < object
после присвоения null тип arr остается объектом, но не несет никакого адреса. Поэтому всякий раз, когда мы хотим такого типа ситуации, мы можем использовать null.
поэтому мы поняли, что null может быть присвоен только объекту. так можем ли мы присвоить null примитивному типу данных?
Ответ: да, мы можем присвоить null примитивному типу данных, но тогда он изменится на тип ссылки или тип объекта. Давайте посмотрим:
var arr = [10,20,30,40,50]; console.log(typeof arr); arr = null; console.log(typeof arr); var a =10; console.log(typeof a); a=null; console.log(typeof a); //Object < object < object < number < object
поэтому, когда мы присвоили null «a», который ранее был числом, но когда мы присвоили null «a», он становится объектом. Таким образом, хотя мы можем использовать null для присвоения значения null примитивному типу данных, использование null не рекомендуется. Вместо этого для числового типа мы можем использовать 0 в качестве нулевого значения или для строки мы можем использовать «» в качестве нулевого значения.
В. Почему мы используем нулевое значение?
Значение null представляет намеренное отсутствие какого-либо значения объекта. Итак, почему мы используем это? В C мы используем функцию free() для освобождения памяти, в JavaScript нам не нужно использовать этот тип функций, потому что в JS уже есть «автоматический сборщик мусора», который освобождает память, когда она не используется. это означает, что когда объект или массив не указывает на какую-либо переменную, автоматический сборщик мусора освобождает или освобождает память, занятую этим объектом или массивом. Поэтому, когда мы не используем массив и хотим, чтобы эта переменная была объектом, мы можем присвоить нулевое значение.
Сборщик мусора не работает каждый раз. Он работает, когда ЦП находится в режиме меньшего использования. Как операции ввода/вывода (ввода/вывода). Операция ввода-вывода не использует ЦП, они используют прерывания.
Неопределенность и нуль – одно и то же?
Ответ - нет, undefined и null - это разные примитивные типы данных.
- undefined - это тип тех переменных, которые только объявлены, но не инициализированы. в то время как, с другой стороны, нулевое значение представляет преднамеренное отсутствие какого-либо значения объекта.
- Если мы присвоим undefined любой переменной, а затем проверим тип этой переменной, она покажет undefined, в то время как, с другой стороны, если мы присвоим null любой переменной, а затем проверим тип переменной, он покажет объект.
- Оба являются примитивными типами данных, хотя если мы проверим typeof undefined, он покажет undefined, а typeof null покажет объект. Здесь это означает JS Engine или браузер.
- Если они разные, то почему null == undefined дает true? мы узнаем это, но сначала мы должны узнать о строгом и свободном сравнении.
Строгое VS свободное сравнение
Это два типа операторов сравнения для сравнения двух переменных или данных, которые возвращают логическое значение, то есть истинное или ложное. Они подпадают под категорию операторов равенства.
Нечеткое сравнение. Также известно как слабое или мягкое сравнение. Мы делаем это с помощью мягкого оператора равенства «==». Оператор снисходительного равенства пытается преобразовать значения разных типов перед их сравнением. Значение: оператор снисходительного равенства сравнивает вещи в два следующих шага:
- Преобразование одной переменной из ее типа данных в другой. Он преобразует тип данных, который легко преобразовать, как легко преобразовать число в строку. он пытается преобразовать объект в примитив. Булево и не логическое значение, затем преобразовать логическое значение в число и снисходительно сравнить (снова)
- Затем он сравнивает значение.
например:
var a =10; var b = "10"; console.log(a==b); //Output < true
В этом примере мы видим, что «a» — это тип числа, а «b» — это тип строки, хотя == дает true. Поскольку свободный компаратор сначала преобразует числовое значение 10 в строку, а затем сравнивает значение, вот почему он дает true.
Строгое сравнение: мы делаем это с помощью оператора строгого равенства, который называется «===». Оператор строгого равенства также работает в два этапа:
- Проверьте тип данных обеих переменных, если они не совпадают, то он не проверяет значение и сразу возвращает false.
- В противном случае он вернет true. Это означает, что он вернет true, только если тип и значение совпадают.
например:
var a =10; var b = "10"; console.log(a===b); //Output < false
В этом примере мы видим, что «a» — это тип числа, а «b» — это тип строки, хотя === дает false. Поскольку строгий компаратор сначала проверяет тип данных 10, который является числом, а «b» — строкой, поэтому тип не соответствует, поэтому он возвращает false.
Когда «null == undefined» дает true, как вы можете сказать, что null и undefined разные?
Потому что == является свободным компаратором, когда мы делаем «null == undefined», потому что оба обозначают отсутствие значения. Оба являются примитивными значениями JavaScript, что означает, что они не считаются объектами и, следовательно, не имеют методов или свойств. Оба являются ложными, когда встречаются в логическом контексте (ложные значения). Вот почему свободное сравнение говорит, что null == undefined true.
Пока мы делаем null === undefined, это дает нам false, потому что тип null является объектом, а тип undefined не определен.
Давайте посмотрим:
console.log(null==undefined); console.log(null==undefined); //Output < true < False
Вот как они работают.
На сегодня все, увидимся на следующем занятии.
Я хотел бы выразить благодарность Амиту Сриваставе, сэру Brain Mentors Pvt Ltd, за проведение таких полезных сессий.
Не стесняйтесь связаться со мной на Linked In: https://www.linkedin.com/in/mohd-ahmad-seemapuri/
Проверьте мой GitHub Для заметок: https://github.com/ahmad9652/MERN-Stack-Learning/tree/main/JS
Спасибо за чтение.
