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

(name is 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. Это полезно, потому что идентификаторы должны быть уникальными, а имена не обязательными.}

Разницу можно резюмировать в этом фрагменте:

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.

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

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

null - это не объект, это примитивное значение . Например, вы не можете добавлять к нему свойства. Иногда люди ошибочно полагают, что это объект, потому что typeof null возвращает "object". Но на самом деле это ошибка (которая может быть исправлена ​​даже в ECMAScript 6).

Разница между null и undefined заключается в следующем:

• undefined: используется JavaScript и означает «без значения». Это значение имеют неинициализированные переменные, отсутствующие параметры и неизвестные переменные.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined
  

  Однако доступ к неизвестным переменным вызывает исключение:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null: используется программистами для обозначения «нет значения», например как параметр функции.

Изучение переменной:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Как правило, вы всегда должны использовать === и никогда == в JavaScript (== выполняет все виды конверсий, которые могут привести к неожиданным результатам). Проверка x == null - это крайний случай, потому что он работает как для null, так и для undefined:

> null == null
true
> undefined == null
true

Обычный способ проверить, имеет ли переменная значение, - преобразовать его в логическое значение и посмотреть, равно ли оно true. Это преобразование выполняется оператором if и логическим оператором! ("нет").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Недостаток этого подхода: все следующие значения оцениваются как false, поэтому будьте осторожны (например, вышеупомянутые проверки не могут различить undefined и 0).

• undefined, null
• Логические: false
• Номера: +0, -0, NaN
• Строки: ""

