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

Question

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

Answer 1

В 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'

Answer 2

Я выбрал это из здесь

Неопределенное значение - это примитивное значение, используемое, когда переменная не имеет было присвоено значение.

Нулевое значение - это примитивное значение, представляющее пустое значение или несуществующая ссылка.

Когда вы объявляете переменную через var и не присваиваете ей значение, оно будет иметь неопределенное значение. Само по себе, если вы попытаетесь 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. Кроме того, эти два специальных значения почти эквивалентны.

Answer 3

null - это специальное ключевое слово, которое указывает на отсутствие значения.

думать о нем как о значении, например:

• "foo" это строка,
• true это логическое значение,
• 1234 это число,
• значение null не определено.

---

undefined свойство указывает, что переменной не было присвоено значение, в том числе и значение NULL.Например,

var foo;

---

определенная пустая переменная null типа данных undefined

---

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

И 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

SO каждый из них имеет свой собственный способ использования

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

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

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

Answer 4

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

.. где переменная - это символическое имя, связанное со значением.

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

Answer 5

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

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

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

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

1. Необъявленные переменные : Следование выполняется для необъявленных переменных

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

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

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

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

4. переменным, назначенным с помощью литерала null

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

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

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

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

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

Вы также можете использовать следующую служебную функцию для определения типов.В настоящее время он поддерживает все типы 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 
}

Answer 6

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

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

Answer 7

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

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

Answer 8

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

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

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

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

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

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

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

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

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

Answer 9

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

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

Нулевое назначение:

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

Answer 10

ТЛ; др

Используйте 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"

Object

Если вы знаете, что переменная является только объектом, в то время как весь жизненный цикл, по соглашению, вы можете инициализировать ее как null:

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

Примечание: разумное использование при нулевом значении должно быть ложной версией Объекта, потому что Объект всегда true, и потому что typeof null возвращает object. Это означает, что typeof myVarObject возвращает согласованное значение как для объекта, так и для нулевого типа.

Все

Если вы знаете, что переменная имеет смешанный тип (любой тип в течение всего жизненного цикла), то по соглашению вы можете инициализировать ее как undefined.