Почему null является объектом и в чем разница между 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.

Итак, если ваш объект not null, но false или 0 или "" Регистрация потому что:

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

null is не является объектом, это примитивное значение. Например, к нему нельзя добавить свойства. Иногда люди ошибочно полагают, что это объект, потому что 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 (==performs все виды конверсии это может привести к неожиданным результатам). Чек x == null является крайним случаем, потому что он работает для обоих null и undefined:

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

обычный способ проверить, имеет ли переменная значение, - преобразовать ее в boolean и посмотреть, является ли она 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 или наоборот, и условие будет true:

 undefined == null
 null == undefined

смотрите JavaScript разница между null и undefined подробнее.

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

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

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

регистрация здесь: Javascript gotcha

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

почему null считается объектом в 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, неочевидные результаты могут быть источником ошибок. Использование == не рекомендуется никогда использовать === вместо.

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

а также:

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

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

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

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

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

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

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

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

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

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

var x = null;

x определяется как null

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

if (!x)

null оценивается как false

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

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

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

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

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

    {
      name: "Bob",
      address: null
    }

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

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 является свойством глобального объекта ("окно" в браузерах), но является примитивным типом, а не самим объектом. Это значение по умолчанию для неинициализированных переменных и функций, заканчивающихся без оператора return.

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

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

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

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

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

Falsy (который будет принуждаться к false) значения в JavaScript:", null, undefined, 0 и false.

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

вы могли бы рассмотреть undefined чтобы представить системный уровень, неожиданный, или ошибка-как отсутствие значения и null для представления на программном уровне, нормальное или ожидаемое отсутствие ценности. Если вам нужно назначить один из эти значения в переменную или свойство или передать одно из этих значений функция, 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: While null - это - как и в других языках объект, undefined не может быть объектом, потому что нет никакого экземпляра (даже не null примеру) доступны.

"window.someWeirdProperty === null" принимает значение false, в то время как

"window.someWeirdProperty === undefined" значение true.

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

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

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" Николаса С. Закаса

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

Zakas, Nicholas C. (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" - вспомнить, как аналогичная концепция используется в базах данных, где она указывает, что поле не содержит " никакого значения вообще."

• Да, значение элемента известно; это is 'определенными.- Это! .. --4-->и инициализирован.
• значение элемента:"нет никакого значения."

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

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

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

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