Яка різниця між null та undefined у JavaScript?

Я хочу знати, в чому різниця між JavaScript nullта undefinedJavaScript.

У JavaScript undefinedозначає, що змінна оголошена, але їй ще не призначено значення, наприклад:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

null- значення присвоєння. Він може бути призначений змінній як подання без значення:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

З попередніх прикладів видно, що undefinedі nullє два різних типи: undefinedце сам тип (невизначений), а nullє об'єктом.

null === undefined // false
null == undefined // true
null === null // true

і

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Я вибрав це звідси

Невизначене значення - це примітивне значення, яке використовується, коли змінній не було призначено значення.

Нульове значення - це примітивне значення, яке представляє нульову, порожню або неіснуючу посилання.

Коли ви оголосите змінну через var і не надасте їй значення, вона матиме значення не визначене. Якщо ви спробуєте WScript.Echo () або попередити () це значення, ви нічого не побачите. Однак якщо додати до нього порожній рядок, він раптом з’явиться:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Ви можете оголосити змінну, встановити її на нуль, а поведінка ідентична, за винятком того, що ви побачите "null", роздруковані проти "undefined". Це дійсно невелика різниця.

Можна навіть порівняти змінну, яка не визначена з нульовою, або навпаки, і умова буде вірною:

undefined == null
null == undefined

Однак вони вважаються двома різними типами. Хоча невизначений тип є самим собою, нуль вважається спеціальним значенням об'єкта. Ви можете побачити це за допомогою typeof (), який повертає рядок, що представляє загальний тип змінної:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

Запуск вищевказаного сценарію призведе до наступного виводу:

undefined
object

Незалежно від того, що вони різного типу, вони все одно будуть діяти однаково, якщо ви спробуєте отримати доступ до члена будь-якого з них, наприклад, це означає, що вони викинуть виняток. З WSH ви побачите жахливий "'ім'я' недійсне або не об'єкт", і це якщо вам пощастить (але це тема для іншої статті).

Ви можете чітко встановити змінну, яку не можна визначити, але я дуже раджу проти неї. Я рекомендую лише встановити змінні значення null і залишити невизначене значення для речей, які ви забули встановити. У той же час, я дуже закликаю вас завжди встановлювати кожну змінну. У JavaScript є ланцюг областей, що відрізняється від мов у стилі C, легко плутаючи навіть ветеранських програмістів, а встановлення змінних на null є найкращим способом запобігання помилок на його основі.

Інший випадок, коли ви побачите невизначене спливаюче вікно - це під час використання оператора видалення. Ті з нас із С-світу можуть неправильно трактувати це як руйнування об'єкта, але це не так. Ця операція робить видалення індекса з масиву або члена з Object. Для Arrays це не впливає на довжину, а скоріше, що індекс індексу вважається невизначеним.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Результатом вищезазначеного сценарію є:

0.) a
1.) undefined
2.) c

Ви також отримаєте невизначене повернення під час читання підписки або члена, який ніколи не існував.

Різниця між null та undefined полягає в тому, що JavaScript ніколи не встановлюватиме щось null, зазвичай це робимо ми. Хоча ми можемо встановити змінні значення невизначеними, ми віддаємо перевагу нульовим, оскільки це не те, що коли-небудь робиться для нас. Коли ви налагоджуєте це, це означає, що все, що встановлено на нуль, - це власне, а не JavaScript. Крім того, ці два особливі значення майже еквівалентні.

(додавання символів через відсутність символів, тому мені дозволено публікувати це.)

null - це спеціальне ключове слово, яке вказує на відсутність значення.

подумайте про це як про значення як:

• "foo" - це рядок,
• правда булева,
• 1234 - це число,
• null не визначено.

властивість undefined вказує на те, що змінній не було призначено значення, включаючи також null. Подібно до

var foo;

визначена порожня змінна має nullтип данихundefined

Обидва вони представляють значення змінної без значення

AND null не являє собою рядок, яка не має значення - порожній рядок-

Подібно до

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Тепер якщо

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

АЛЕ

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

Так у кожного є свій спосіб використання

невизначено використовувати його для порівняння змінного типу даних

null використовувати його для очищення значення змінної

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null : відсутність значення для змінної; невизначений : відсутність самої змінної;

..where змінною є символічна назва, пов'язана зі значенням.

JS міг би бути досить добрим, щоб неявно вписати щойно оголошені змінні з null , але це не так.

