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

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

Ответ 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 - это сам тип (undefined), а null - объект.

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

а также

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

Ответ 2

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

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

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

Когда вы объявляете переменную через var и не даете ей значения, она будет иметь значение undefined. Само по себе, если вы попытаетесь выполнить WScript.Echo() или alert(), вы ничего не увидите. Однако, если вы добавите в него пустую строку, то вдруг она появится:

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

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

Вы даже можете сравнить переменную undefined с нулевой или наоборот, и условие будет истинным:

undefined == null
null == undefined

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

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

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

undefined
object

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

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

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

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

Результат выше script:

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

Вы также получите undefined, возвращенный при чтении индекса или члена, который никогда не существовал.

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

Ответ 3

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

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

"foo" - строка,
true имеет значение boolean,
1234 - номер,
null - undefined.

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

Ответ 4

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

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

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

Ответ 5

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

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

Необъявленные переменные
Объявленные, но неназначенные переменные
Переменные, назначенные с буквальным undefined
Переменные, назначенные с буквальным null
Переменные, назначенные с помощью чего-либо, кроме undefined или null

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

Необъявленные переменные. Следующее выполняется для необъявленных переменных
- Может быть проверен только typeof(), который возвращает строку 'undefined'
- Невозможно проверить с помощью == или === или , если или условного оператора ? (бросает Исходная ошибка)
Объявленные, но неназначенные переменные
- typeof возвращает строку 'undefined'
- == с null возвращает true
- == с undefined возвращает true
- === с null возвращает false
- === с undefined возвращает true
- , если или условный оператор ? возвращает false
Переменные, назначенные с буквальным undefined. Эти переменные обрабатываются аналогично Объявленные, но не назначенные переменные.
Переменные, назначенные с буквальным null
- typeof возвращает строку 'object'
- == с null возвращает true
- == с undefined возвращает true
- === с null возвращает true
- === с undefined возвращает false
- , если или условный оператор ? возвращает false
Переменные, назначенные с помощью чего-либо, кроме undefined или null
- typeof возвращает одну из следующих строк: 'string', 'number', 'boolean', 'function', "объект" , "символ"

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

Отметьте необъявленный/ неназначенный/, назначенный undefined, используя typeof. return, если возвращается строка 'undefined'.
Проверьте null, используя ===. return 'null', если true.
Проверить фактический тип с помощью typeof. return type , если не равен 'object'
Вызовите 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 
}

Ответ 6

(добавление символов из-за отсутствия символов, поэтому я могу опубликовать это.)

Ответ 7

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

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

Ответ 8

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

1 - Uncaught ReferenceError: переменная не была объявлена  в вашем script, ссылка на этот varaible отсутствует /

2 - undefined: переменная объявлена, но не инициализирована
3 - null: Объявлена переменная и является пустым значением

Ответ 9

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

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

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

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

Ответ 10

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

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

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

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

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

Теперь попробуем одно и то же: null:

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

Oops! 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).

Ответ 11

null - это специальное значение, означающее "no value". null - это специальный объект, потому что typeof null возвращает "объект".

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

Ответ 12

ТЛ; дг

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

Boolean

Если вы знаете, что переменная является только логической, тогда как весь жизненный цикл, по соглашению, вы можете инициализировать его, 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 должно быть фальшивой версией объекта, потому что Object всегда true, а потому, что typeof null возвращает object. Это означает, что typeof myVarObject возвращает согласованное значение как для объекта, так и для нулевого типа.

Все

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

Ответ 13

В 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);

это даст undefined; мы объявили переменную, но мы не присвоили ей никакой ценности; но если мы напишем

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

так что null - это объект. таким образом, мы присвоили значение null в 'a'

Ответ 14

null - это ключевое слово языка, которое оценивает специальное значение, которое обычно используется для указывают на отсутствие значения. Использование оператора typeof в null возвращает строку "object", указывая, что null можно рассматривать как значение специального объекта, которое указывает "нет объекта". На практике, однако, нуль обычно рассматривается как единственный член его собственный тип, и его можно использовать для указания "нет значения" для чисел и строк, а также объекты. Большинство языков программирования имеют эквивалент JavaScripts null: вы можете быть знакомым с ним как null или nil.

JavaScript также имеет второе значение, которое указывает на отсутствие значения. Значение undefined представляет собой более глубокий вид отсутствия. Это значение переменных, которые не были инициализируется и значение, которое вы получаете при запросе значения свойства или массива объекта элемент, который не существует. Значение undefined также возвращается функциями, которые имеют нет возвращаемого значения и значения параметров функции, для которых не задан аргумент. undefined - это предопределенная глобальная переменная (не ключевое слово языка, такое как null), которое инициализируется значением undefined. В ECMAScript 3 undefined является переменной чтения/записи, и его можно установить на любое значение. Эта ошибка исправлена в ECMAScript 5 и undefined доступен только для чтения в этой версии языка. Если вы примените оператор typeof к значению undefined, он возвращает "undefined", указывая, что это значение является единственным член специального типа.

Несмотря на эти различия, null и undefined оба указывают на отсутствие значения и часто могут использоваться взаимозаменяемо. Оператор равенства == считает их равными. (Используйте для этого строгого оператора равенства ===). Оба являются значениями ложности - они вести себя как false, когда требуется логическое значение. Ни null, ни undefined не имеют любые свойства или методы. На самом деле, используя. или [] для доступа к собственности или методу этих значения вызывает TypeError.

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

