JavaScript не определен заменен на ноль

Question

В JavaScript undefined можно переназначить, поэтому часто рекомендуется создавать самозапускающуюся функцию, которая гарантирует, что undefined фактически не определен. В качестве альтернативы null и undefined определенно ==, но любые другие значения слабо эквивалентны null/undefined?

TLDR

В принципе, вы можете смело заменить это:

(function(undefined){

   window.f = function(obj){
     if(obj===undefined || obj===null ){
       alert('value is undefined or null');
     }
   }

})();

с:

window.f = function(obj){
  if(obj==null){
    alert('value is undefined or null');
  }
}

Если все вышесказанное безопасно на 100%, почему сообщество / библиотеки JavaScript не пропускают undefined в целом и не используют более короткое условное выражение x == null для одновременной проверки обоих null / undefined?

EDIT:

Я никогда не видел, чтобы кто-то на самом деле представлял «неизвестное значение» с «неопределенным» против null? Я никогда не видел этот сценарий, и именно поэтому я изначально задал вопрос. Это просто две невероятно запутанные ценности, которые никогда не используются в их первоначальном намерении. Стандартизация всего для сравнения obj==null будет полезна для размера и позволит избежать проблем с переназначением. Все будет продолжать работать

var obj={};
obj.nonExistantProperty==null // true

var x;
ix==null // true

function(obj){
  obj==null // true
}

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

+(null)==0 в то время как isNaN(+undefined)

Учитывая, что NaN является единственным значением в JavaScript, не равным самому себе, вы можете сделать несколько довольно безумных вещей, таких как:

+undefined == +undefined // false
+null == +null // true

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

Answer 1

Алгоритм абстрактного равенства из раздела 11.9.3 спецификации языка - это то, что определяет == и !=, и определяет их так, что

null == void 0
null == null
void 0 == null

где void 0 это просто надежный способ сказать undefined (см. ниже), поэтому ответ на ваш вопрос - да, null равен undefined и сам по себе, и ничего больше.

соответствующие части спецификации:

1. If Type(x) is the same as Type(y), then
     If Type(x) is Undefined, return true.
     If Type(x) is Null, return true.
     ...
2. If x is null and y is undefined, return true.
3. If x is undefined and y is null, return true.
...

Если вас беспокоит, что undefined означает нечто иное, чем обычно, используйте void 0.

null               ==  void 0           // True
({}).x             === void 0           // True
"undefined"        === typeof void 0    // True
(function () {})() === void 0           // True
(undefined = 42,
 undefined         === void 0)          // False
"undefined"        === typeof undefined // False
"undefined"        === typeof void 0    // True

Из спецификации языка :

11.4.2 Оператор void

Производство UnaryExpression: void UnaryExpression оценивается следующим образом:

1. Пусть expr будет результатом вычисления UnaryExpression /.
2. Call GetValue(expr).
3. Return undefined .

Таким образом, префиксный оператор void оценивает свой аргументи возвращает специальное значение undefined независимо от того, на что была изменена глобальная переменная undefined (или определено ли undefined:).

EDIT: в ответ на комментарии

Если вы имеете дело с библиотечным кодом, который различает два, то вам нужно разобраться с разницей.Некоторые из новых библиотек, стандартизированных языковым комитетом, игнорируют разницу: JSON.stringify([void 0]) === "[null]", но существует слишком много кода, который обрабатывает их немного по-разному, и есть другие различия:

+(null) === 0
isNaN(+undefined)

"" + null === "null"
"" + undefined === "undefined"

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

Answer 2

Поскольку JavaScript имеет оба значения.И хотя в других языках может иметь только nil / null JavaScript вырос с undefined в качестве "неизвестного значения", в то время как null является явно известным значением, которое ничего не представляет.

Сравнить var x, где x не определено, поскольку значение не было назначено, а var y = null, где y равно null.Было установлено что-то - предложение, представляющее «ничто».Это базовое фундаментальное использование undefined против null в JavaScript выполняется очень глубоко, и другие случаи включают в себя:

1. Отсутствующее (или delete 'd) свойство также дает undefined, а не null (это приведет к null, только если назначено null).
2. Параметры неназначенных функций: undefined.
3. undefined, возвращенные из стандартных функцийкак getElementById.См. Комментарии.

Таким образом, в Javascript , часто более правильно использовать undefined, а не null. Они оба представляют разные вещи,Библиотека, которая пытается бороться с этим, борется с JavaScript.

Удачное кодирование.

---

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

Из-за этого убеждения я бы рассмотрел сравнение x == null на грани попытки охранять слишком много и все же слишком мало, но в случае ловли null или undefined, это работает, как указано.Иди начинай тренд; -)

Answer 3

Из-за этого:

var myVar1;
var myVar2 = null;

if (myVar1 === null) alert('myVar1 is null');
if (myVar1 === undefined) alert('myVar1 is undefined');
if (myVar2 === null) alert('myVar2 is null');
if (myVar2 === undefined) alert('myVar2 is undefined');

Все, что установлено на ноль, не является неопределенным - оно определяется как ноль.

Answer 4

Чтение Javascript: Хорошие части , кажется, что только null и undefined эквивалентны

JavaScript имеет два набора операторов равенства: === и! == и их злоблизнецы == и! =.Хорошие работают так, как вы ожидаете.Если два операнда имеют один и тот же тип и имеют одинаковое значение, то === выдает true, а! == выдает false.Злые близнецы поступают правильно, когда операнды относятся к одному и тому же типу, но если они относятся к разным типам, они пытаются привести значения.Правила, по которым они это делают, сложны и не запоминаются.Вот некоторые из интересных случаев:

'' == '0' // false
0 == '' // true
0 == '0' // true
false == 'false' // false
false == '0' // true
false == undefined // false
false == null // false
null == undefined // true
' \t\r\n ' == 0 // true

«JavaScript: хорошие части» Дугласа Крокфорда. Copyright 2008 Yahoo! Inc., 978-0-596-51774-8. »