Будь ласка уважно прочитайте наступне. Це усуне всі ваші сумніви щодо різниці між null та undefined у JavaScript. Також ви можете використовувати функцію утиліти, наведену нижче, щоб точно визначити типи.

У JavaScript ми можемо мати такі типи змінних.

1. Недекларовані змінні
2. Декларовані, але непризначені змінні
3. Змінні, присвоєні буквально невизначеним
4. Змінні, присвоєні буквальним null
5. Змінні, присвоєні будь-чому, окрім невизначеного або нульового

Далі пояснюється кожен з цих випадків по одному

1. Недекларовані змінні : Наступне справедливо для незадекларованих змінних

   • Перевірити можна лише за допомогою typeof (), який повертає рядок 'undefined'
   • Неможливо перевірити з допомогою == або === або якщо оператор чи умовний ? (кидає Посилання Помилка)

2. Декларовані, але непризначені змінні

   • typeof повертає рядок 'undefined'
   • == перевірити з нульовим поверненням true
   • == перевірити з невизначеним поверненням true
   • === перевірка з нульовим поверненням false
   • === перевірити з невизначеним поверненням true
   • якщо або умовний оператор ? повертає помилкове

3. Змінні, присвоєні буквально невизначеним : Ці змінні трактуються аналогічно як оголошені, але непризначені змінні .

4. Змінні, присвоєні буквальним null

   • typeof повертає рядок 'object'
   • == перевірити з нульовим поверненням true
   • == перевірити з невизначеним поверненням true
   • === перевірити з нульовим поверненням true
   • === перевірити з невизначеним поверненням false
   • якщо або умовний оператор ? повертає помилкове

5. Змінні, присвоєні будь-чому, окрім невизначеного або нульового

   • typeof повертає один із таких рядків: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

Далі наведено алгоритм правильної перевірки типу змінної:

1. Перевірте наявність незадекларованого / непризначеного / призначеного для невизначеного за допомогою typeof . return, якщо повертається рядок 'undefined' .
2. Перевірте наявність нуля, використовуючи === . поверніть "null", якщо це правда .
3. Перевірте фактичний тип за допомогою typeof . тип повернення, якщо він не дорівнює 'об'єкт'
4. Виклик Object.prototype.toString.call (о) , щоб визначити фактичний тип об'єкта. Він повинен повернути рядок типу "[object ObjectType]" для всіх вбудованих об'єктів, визначених Javascript або DOM . Для визначених користувачем об’єктів повертається "[object Object]"

Ви також можете використовувати наступну функцію утиліти для визначення типів. В даний час він підтримує всі типи ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

Ви можете вважати, що невизначене відображає системний рівень, несподівану або схожу на помилку відсутність значення та null для відображення програмного рівня, нормальної чи очікуваної відсутності значення.

через JavaScript: Постійний посібник

Я поясню undefined, nullі Uncaught ReferenceError:

1 - Uncaught ReferenceError: змінна не була оголошена у вашому сценарії, немає посилання на цю змінну
2 - undefined: змінна оголошена, але не ініціалізована
3 - null: змінна оголошена і є порожнім значенням

Не визначено означає, що змінна була оголошена, але не має значення:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null - це призначення:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

null та undefined - два різних типи об'єктів, які мають наступне спільне:

• обидва можуть містити лише одне значення, нульове та невизначене відповідно;
• обидва не мають властивостей чи методів, і спроба прочитати будь-які властивості будь-якого призведе до помилки під час виконання (для всіх інших об'єктів ви отримуєте значення невизначене, якщо намагаєтесь прочитати неіснуюче властивість);
• значення нуля і невизначений вважаються рівним один одному і нічого по ==і !=операторами.

Однак подібність закінчується тут. Один раз існує принципова різниця в тому, як реалізуються ключові слова нульові та невизначені . Це не очевидно, але розглянемо наступний приклад:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

невизначені , NaN та нескінченність це лише назви попередньо ініціалізованих "надглобальних" змінних - вони ініціалізуються під час виконання і можуть бути замінені звичайною глобальною або локальною змінною з тими ж назвами.

Тепер спробуємо те ж саме з null :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

На жаль! нульове , істинне та хибне є зарезервованими ключовими словами - компілятор не дозволить вам використовувати їх як імена змінних чи властивостей

Інша відмінність полягає в тому, що undefined є примітивним типом, а null - типом об'єкта (що вказує на відсутність посилання на об'єкт). Розглянемо наступне:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Крім того, існує важлива різниця в тому, як в числовому контексті трапляються нульові та невизначені :

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null стає 0 при використанні в арифметичних виразах або числових порівняннях - подібно до false , це в основному лише особливий вид "нуля". з іншого боку, невизначене - це справжнє "ніщо" і стає NaN ("не числом"), коли ви намагаєтесь використовувати його в числовому контексті.

