В чем разница между нулевым и неопределенным в JavaScript?

Я хочу знать, в чем разница между nullи undefinedв JavaScript.

В 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 и не присваиваете ей значение, оно будет иметь значение undefined. Само по себе, если вы попытаетесь WScript.Echo () или alert () это значение, вы ничего не увидите. Однако, если вы добавите к нему пустую строку, то внезапно появится:

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

Вы можете объявить переменную, установить для нее значение null, и поведение будет идентичным, за исключением того, что вы увидите распечатку «null» вместо «undefined». Это небольшая разница действительно.

Вы даже можете сравнить переменную, которая не определена, со значением NULL или наоборот, и условие будет истинным:

undefined == null
null == undefined

Они, однако, считаются двумя различными типами. В то время как undefined является типом для себя самого, null считается значением специального объекта. Это можно увидеть с помощью typeof (), который возвращает строку, представляющую общий тип переменной:

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

Запуск вышеуказанного скрипта приведет к следующему выводу:

undefined
object

Независимо от того, являются ли они разными типами, они все равно будут действовать одинаково, если вы попытаетесь получить доступ к члену любого из них, например, то есть они сгенерируют исключение. С WSH вы увидите страшное «varname» - ноль или не объект », и это, если вам повезет (но это тема для другой статьи).

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

Другой случай, когда вы увидите неопределенное всплывающее окно, - это использование оператора удаления. Те из нас, кто живет в С-мире, могут неправильно истолковывать это как уничтожение объекта, но это не так. Эта операция удаляет индекс из массива или элемент из объекта. Для массивов это не влияет на длину, скорее, этот индекс теперь считается неопределенным.

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 число,
• ноль не определено.

Свойство undefined указывает, что переменной не было присвоено значение, включая ноль. подобно

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

У каждого есть свой способ использования

undefined используйте его для сравнения типа данных переменной

null использовать его для очистки значения переменной

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

null : отсутствие значения для переменной; undefined : отсутствие самой переменной;

Переменная ..where - это символическое имя, связанное со значением.

JS может быть достаточно любезен, чтобы неявно инициировать вновь объявленные переменные с нулем , но это не так.

Пожалуйста, внимательно прочитайте следующее. Это устранит все ваши сомнения относительно различий между нулевым и неопределенным в JavaScript. Также вы можете использовать приведенную ниже функцию полезности для точного определения типов.

В JavaScript у нас могут быть следующие типы переменных.

1. Необъявленные переменные
2. Объявленные, но неназначенные переменные
3. Переменные, назначенные с литералом undefined
4. Переменные, назначенные с литералом null
5. Переменные, назначенные с чем-либо, кроме undefined или null

Следующее объясняет каждый из этих случаев один за другим

1. Необъявленные переменные : для необъявленных переменных верно следующее

   • Может быть проверено только функцией typeof (), которая возвращает строку undefined
   • Не может быть проверено с помощью == или === или оператором if или условным оператором ? (выдает ошибку ссылки)

2. Объявленные, но неназначенные переменные

   • typeof возвращает строку 'undefined'
   • == проверка с нулевым возвращает true
   • == проверить с неопределенным возвращает true
   • === проверить с нулевым возвратом false
   • === проверить с неопределенными возвращает true
   • если или условный оператор ? возвращает ложь

3. Переменные, назначенные с литералом undefined : эти переменные обрабатываются аналогично объявленным, но неназначенным переменным .

4. Переменные, назначенные с литералом null

   • typeof возвращает строку «объект»
   • == проверка с нулевым возвращает true
   • == проверить с неопределенным возвращает true
   • === проверить с нулевым возвращает true
   • === проверить с неопределенным возвратом false
   • если или условный оператор ? возвращает ложь

5. Переменные, назначенные с чем-либо, кроме undefined или null

   • typeof возвращает одну из следующих строк: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

Ниже приведен алгоритм правильной проверки типа переменной:

