Почему null является объектом и в чем разница между null и undefined?

Вы: Что такое name?^(*)

JavaScript: name? Что за name? Я не знаю, о чем ты говоришь. Ты никогда не упоминал никакого name раньше. Может, ты имеешь в виду какой-то другой скриптовый язык на стороне клиента?

name = null;

Вы: Что такое name?

JavaScript: Я не знаю.

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

Важно помнить, что null концептуально не то же самое, что false или "", даже если они эквивалентны после приведения типов, например:

name = false;

Вы: Что такое name?

JavaScript: Логическое значение false.

name = '';

Вы: Что такое name?

JavaScript: Пустая строка.

^*: В данном контексте name обозначает переменную, которая никогда не была определена. Однако это может быть любая неопределенная переменная, хотя name — это свойство практически любого элемента формы HTML. Оно появилось очень давно, задолго до id. Это удобно, потому что id должен быть уникальным, а name — нет.

Разница между null и undefined может быть обобщена следующим образом:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined); // true
alert(null == undefined);  // true

Проверка object == null отличается от проверки if (!object).

Во втором случае проверка эквивалентна !Boolean(object), так как унарный оператор ! автоматически преобразует правый операнд в логическое значение.

Поскольку Boolean(null) равно false, то !false === true.

Таким образом, если ваш объект не равен null, но равен false, 0 или "", проверка пройдет успешно, потому что:

alert(Boolean(null)); // false
alert(Boolean(0));    // false
alert(Boolean(""));   // false

Почему null считается объектом в JavaScript?

Это ошибка проектирования JavaScript, которую сейчас невозможно исправить. На самом деле, null должен был быть типом null, а не типом object, или же его вовсе не должно было быть. Это приводит к необходимости дополнительной проверки (которая иногда забывается) при определении настоящих объектов и является источником багов.

Вторая часть вопроса:

Является ли проверка

if (object == null) 
  // Выполнить что-то

такой же, как

if (!object) 
  // Выполнить что-то

Обе проверки всегда ложные, кроме случаев, когда:

• object равен undefined или null: обе проверки вернут true.
• object является примитивом и равен 0, "" или false: первая проверка вернет false, вторая — true.

Если же object не примитив, а реальный объект, например, new Number(0), new String("") или new Boolean(false), тогда обе проверки будут ложными.

Таким образом, если рассматривать 'object' как реальный объект, обе проверки всегда будут одинаковы. Если примитивы рассматриваются, проверки получаются разными для 0, "" и false.

В случаях, подобных object==null, неожиданные результаты могут стать источником ошибок. Использование == не рекомендуется, вместо этого лучше использовать ===.

Третья часть вопроса:

И также:

Какова разница между null и undefined?

В JavaScript одной из значительных разниц является то, что null имеет тип object, а undefined — тип undefined.

В JavaScript выражение null==undefined вернет true, считается равным, если игнорировать тип. Почему так решили, а 0, "" и false не равны, не знаю. Это кажется произвольным мнением.

В JavaScript null===undefined не верно, поскольку типы должны совпадать при использовании ===.

На самом деле, null и undefined идентичны, так как оба представляют собой отсутствие значения. Так же, как и 0 и "", а может, и пустые контейнеры [] и {}. Столь множество типов одного и того же "ничего" — это рецептура для ошибок. Один или ни одного типа было бы лучше. Я бы старался использовать как можно меньше типов.

'false', 'true' и '!' — это еще одна каша, которую можно упростить. Например, if(!x) и if(x) вполне достаточно; не нужны true и false.

Объявленная var x имеет тип undefined, если значение не задано, но это должно быть аналогично тому, как если бы x вообще не было объявлено. Еще одним источником ошибок является пустой контейнер "ничто". Поэтому лучше объявлять и определять переменную одновременно, например, var x=1.

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

undefined===undeclared===null===0===""===[]==={}===nothing

И, возможно, все они должны вызывать исключения.

В JavaScript, оператор typeof возвращает тип значения переменной. Рассмотрим следующие примеры:

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

Значение null представляет собой намеренное отсутствие какого-либо объектного значения. Это одно из примитивных значений JavaScript и рассматривается как "ложное" (falsy) при булевых операциях.

var x = null; // x объявлена и инициализирована со значением null
var y;        // y объявлена, но не инициализирована, поэтому она undefined

Таким образом, переменная x объявлена и присвоено значение null, а y объявлена без задания значения, поэтому она имеет значение undefined.

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

Некоторые уточнения:

null и undefined это два разных значения. Первое представляет отсутствие значения для имени, а второе — отсутствие самого имени.

Что происходит в if, можно объяснить так: для if( o ) осуществляется следующее:

Выражение в скобках o оценивается, после чего if начинает применять преобразование типов к значению этого выражения — в нашем случае к o.

Ложные (falsy) значения в JavaScript, которые будут преобразованы в false, это: '', null, undefined, 0 и false.