Зверніть увагу , що нуль і Невизначені отримує спеціальне лікування від ==і !=операторів, але ви можете перевірити істинне числове рівність і Ь з виразом .(a >= b && a <= b)

тл; д-р

Використовуйте nullдля встановлення змінної, яку ви знаєте, що це Об'єкт.

Використовуйте undefinedдля встановлення змінної, тип якої змішаний.

Це моє використання як 5 примітивів, так і типу Object, і це пояснює різницю між «випадком використання» undefinedабо null.

Рядок

Якщо ви знаєте, що змінна є лише рядком, тоді як весь життєвий цикл, за умовою, ви можете її ініціалізувати, щоб "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Номер

Якщо ви знаєте, що змінною є лише число, тоді як весь життєвий цикл, за умовою, ви можете її ініціалізувати, щоб 0(або NaNякщо 0це важливе значення у вашому використанні):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

або

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Булева

Якщо ви знаєте, що змінна є лише булевою, тоді як весь життєвий цикл, за умовою, ви можете її ініціалізувати, щоб false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Об'єкт

Якщо ви знаєте, що змінна є лише Об'єктом, тоді як весь життєвий цикл, за умовою, ви можете ініціалізувати її null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Примітка. Інтелектуальне використання off null має бути хибною версією Об'єкта, тому що Об'єкт є завжди trueі тому, що typeof nullповертається object. Це означає, що typeof myVarObjectповертає послідовне значення як для об’єкта, так і для нуля.

Усі

Якщо ви знаєте, що змінна має змішаний тип (будь-який тип протягом усього життєвого циклу), за умовою ви можете її ініціалізувати, щоб undefined.

nullє особливим значенням, що означає "немає значення". nullє спеціальним об'єктом, оскільки typeof nullповертає "об'єкт".

З іншого боку, undefinedозначає, що змінна не була задекларована або не отримала значення.

Найкращий спосіб зрозуміти різницю - спочатку очистити свою думку від внутрішнього функціонування JavaScript і просто зрозуміти відмінності в значенні між:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Існує різниця у значенні між цими трьома випадками, а JavaScript розрізняє два останні випадки з двома різними значеннями nullта undefined. Ви можете використовувати ці значення явно, щоб передати ці значення.

То які деякі проблеми, пов’язані з JavaScript, виникають у зв'язку з цією філософською основою?

1. Оголошена змінна без ініціалізатора отримує значення, undefinedоскільки ви ніколи нічого не говорили про те, що було призначене значення.

   let supervisor;
   assert(supervisor === undefined);

2. Властивість об'єкта, який ніколи не був встановлений, оцінюється undefinedтому, що ніхто ніколи нічого не говорив про цю властивість.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nullі undefined"схожі" один на одного тому, що так сказав Брендан Ейх. Але вони категорично не рівні між собою.

   assert(null == undefined);
   assert(null !== undefined);

4. nullі, на undefinedщастя, мають різні типи. nullналежить до типу Nullі undefinedдо типу Undefined. Це в специфікації, але ти цього ніколи не дізнаєшся через typeofдивацтво, яке я тут не повторю.

5. Функція, що доходить до кінця її тіла без явного заяви про повернення, повертається, undefinedоскільки ви нічого не знаєте про те, що вона повернулася.

До речі, в JavaScript існують і інші форми "небуття" (добре вивчити Філософію ....)

• NaN
• Використання змінної, яка ніколи не була оголошена та отримана a ReferenceError
• Використання letабо constвизначеної локальної змінної у її тимчасовій мертвій зоні та отримання aReferenceError

• Порожні комірки в розріджених масивах. Так, це навіть undefinedнезважаючи на те, що вони порівнюються ===з невизначеними.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

У JavasSript є 5 примітивних типів даних String, Number, Boolean, null та undefined. Спробую пояснити на простому прикладі

скажемо, у нас проста функція

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

також у наведеній вище функції, якщо (a == null) те саме, що якщо (! a)

тепер, коли ми викликаємо цю функцію, не передаючи параметр a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