Ответ 15

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

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

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

Ответ 16

Лучший способ понять разницу - сначала разобраться в внутренней работе 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, которые возникают из-за этой философской основы?

Объявленная переменная без инициализатора получает значение undefined потому что вы никогда ничего не говорили о том, что это за значение.
```
let supervisor;
assert(supervisor === undefined);
```
Свойство объекта, который никогда не был установлен, оценивается как undefined потому что никто никогда ничего не говорил об этом свойстве.
```
const dog = { name: 'Sparky', age: 2 };
assert(dog.breed === undefined);
```
null и undefined "похожи" друг на друга, потому что Брендан Эйч так сказал. Но они категорически не равны друг другу.
```
assert(null == undefined);
assert(null !== undefined);
```
null и undefined счастью, имеют разные типы. null относится к типу Null и undefined типу Undefined. Это в спецификации, но вы никогда не знаете, это из-за typeof странности, которые я не буду повторять здесь.
Функция, достигающая конца своего тела без явного оператора 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 ]
```

Ответ 17

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

var a = null;

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

typeof(a)
//object

null - это объект в JavaScript

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

var b;

b undefined и неинициализированный

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

Обычно мы присваиваем значение null переменным, а не undefined.

Ответ 18

Оба Null и undefined в JavaScript указывают на отсутствие значения.
var a = null; //variable assigned null value
var b;  // undefined
Несмотря на то, что оба существуют для отсутствия значения, но: Undefinedфактически означает, что переменная не инициализирована. Возвращаемые функции ничего и функциональные параметры, для которых не задано значение, Возвращается значение undefined. Используйте строгий оператор равенства === to различать нуль и undefined.

Ссылка: http://www.thesstech.com/javascript/null-and-undefined

Ответ 19

Для типа 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();

Ответ 20

Хорошо, мы можем запутаться, когда узнаем о null и undefined, но давайте начнем с простого: они оба ложные и во многом схожи, но странная часть JavaScript делает их парой существенных отличий, например, typeof null 'object' то время как typeof undefined равен 'undefined'.

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

Но если вы проверите их с == как показано ниже, вы увидите, что они оба ложные:

null==undefined; //true

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

Я создаю быстрое изображение, чтобы показать различия для вас с первого взгляда.

Ответ 21

Как typeof возвращает undefined, undefined - это тип, где в качестве нулевого значения инициализатор указывает, что переменная не указывает на какой-либо объект (практически все в Javascript является объектом).

Ответ 22

Пер Райан Морр подробно описывает эту тему...

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

См. Изучение вечной бездны нулей и Undefined

Ответ 23

В javascript все переменные сохраняются как пары значений ключа. Каждая переменная хранится как variable_name: variable_value/reference.

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

В этом случае, как обозначить, когда вы хотите, чтобы переменная была без значения в более поздней точке кода? Вы можете использовать тип null, который также является типом, который используется для определения того же объекта, отсутствия значения, но это не то же самое, что и undefined, так как в этом случае вы действительно имеете значение в памяти, Это значение равно null

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

Ответ 24

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

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

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

var null = 'foo'

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

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

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

var undefined = 'bar'

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

Ответ 25

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

undefined - это переменная, которой не присвоено никакого значения, поэтому JavaScript назначит ей неопределенное значение (это тип данных).

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

Ответ 26

Разница между undefined и null минимальна, но есть разница. Значение переменной undefined никогда не было инициализировано. Переменная, значение которой null, явно задано значением null, что означает, что в переменной явно указано значение не имеющее значения. Если вы сравниваете undefined и null с помощью выражения null==undefined, они будут равны.

Ответ 27

В принципе, Undefined - это глобальная переменная, которую javascript создает во время выполнения, означает ли null, что значение не присвоено переменной (фактически null - это сам объект).

Возьмем пример:

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

Undefined, что вы получите как вывод.

Теперь

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

и вы получите 5 в качестве вывода. Главное отличие между Undefined и null

Ответ 28

С JavaScript значение null для объектов, undefined для переменных, свойств и методов.

Чтобы быть нулевым, объект должен быть определен, иначе он будет undefined.

Если вы хотите проверить, существует ли объект, это вызовет ошибку, если объект undefined:

Неправильно:

if (myObj !== null && typeof myObj !== "undefined")

Из-за этого вы должны сначала проверить типof():

Правильно:

if (typeof myObj !== "undefined" && myObj !== null)

Ответ 29

Когда значение равно null, оно ничего и ничего не содержит. Пустое значение или переменная все еще заполнено; его просто полно пустоты. Пустота отличается от нуля, а это просто ничего. Например, определение переменной и ее значение для пустой строки выглядит следующим образом:

 var myVariable = '';

Переменная myVariable пуста, но она не является нулевой.

Undefined - это состояние, иногда используемое как значение, для представления переменной, которая еще не указала значение. таких как var abcd;, Это состояние отличается от нуля, хотя оба значения null и undefined могут оцениваться одинаково.

Ответ 30

undefined означает, что переменная была объявлена, но ей еще не присвоено значение.
null - это значение присваивания. Он может быть назначен переменной как представление без значения.
undefined и null - два разных типа:

undefined является самим типом (undefined) а null - объект.

Неназначенные переменные инициализируются JavaScript со значением по умолчанию undefined.
JavaScript никогда не устанавливает значение null. Это должно быть сделано программно.