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

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

Проверяет

if ( object == null )
      Do something

такой же как

if ( !object )
      Do something

?

А также:

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

Разницу можно суммировать в следующем фрагменте:

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

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 или наоборот, и условие будет истинным:

 undefined == null
 null == undefined

Обратитесь к JavaScript Разница между нулевым и неопределенным для более подробной информации.

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

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

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

Проверьте здесь: Javascript получил

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

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

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

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

Проверяется так


if (object == null)
Do something

же, как

if (!object)
Do something

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

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

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

Если объект не является примитивным, а реальный объект, как 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, и ""в этом отношении тоже, и, возможно, пустые контейнеры []и{} . Так много типов одного и того же ничего не являются рецептом для ошибок. Один тип или нет вообще лучше. Я бы постарался использовать как можно меньше.

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

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

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

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

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

var x = null;

х определяется как ноль

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

if (!x)

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

Один из способов понять значение 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
}

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

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

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

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

Некоторые точности:

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

Что происходит в ifследующем if( o ):

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

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

Для того, чтобы добавить к ответу Что Необходимо различать undefinedиnull с JavaScript Definitive Guide 6 - е издание, с.41 на этой странице :

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

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

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

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

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

test();

Вы получаете

не определено

значение NULL

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

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

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

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

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

Кроме того checkif if (!o)не то же самое , как проверка if (o == null)для oтого false.

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

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

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

В Javascript null это не objectтип, это primitaveтип.

В чем разница? Undefined относится к указателю, который не был установлен. Null ссылается на нулевой указатель, например, что-то вручную установило переменную типа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 является пустым указателем объекта, что делает «object» логическим возвращаемым значением, но это по-прежнему сбивает с толку.)

Закас Николай Николаевич (2014-02-07). Принципы объектно-ориентированного JavaScript (Kindle Locations 226-227). Нет крахмального пресса. Kindle Edition.

Это говорит:

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 ". Старое значение будет потеряно и скоро будет собрано для мусора; новое значение: «нет значения (сейчас)». В обоих случаях состояние переменной определено: «она, очевидно, умышленно получила этот путь».

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

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

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