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

Ответ 1

(name is undefined)

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

name = null;

Вы: Как name?
JavaScript: я не знаю

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

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

name = false;

Вы: Как name?
JavaScript: логическое значение false.

name = '';

Вы: Как name?
JavaScript: пустая строка

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

Ответ 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, то !false === true.

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

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

Ответ 3

null не объект, это примитивное значение. Например, вы не можете добавлять к нему свойства. Иногда люди ошибочно предполагают, что это объект, потому что typeof null возвращает "object". Но на самом деле это ошибка (которая может быть исправлена ​​в ECMAScript 6).

Разница между null и undefined заключается в следующем:

• undefined: используется JavaScript и означает "no value". Неинициализированные переменные, отсутствующие параметры и неизвестные переменные имеют это значение.

  > 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

Обычный способ проверить, имеет ли переменная значение, чтобы преобразовать его в 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, используя Boolean как функцию (обычно это конструктор, который будет использоваться с new):

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

Ответ 4

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

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

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

 undefined == null
 null == undefined

Подробнее см. Различие JavaScript между нулем и undefined.

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

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

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

Отметьте здесь: Javascript gotcha

Ответ 5

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

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

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

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

Является ли проверка


if (object == null)
Do something

так же, как

if (!object)
Do something

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

• объект undefined или null: оба true.

• объект примитивен и 0, "" или false: сначала установите флажок false, второй true.

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

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

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

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

А также:

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

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

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

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

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

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

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

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

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

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

Ответ 6

var x = null;

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

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

if (!x)

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

Ответ 7

Один способ понять значение null и undefined - понять, где они происходят.

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

• Методы запроса DOM

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

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

    {
      name: "Bob",
      address: null
    }

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

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

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

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

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

Ответ 9

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

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

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

Ответ 10

Некоторые замечания:

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

Что происходит в if для if( o ), как показано ниже:

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

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

Ответ 11

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

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

Ответ 12

null - это объект. Его тип равен NULL. undefined не является объектом; его тип undefined.

Ответ 13

Например window.someWeirdProperty - undefined, поэтому

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

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

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

Ответ 14

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

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

Если вы вызываете

test();

Вы получаете

undefined

нулевым

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

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

Ответ 15

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

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

Ответ 16

В Javascript null не является типом object, это тип primitave.

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

Ответ 17

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

   <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

Ответ 18

Из "Принципов объектно-ориентированного Javascript" Николаса К. Закаса

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

Закас, Николас К. (2014-02-07). Принципы объектно-ориентированного JavaScript (разжечь локации 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 not an instance but it type is object
//let make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Undefined case:

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.

Ответ 19

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

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

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

Ответ 20

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

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

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