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


866

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

Проверяет

if ( object == null )
      Do something

такой же как

if ( !object )
      Do something

?

А также:

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


6
Было бы здорово, если бы последний вопрос был добавлен в заголовок. Ответы здесь потрясающие, но название может не указывать на то, что вы найдете этот ответ здесь
marcos.borunda

6
Нуль не является объектом в JavaScript! typeof null === 'object'но это ошибка! Вот ссылка Смотрите все видео и наслаждайтесь :)
CoR

1
Мне нравится использовать C / C ++ в качестве аксиоматической истины для неопределенной переменной со значением NULL, поскольку она очень проста. Затем посмотрите, как эти определения соотносятся со спецификациями других языков.
Самис

Ответы:


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


14
Но в JavaScript пустая строка '' по-прежнему является логическим значением false.
Андреас Греч

117
Пустая строка не является логическим значением false, но в контексте условия она интерпретируется как значение false (y) (приведение).
Брайан Мэтьюз

22
Во втором случае, где name = null, вместо «я не знаю», JavaScript может ответить: нулевой объект. Помимо этого мне нравится стиль ответа.
Жан Винсент

16
Вместо «я не знаю» я бы сказал, что ответ null«ничего». Нуль точно определяется как отсутствие значения. Пустота, ноль, нада. Ничего.
Микл

50
Люблю такой стиль ответа. В общем, «Вы никогда не упоминали name раньше» - это правда. Однако объявление переменной без присвоения ей значения ( var somevar;), как ни странно, все равно приведет к undefined.
MC Emperor

142

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

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

@kentaromiura Для нас нубы Javascript ... может быть, только я ... что это за логический (значение) синтаксис? Кастинг в логическое значение?
xr280xr

@ xr280xr Да, это кастинг. Попробуйте String(null)увидеть еще один пример кастинга. Вы можете даже делать глупые вещи, как Number(null + 2)... но вы не должны :-). Отличный ответ от кентаромиура.
Squidbe

Помните typeof, это оператор. Вы не заключили бы операнд в скобки по той же причине, по которой не написали бы var sum = 1 +(1);.
Алекс

124

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

1
Зачем ссылаться +0и -0отдельно если +0 === -0?
Райнос

6
Вероятно потому , что вы до сих пор можно различить +0и -0: 1/+0 !== 1/-0.
Neo

1
Этот ответ ссылается на пост, который ссылается на этот ответ как источник ... вероятно, имел в виду вместо этого ссылку 2ality.com/2013/10/typeof-null.html
Рикардо Томази

Да, как в C, где объявления неинициализированных переменных считаются неопределенными (старые версии могут фактически содержать данные предыдущих программ).
Самис

5
«Но это на самом деле ошибка (которая может даже быть исправлена ​​в ECMAScript 6)» - источник?
Gajus

26

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

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

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

 undefined == null
 null == undefined

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

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

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

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

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


4
Вы должны использовать ===, тогда не определено! == null: D
olliej

1
обратите внимание на последнюю часть, неверно смотри мой ответ;)
kentaromiura

6
! object - это не то же самое, что "object == null" ... На самом деле они совершенно разные. ! object будет возвращать true, если для объекта установлено значение 0, пустая строка, логическое значение false, undefined или null.
Джеймс

3
Является ли null действительно объектом? Первая ссылка, которую вы предоставили, проверяет null по typeof, но typeof (null) оценивается как 'object' из-за ошибки проектирования языка.
c4il

2
nullэто не объект. Это typeof null == 'object';возвращает true из-за ошибки, которая не может быть исправлена ​​в JavaScript (в настоящее время, но может измениться в будущем).
Мохамад

21

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

Почему 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

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


8
Хороший ответ, но он заходит слишком далеко с []: « На самом деле, null и undefined идентичны ... и, возможно, пустые контейнеры [] и {}. » Вы, вероятно, могли бы убедить меня, что {} должно быть вкус ноль, но мое внутреннее впечатление, что это не должно. Но менее спорно, пустой массив по []понятным причинам имеет .push()функцию , поэтому нет хорошего аргумента для [] будучи нуля. $ 0,02.
Ерф

11
var x = null;

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

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

if (!x)

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


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
}

8

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

JavaScript Null Check Сравнительная таблица


1
делает "var myUndefined;" определить переменную (как известную переменную с неизвестным типом)?
Ци Фан

6

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

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

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


5

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

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


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

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

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


5

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

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


3

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


11
неправильный - оба nullи undefinedпримитивные значения - typeof null === 'object'это языковая ошибка, потому чтоObject(null) !== null
Кристоф

Нет. Функция Object () приведена таким образом, см. Ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf - 15.2.2.1 new Object ([value]) ... 8. (Значение аргумента не был предоставлен или его тип был пустым или неопределенным.) Создайте новый собственный объект ECMAScript. Свойство [[Prototype]] вновь созданного объекта устанавливается равным объекту-прототипу Object. Свойство [[Class]] вновь созданного объекта имеет значение «Объект». Вновь созданный объект не имеет свойства [[Value]]. Вернуть вновь созданный нативный объект.
kentaromiura

3
@ Кристоф: Я имею в виду, ты прав. null должен быть типом, я имею в виду, что вы не можете проверить его таким образом, потому что: alert (new Object ()! == new Object ()); / * true, новый istance - это не то же самое, что istance / alert (Object (null) .constructor == {} .constructor); / true как в spec / alert (Object (null) .prototype == {} .prototype); / true как в spec / alert (null instanceof Object); / очевидно ложный, нулевой означает, что не был создан * * Но в основном это ошибка спецификации XD, см .: uselesspickles.com/blog/2006/06/12/… и javascript.crockford.com/remedial.html
kentaromiura

2

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

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доступного экземпляра (даже не экземпляра).


2

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

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

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

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


Можете ли вы уточнить разницу между двумя условиями
Рахул

прочитайте мой ответ, он означает, что если o равно 0, false или "" логическое значение равно false: var undef, Various = [0, "", null, false, undef]; for (var obj в различных) {alert (! obj); // 4 раза ложь в IE, 5 в FF;)}
kentaromiura

2

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

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

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


2

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

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


2

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

   <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

1

Из «Принципов объектно-ориентированного 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.

1

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

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

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


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

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

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

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.