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

Question

Почему null считается object в JavaScript?

Проверяет

if ( object == null )
      Do something

так же, как

if ( !object )
      Do something

А также:

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

Answer 1

(name is undefined)

Вы: Что такое name? ^(*)
JavaScript: name? Что такое name? Я не знаю о чем ты говоришь. Вы никогда не упоминали ни одного name раньше. Вы видите какой-нибудь другой язык сценариев на стороне (клиента)?

name = null;

Вы: Что такое name?
JavaScript: Я не знаю.

Короче говоря; undefined - это место, где понятия о вещи не существует; у него нет типа, и на него никогда раньше не ссылались; null - это место, где, как известно, существует вещь, но неизвестно, каково значение.

Следует помнить, что null концептуально не совпадает с false или "" или чем-то подобным, даже если они равны после приведения типа, т.е.

name = false;

Вы: Что такое name?
JavaScript: Boolean false.

name = '';

Вы: Что такое name?
JavaScript: Пустая строка

---

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

Answer 2

Разница может быть сведена в этот фрагмент:

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 === true.

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

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

Answer 3

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
• Booleans: false
• Номера: +0, -0, NaN
• Строки: ""

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

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

Answer 4

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

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

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

 undefined == null
 null == undefined

Подробнее см. JavaScript. Разница между нулевым и неопределенным .

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

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

при тестировании, если объект имеет значение false, они оба удовлетворяют условию только при тестировании, если false , но не при true

Проверьте здесь: Javascript gotcha

Answer 5

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

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

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

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

Проверяет


if (object == null)
Do something

так же, как

if (!object)
Do something

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

• объект не определен или имеет значение null: оба true.

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

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

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

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

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

А также:

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

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

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

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

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

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

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

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

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

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

Answer 6

var x = null;

x определен как ноль

у не определено; // потому что я не определил это

if (!x)

ноль оценивается как ложное

Answer 7

Сравнение множества различных нулевых проверок в 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-нуль-проверка-неопределенными-and.html

Answer 8

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

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

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

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

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

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

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

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

       // But this returns undefined:

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

Все остальные случаи небытия обозначаются как неопределенные (как отмечено @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. Для всех остальных случаев безопасно проверять неопределенность при строгом равенстве:

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

Answer 9

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

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

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

Answer 10

Чтобы добавить к ответу В чем разница между undefined и null, из JavaScript Guide Guide на этой странице :

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