Вы можете протестировать преобразование в логическое значение, используя Boolean в качестве функции (обычно это конструктор, который будет использоваться с new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

В чем разница между null и undefined ??

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

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

 undefined == null
 null == undefined

См. Разница в JavaScript между null и undefined для получения более подробной информации.

и с вашим новым редактированием да

if (object == null)  does mean the same  if(!object)

при тестировании, если объект ложен, они оба удовлетворяют условию только при проверке, если ложь, но не когда истинно

Проверьте здесь: Попытка Javascript

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

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

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

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

Проверяет


if (object == null)
Do something

то же самое, что

if (!object)
Do something

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

• объект не определен или равен нулю: оба значения верны.

• объект является примитивным, и 0, "" или false: первая проверка - ложь, вторая - истина.

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

Итак, если «объект» интерпретируется как реальный объект, то обе проверки всегда одинаковы. Если примитивы разрешены, то проверки различны для 0, "" и false.

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

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

А также:

В чем разница между null и undefined?

В JavaScript одно отличие состоит в том, что null имеет тип object, а undefined - тип undefined.

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

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

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

«ложь», «истина» и «!» - еще один набор червей, который можно упростить, например, достаточно только if(!x) и if(x), вам не нужны true и false.

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

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

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

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

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

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

var x = null;
var y;

x объявлен и определен как null

y объявлен, но не определен. Он объявлен без значения, поэтому он не определен.

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

Один из способов разобраться в значениях null и undefined - это понять, где они встречаются.

Ожидайте возвращаемого значения NULL в следующих ситуациях:

• Методы, запрашивающие DOM

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null
  

• Ответы JSON, полученные от запроса Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec.

• Новые функциональные возможности, которые постоянно меняются. Следующее возвращает null:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Все остальные случаи несуществования обозначаются undefined (как отмечено @Axel). Каждый из следующих отпечатков «undefined»:

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Конечно, если вы решите написать var unitialised = null; или вернуть null из метода самостоятельно, тогда у вас будет null, встречающийся в других ситуациях. Но это должно быть довольно очевидно.

Третий случай - когда вы хотите получить доступ к переменной, но вы даже не знаете, была ли она объявлена. В этом случае используйте typeof, чтобы избежать ошибки ссылки:

if(typeof unknown !== "undefined"){
    //use unknown
}

Таким образом, проверьте значение null, когда вы манипулируете DOM, имеете дело с Ajax или используете определенные функции ECMAScript 5. Во всех остальных случаях можно безопасно проверить undefined при строгом равенстве:

if(value === undefined){
  // stuff
}

Сравнение множества различных нулевых проверок в JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

Чтобы добавить к ответу В чем разница между undefined и null, от Полное руководство по JavaScript, 6-е издание, стр. 41 на этой странице:

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

TL; DR

undefined - это примитивное значение в JavaScript, указывающее на неявное отсутствие значения. Неинициализированные переменные автоматически получают это значение, а функции без явного оператора return возвращают undefined.

null также является примитивным значением в JavaScript. Он указывает на намеренное отсутствие значения объекта. null в JavaScript был разработан для обеспечения взаимодействия с Java.

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

Подробности

undefined - это примитивное значение, представляет неявное отсутствие значения. Обратите внимание, что undefined не был напрямую доступен до JavaScript 1.3 в 1998 году. Это говорит нам о том, что null должен был быть значением, используемым программистами при явном указании на отсутствие значения. Неинициализированные переменные автоматически получают значение undefined. undefined - это единственный в своем роде тип в спецификация ECMAScript.

null - примитивное значение, представляет намеренное отсутствие значения объекта. null также является единственным в своем роде типом в спецификации ECMAScript.

null в JavaScript был разработан с целью обеспечения взаимодействия с Java, как с точки зрения внешнего вида, так и с точки зрения программирования (например, мост LiveConnect Java / JS, запланированный на 1996 год). И Брендан Эйх, и другие с тех пор выразили отвращение к включению двух значений отсутствия значений, но в 1995 году Эйх был под заказом, чтобы [JavaScript] выглядел как Java.

Брендан Эйх:

Если бы у меня не было приказа руководства «Сделать это похожим на Java», и у меня было бы больше времени (трудно разоблачить эти два причинных фактора), тогда я бы предпочел самоподобное все и объектный подход: нет булевых, числовых, строковых оберток. Нет undefined и null. Вздох.

Чтобы приспособить Java-концепцию null, которая из-за строго типизированной природы Java может быть назначена только переменным, типизированным для ссылочного типа (скорее, примитивам), Эйх решил разместить специальное значение null в верхней части объекта. цепочка прототипов (т. е. вершина ссылочных типов) и включить тип null как часть набора примитивов объектного типа.

Оператор typeof был добавлен вскоре после этого в JavaScript 1.1, выпущенный 19 августа 1996 года.

Из блога V8:

typeof null возвращает object, а не null, несмотря на то, что null является отдельным типом. Чтобы понять, почему, представьте, что набор всех типов JavaScript разделен на две группы:

1. объекты (т.е. тип объекта)
2. примитивы (т.е. любое значение, не являющееся объектом)

Таким образом, null означает «нет значения объекта», тогда как undefined означает «нет значения».

Следуя этой мысли, Брендан Эйх разработал JavaScript, чтобы typeof возвращал «объект» для всех значений с правой стороны, то есть для всех объектов и нулевых значений, в духе Java. Вот почему typeof null === 'object', несмотря на то, что в спецификации указан отдельный тип null.

Поэтому Эйх разработал иерархию примитивных типов, чтобы обеспечить взаимодействие с Java. Это привело к тому, что он разместил null вместе с примитивами объектного типа в иерархии. Чтобы отразить это, когда вскоре после этого к языку был добавлен typeof, он выбрал typeof null, чтобы вернуть "object".

Удивление, выраженное разработчиками JavaScript на typeof null === "object", является результатом несоответствия импеданса (или утечки абстракции) между языком со слабой типизацией (JavaScript), который имеет как null, так и undefined, и другим строго типизированным языком (Java), который имеет только null , и в котором null строго определено для ссылки тип (не примитивный тип).

Обратите внимание, что все это логично, разумно и оправданно. typeof null === "object" - это не ошибка, а побочный эффект, связанный с необходимостью совместимости с Java.

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

Соответствующий разговор с Бренданом Эйхом, скриншот для потомков:

null и undefined оба являются ложными для равенства значений (null == undefined): они оба сворачиваются в логическое значение false. Это не один и тот же объект (null! == undefined).

undefined - это свойство глобального объекта («окно» в браузерах), но это примитивный тип, а не сам объект. Это значение по умолчанию для неинициализированных переменных и функций, заканчивающихся без оператора возврата.

null - это экземпляр Object. null используется для методов DOM, которые возвращают объекты коллекции, чтобы указать пустой результат, который предоставляет ложное значение без указания ошибки.

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

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

То, что происходит в if, происходит следующим образом для if( o ):

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

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

Следующая функция показывает, почему и способна определить разницу:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Если вы позвоните

test();

Ты получаешь

неопределенный

нулевой

Первый console.log(...) пытается получить myProperty от myObj, пока он еще не определен, поэтому возвращается неопределенным. После присвоения ему значения null второй console.log(...), очевидно, возвращает null, потому что myProperty существует, но ему присвоено значение null.

Чтобы иметь возможность запрашивать это различие, в JavaScript есть null и undefined: Хотя null - как и в других языках - объект, undefined не может быть объектом, потому что нет доступного экземпляра (даже не null экземпляра).

null - это объект. Его тип - null. undefined не является объектом; его тип не определен.

Например, window.someWeirdProperty не определено, поэтому

"window.someWeirdProperty === null" оценивается как ложь, а

"window.someWeirdProperty === undefined" оценивается как истина.

Кроме того, проверка if (!o) - это не то же самое, что проверка if (o == null) на то, чтобы o было false.

В Javascript null не является object типом, это primitave тип.

В чем разница? Не определено - указатель, который не был установлен. Нулевой относится к нулевому указателю, например, что-то вручную установило для переменной тип null.

Посмотри на это:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

Из книги Николаса Закаса "Принципы объектно-ориентированного JavaScript".

Но почему объект, если тип равен нулю? (Фактически, это было признано TC39, комитетом, разрабатывающим и поддерживающим JavaScript, как ошибка. Можно было бы предположить, что null - это пустой указатель на объект, что делает «объект» логическим возвращаемым значением, но это все еще сбивает с толку.)

Закас, Николас К. (07.02.2014). Принципы объектно-ориентированного JavaScript (местоположения Kindle 226-227). Пресс без крахмала. Разжечь издание.

При этом сказано:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Неопределенный случай:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

Лучший способ подумать о «нуле» - это вспомнить, как аналогичное понятие используется в базах данных, где оно указывает, что поле не содержит «никакого значения вообще».

• Да, стоимость предмета известна; он "определен". Он был инициализирован.
• Значение элемента: «Нет значения».

Это очень полезный метод для написания программ, которые легче отлаживать. Неопределенная переменная может быть результатом ошибки ... (откуда вы знаете?) ... но если переменная содержит значение 'null', вы знаете, что "кто-то где-то в этой программе установите значение 'null'. "Поэтому я предлагаю, чтобы, когда вам нужно избавиться от значения переменной, не" удалять "... установите для него значение 'нулевой.' Старое значение будет потеряно и скоро будет собрано в мусор; новое значение - «нет значения (сейчас)». В обоих случаях состояние переменной определенно: «очевидно, намеренно так оно и было».

The other fun thing about null, compared to undefined, is that it can be incremented.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Это полезно для установки числовых значений по умолчанию для счетчиков. Сколько раз вы устанавливали для переменной значение -1 в ее объявлении?

1. Undefined означает, что переменная была объявлена, но ей не было присвоено какое-либо значение, в то время как Null может быть назначен переменной, представляющей «нет значения». (Null - это оператор присваивания)

2.Undefined - это сам тип, а Null - это объект.

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

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

Например, если переменная не имеет значения, присвойте ей значение null.

var weDontHaveAValue = null;

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

if (typeof args.optionalParam !== 'undefined') { }