1. Проверьте наличие необъявленного / неназначенного / назначенного с неопределенным с помощью typeof . вернуть, если строка 'undefined' возвращается.
2. Проверьте на ноль, используя === . верните 'null', если истина .
3. Проверьте фактический тип, используя typeof . возвращаемый тип, если он не равен «объекту»
4. Вызовите Object.prototype.toString.call (o), чтобы определить фактический тип объекта. Он должен возвращать строку типа '[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 
}

Вы можете считать, что undefined представляет системное, непредвиденное или ошибочное отсутствие значения, а null - программный, нормальный или ожидаемое отсутствие значения.

через JavaScript: полное руководство

Я объясню undefined, nullи Uncaught ReferenceError:

1 - Uncaught ReferenceError: переменная не была объявлена в вашем скрипте, нет ссылки на эту переменную
2 - undefined: переменная объявлена, но не инициализирована
3 - null: переменная объявлена ​​и является пустым значением

Undefined означает, что переменная была объявлена, но не имеет значения:

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

Null - это задание:

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

null и undefined - это два разных типа объектов, которые имеют следующие общие черты:

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

Однако на этом сходство заканчивается. На этот раз есть принципиальная разница в том, как реализованы ключевые слова null и undefined . Это не очевидно, но рассмотрим следующий пример:

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

undefined , NaN и Infinity - это просто имена предварительно инициализированных «суперглобальных» переменных - они инициализируются во время выполнения и могут быть переопределены обычной глобальной или локальной переменной с теми же именами.

Теперь давайте попробуем то же самое с нулем :

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

К сожалению! null , true и false являются зарезервированными ключевыми словами - компилятор не позволит вам использовать их в качестве имен переменных или свойств

Другое отличие состоит в том, что 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

Кроме того, есть важное различие в том, как null и undefined обрабатываются в числовом контексте:

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 (!!!)

Нуль становится 0, когда используется в арифметических выражениях или числовых сравнениях - подобно ложному , это в основном просто особый вид «ноль». undefined , с другой стороны, является истинным «ничем» и становится NaN («не числом»), когда вы пытаетесь использовать его в числовом контексте.

Обратите внимание , что нуль и Неопределенные получает специальное лечение от ==и !=операторов, но вы можете проверить истинное числовое равенство и Ь с выражением .(a >= b && a <= b)

ТЛ; др

Используйте nullдля установки переменной вы знаете, что это объект.

Используйте undefinedдля установки переменной, тип которой является смешанным.

Это мое использование 5 примитивов и типа объекта, и это объясняет разницу между «вариантом использования» 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"

Примечание: разумное использование с нулевым значением должно быть ложной версией Объекта, потому что Объект всегда 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. Функция, достигающая конца своего тела без явного оператора return, возвращается, undefinedтак как вы ничего не знаете о том, что она возвратила.

Кстати, в JavaScript есть и другие формы "небытия" (хорошо бы изучать философию ....)

• NaN
• Использование переменной, которая никогда не была объявлена, и получение ReferenceError
• Использование letили constопределение локальной переменной во временной мертвой зоне и получениеReferenceError

• Пустые ячейки в разреженных массивах. Да, они даже 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);
     }
  }

