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

StackOverflow https://stackoverflow.com/questions/801032

Вопрос

Почему 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: Логическое значение ложь.

name = '';

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

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

Итак, если ваш объект не ноль, но ЛОЖЬ или 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» вместо «undef».Вы даже можете сравнить переменную, которая не определена, с нулевой или наоборот, и условие будет истинным:

 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

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

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

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

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

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

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

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

А также:

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

В JavaScript одно отличие состоит в том, что null имеет тип объекта, а undef — неопределенный тип.

В 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;

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

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

if (!x)

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

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

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

  • Методы, опрашивающие 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).Каждое из следующих значений выводит «неопределено»:

    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 unitialized = null;или самостоятельно вернуть значение null из метода, то в других ситуациях у вас возникнет значение null.Но это должно быть довольно очевидно.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

test();

Вы получаете

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

нулевой

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

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

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

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

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

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

Кроме того, проверьте, если 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 тип.

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

Закас, Николас С.(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», вы знаете, что «кто-то где-то в этой программе установить его на «ноль». Поэтому я советую, когда вам нужно избавиться от значения переменной, не «удалять»…Установите его на «null». Старая стоимость будет осиротежна и скоро будет сборка мусора;Новое значение: «Нет значения (сейчас)». В обоих случаях состояние переменной определенно:«Очевидно, что это было сделано намеренно».

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

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

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

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top