також

var a;
alert(typeof a); 

це дасть невизначеність; ми оголосили змінну, але не призначили цій змінній жодного значення; але якщо ми пишемо

var a = null;
alert(typeof a); will give alert as object

тому null є об’єктом. таким чином ми призначили нульове значення "a"

Для undefinedтипу, існує один і тільки одне значення: undefined.

Для nullтипу, існує один і тільки одне значення: null.

Тож для обох етикетка є і своїм типом, і значенням.

Різниця між ними. Наприклад:

• null - порожнє значення
• undefined є відсутнім значенням

Або:

• undefined ще не мала значення
• null мав значення і більше не має

Насправді nullце спеціальне ключове слово , а не ідентифікатор, і тому ви не можете розглянути його як змінну, якій слід призначити.

Однак undefinedце ідентифікатор . І в non-strictрежимі, і в strictрежимі ви можете створити локальну змінну імені, що не визначено. Але це одна жахлива ідея!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Коли ви оголошуєте змінну в javascript, їй присвоюється значення undefined. Це означає, що змінна є недоторканою і їй може бути присвоєно будь-яке значення в майбутньому. Це також означає, що ви не знаєте значення, яке має містити ця змінна під час декларування.

Тепер ви можете явно призначити змінну null. Це означає, що змінна не має жодного значення. Наприклад - деякі люди не мають прізвища. Тож у такому випадку краще присвоїти значення null змінної імені особи людини.

Тепер припустімо, що хтось отримує доступ до змінної імені вашого особи об'єкта, і це має значення undefined. Він не знає, забув розробник ініціалізувати цю змінну чи вона не мала жодного значення. Якщо воно має значення null, то користувач може легко зробити висновок, що середнє ім’я не має жодного значення, і це не є недоторканою змінною.

null та undefined обидва використовуються для відображення відсутності деякого значення.

var a = null;

a ініціалізовано та визначено.

typeof(a)
//object

null - об’єкт у JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b не визначено та неініціалізовано

невизначені властивості об'єкта також не визначені. Наприклад, "x" не визначено на об'єкті c, і якщо ви спробуєте отримати доступ до cx, він повернеться невизначеним.

Як правило, ми присвоюємо null змінним, не визначеним.

Перша стаття Райана Морра на цю тему ...

"Як правило, якщо вам потрібно призначити змінну чи властивість, що не має значення, передати її функції або повернути її з функції, нуль майже завжди є найкращим варіантом. Простіше кажучи, JavaScript використовує невизначене, і програмісти повинні використовувати null. "

Див. Дослідження вічної безодні Нульового та Невизначеного

Як Null, так і невизначені в JavaScript вказують на відсутність значення.

var a = null; //variable assigned null value
var b;  // undefined

Незважаючи на те, що обидва існують для відсутності значення, але: Undefined фактично означає, що змінна не ініціалізується. Функції, які не повертають нічого, і параметри функцій, для яких не вводиться значення, повертається невизначене значення. Використовуйте суворий оператор рівності ===, щоб розрізняти нульове та невизначене.

Довідка: http://www.thesstech.com/javascript/null-and-undefined

Добре, ми можемо заплутатися , коли ми чуємо про nullта undefined, але давайте почнемо це просто, вони обидва falsy і багато в чому схожі, але дивно частина JavaScript, зробити їх кілька суттєвих відмінностей, наприклад, TypeOf null це в 'object'той час як TypeOf undefined є 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Але якщо перевірити їх ==як нижче, ви побачите, що вони обоє хибні :

null==undefined; //true

Також ви можете призначити nullвластивість об'єкта або примітиву, тоді як цього undefinedможна просто досягти, не привласнюючи нічого.

Я створюю швидке зображення, щоб показати вам відмінності з першого погляду.

Оскільки typeof повертає undefined, undefined - це тип, де як null є ініціалізатором, вказує змінні точки на жоден об'єкт (практично все в Javascript є об'єктом).

У javascript всі змінні зберігаються як пари ключових значень. Кожна змінна зберігається як ім'я змінної: змінна_значення / посилання .

undefined означає, що змінній було надано простір в пам'яті, але їй не присвоєно жодного значення. Як найкраща практика, ви не повинні використовувати цей тип як завдання.