также в приведенной выше функции if (a == null) совпадает с if (! 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 это объект. таким образом, мы присвоили нулевое значение «а»

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

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

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

Разница между ними. Например:

• null это пустое значение
• undefined пропущенное значение

Или:

• undefined еще не имел значения
• null имеет значение и больше не

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

Тем не менее, undefinedэто идентификатор . Однако в non-strictрежиме и strictрежиме вы можете создать локальную переменную с именем undefined. Но это одна ужасная идея!

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

foo();

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

foo();

Когда вы объявляете переменную в javascript, ей присваивается значение undefined. Это означает, что переменная не тронута и ей может быть присвоено любое значение в будущем. Это также подразумевает, что вы не знаете значение, которое эта переменная будет содержать во время объявления.

Теперь вы можете явно назначить переменную null . Это означает, что переменная не имеет никакого значения. Например - Некоторые люди не имеют отчества. Поэтому в таком случае лучше присвоить значение null переменной middlename объекта person.

Теперь предположим, что кто-то обращается к переменной middlename вашего объекта person, и она имеет значение undefined. Он не знал бы, забыл ли разработчик инициализировать эту переменную или она не имеет никакого значения. Если оно имеет значение null, то пользователь может легко сделать вывод, что middlename не имеет никакого значения и не является нетронутой переменной.

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

var a = null;

А инициализируется и определяется.

typeof(a)
//object

нуль - это объект в JavaScript

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

var b;

b не определено и неинициализировано

неопределенные свойства объекта также не определены. Например, «x» не определен для объекта c, и если вы попытаетесь получить доступ к cx, он вернет undefined.

Обычно мы присваиваем значение null переменным, которые не определены.

Тщательная статья Пера Райана Морра на эту тему ...

«Как правило, если вам нужно присвоить ненулевое значение переменной или свойству, передать его функции или вернуть его из функции, то null - почти всегда лучший вариант. Проще говоря, JavaScript использует undefined, и программисты должны использовать ноль. "

См. Изучение Вечной Бездны Нулевого и Неопределенного

И ноль, и неопределенный в 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 , который также является типом, который используется для определения того же самого, отсутствия значения, но это не то же самое, что и undefined, так как в этом случае у вас фактически есть значение в памяти. Это значение равно нулю

Оба похожи, но использование и смысл разные.

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

• nullявляется зарезервированным ключевым словом в JS, а undefinedявляется переменной глобального объекта среды выполнения, в которой вы находитесь.

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

var null = 'foo'

Это дает ниже ошибку:

Uncaught SyntaxError: неожиданный нулевой токен

Хотя приведенный ниже код работает успешно, хотя я не рекомендую делать это в реальной жизни:

var undefined = 'bar'

Это работает, потому что undefinedэто переменная в глобальном объекте (объект окна браузера в случае JS на стороне клиента)

Разница между undefinedи nullминимальна, но есть разница. Переменная, значение которой undefinedникогда не было инициализировано. Переменная, чье значение nullбыло явно задано значение null, что означает, что переменная была явно установлена, чтобы не иметь значения. Если вы сравните undefinedи nullс помощью null==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 назначит ей неопределенное значение (это тип данных).

undeclared - если переменная вообще не создается, она называется undeclared.

Проверь это. Результат стоит тысячи слов.

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/Comparison_Operators

Ура!

Оба специальных значения подразумевают пустое состояние.

Основное отличие состоит в том, что undefined представляет значение переменной, которая еще не была инициализирована, а null представляет намеренное отсутствие объекта.

Номер переменной определен, однако ему не присваивается начальное значение:

let number;
number; // => undefined

числовая переменная не определена, что ясно указывает на неинициализированную переменную

Та же неинициализированная концепция возникает при доступе к несуществующему свойству объекта:

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

Поскольку свойство lastName не существует в obj, JavaScript правильно оценивает obj.lastName как неопределенное.

В других случаях вы знаете, что переменная ожидает, чтобы содержать объект или функцию для возврата объекта. Но по какой-то причине вы не можете создать экземпляр объекта. В таком случае ноль является значимым индикатором отсутствующего объекта.

Например, 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

Однако clone () может быть вызван с необъектным аргументом: 15 или null (или, как правило, примитивное значение, null или undefined). В таком случае функция не может создать клон, поэтому она возвращает ноль - индикатор отсутствующего объекта.

Оператор typeof делает различие между двумя значениями:

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

Оператор строгого качества === правильно отличает неопределенное от нулевого:

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 (typeof MyName);

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

null - это объект. Если вы хотите, чтобы какая-либо переменная была нулевой, тогда используется значение null. Переменная null существует, но значение неизвестно. Ее следует назначать переменной программно. ноль не инициализируется автоматически.

Пример: var MyName = null; console.log (typeof MyName); Проверьте журнал csole в инструменте разработки, это будет объект.