У такому випадку як позначити, коли ви хочете, щоб змінна була без значення в наступній точці коду? Ви можете використовувати тип null , який також є типом, який використовується для визначення того ж самого, відсутності значення, але воно не є таким, як невизначене, так як у цьому випадку ви фактично маєте значення в пам'яті. Це значення є нульовим

Обидва схожі, але використання та значення різні.

Я хочу додати дуже тонка різниця між nullі undefinedце добре , щоб знати , коли ви намагаєтеся дізнатися Vanilla JavaScript (JS) з нуля:

• nullє зарезервованим ключовим словом у JS, тоді як undefinedє змінною глобального об'єкта середовища виконання, у якому ви перебуваєте.

Під час написання коду цю різницю не можна ідентифікувати як обидві, nullі undefinedвони завжди використовуються в RHS оператора JavaScript. Але коли ви використовуєте їх у LHS виразу, ви можете легко спостерігати цю різницю. Тож інтерпретатор JS інтерпретує наведений нижче код як помилку:

var null = 'foo'

Нижче наведено помилку:

Uncaught SyntaxError: Несподіваний маркер null

Хоча нижче код працює успішно, хоча я не рекомендую робити це в реальному житті:

var undefined = 'bar'

Це працює, тому що undefinedє змінною глобального об'єкта (об'єкт вікна браузера у випадку JS на стороні клієнта)

Різниця між undefinedі nullмінімальна, але є різниця. Змінна, значення undefinedякої ніколи не було ініціалізовано. Змінна, значення якої nullявно було дано значення null, що означає, що змінна була явно встановлена ​​таким, що не має значення. Якщо порівнювати undefinedі null, використовуючи null==undefinedвираз, вони будуть рівні.

В основному, Undefined - це глобальна змінна, яку Javascript створює під час виконання, будь то null означає, що жодне значення не призначило змінну (насправді null сам по собі є об'єктом).

Візьмемо приклад:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Не визначено , це ви отримаєте як вихід.

Тепер,

        x=5;
        y=null;
        z=x+y;

і ви отримаєте 5 як вихід. Ось основна відмінність між невизначеним та нульовим

null - Це значення присвоєння, яке використовується зі змінною для представлення ніякого значення (це об'єкт).

undefined - Це змінна, яка не має присвоєного їй значення, тому JavaScript призначить їй невизначене (це тип даних).

незадекларований - якщо змінна взагалі не створена, вона відома як незадекларована.

Заціни. Вихід коштує тисячі слів.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Дивись також:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comppare_Operators

Ура!

Обидва спеціальні значення передбачають порожній стан.

Основна відмінність полягає в тому, що undefined представляє значення змінної, яка ще не була ініціалізована, тоді як null являє собою навмисну ​​відсутність об'єкта.

Визначене число змінної, однак не присвоюється початковому значенню:

let number;
number; // => undefined

числова змінна не визначена, що чітко вказує на неініціалізовану змінну

Та ж неініціалізована концепція трапляється, коли доступ до неіснуючої властивості об'єкта:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Оскільки властивість lastName не існує в obj, JavaScript правильно оцінює obj.lastName на невизначений.

В інших випадках ви знаєте, що змінна розраховує утримати об'єкт або функцію для повернення об'єкта. Але чомусь ви не можете створити інстанцію об'єкта. У такому випадку null є значущим показником відсутнього об'єкта.

Наприклад, clone () - це функція, що клонує звичайний JavaScript-об’єкт. Очікується, що функція поверне об'єкт:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Однак, клон () може викликатись аргументом без об’єкта: 15 або null (або загалом примітивним значенням, null або undefined). У такому випадку функція не може створити клон, тому повертає null - індикатор відсутнього об'єкта.

Оператор typeof розрізняє два значення:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

Оператор суворої якості === правильно відрізняє невизначений від null:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

Крім іншого значення, існують і інші відмінності:

1. Деструкція об'єкта працює по-різному для цих двох значень:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () зберігає, nullале опускаєundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. оператор typeof

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Якщо змінна не ініціалізується, то вона не визначена. undefined не є об’єктом. Приклад: var MyName; console.log (тип MyName);

Перевірте консоль журналу в інструменті розробки, він буде надрукований як невизначений.

null - це об'єкт. Якщо ви хочете, щоб якась змінна була null, тоді використовується null.null змінна існує, але значення не відомо. Їй слід присвоїти програму граматично. null не ініціалізується автоматично.

Приклад: var MyName = null; console.log (тип MyName); Перевірте журнал csole в інструменті розробки, це буде об’єкт.