Проверка JavaScript на ноль против неопределенного и разницу между == и ===


579
  1. Как проверить переменную, если она nullили undefinedи в чем разница между nullи undefined?

  2. В чем разница между ==и ===(трудно найти в Google "===")?


10
2. Разница между ==и ===хорошо описана здесь .
Узбекджон

1. Используйте === Вместо == JavaScript использует два разных вида операторов равенства: === | ! == и == | ! = Рекомендуется всегда использовать первый набор при сравнении. «Если два операнда имеют одинаковый тип и значение, то === выдает истину, а! == - ложь». - JavaScript: хорошие стороны Однако при работе с == и! = Вы столкнетесь с проблемами при работе с различными типами. В этих случаях они попытаются привести значения безуспешно. code.tutsplus.com/tutorials/…
jasonleonhard

4
Вы можете искать в Google: «оператор строгого равенства» - который приносит очень релевантные результаты
Danield

Просто чтобы добавить сюда множество ответов, что вы можете использовать функцию lodash.com/docs#isNil, чтобы проверить, является ли переменная нулевой или неопределенной
Kfir Erez

Ответы:


936

Как проверить переменную, если она nullили undefined...

Является ли переменная null:

if (a === null)
// or
if (a == null) // but see note below

... но обратите внимание, что последнее также будет верно, если aесть undefined.

Это undefined:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

... но опять же, обратите внимание, что последний является расплывчатым; это также будет верно, если aесть null.

Теперь, несмотря на вышесказанное, обычный способ проверить это - использовать тот факт, что они ложные :

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

Это определяется ToBoolean в спецификации.

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

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

nullнемного конкретнее, чем undefined: Это пустая ссылка на объект. Конечно, JavaScript является типизированным, но не все функции, с которыми взаимодействует JavaScript, являются типизированными. Если для API, такого как DOM в браузерах, нужна пустая ссылка на объект, мы используем null, а не undefined. И точно так же getElementByIdоперация DOM возвращает ссылку на объект - либо действительную (если она нашла элемент DOM), либо null(если она этого не сделала).

Интересно (или нет), они свои типы. То есть, nullэто единственное значение в типе Null и undefinedединственное значение в неопределенном типе.

В чем разница между "==" и "==="

Единственная разница между ними заключается в том, что они ==будут выполнять приведение типов, чтобы попытаться получить совпадающие значения, и ===не будут. Так, например, "1" == 1это правда, потому что "1"принуждает к 1. Но "1" === 1это ложь , потому что типы не совпадают. ( "1" !== 1верно.) Первый (реальный) шаг ===- "Являются ли типы операндов одинаковыми?" и если ответ «нет», результат false. Если типы одинаковы, он делает именно то, что ==делает.

Приведение типов использует довольно сложные правила и может иметь неожиданные результаты (например, "" == 0верно).

Больше в спецификации:


122
Чтобы узнать ответ TJ, === означает, что значение И тип одинаковы.
Сладкий

13
@Slappy: :-) @ MUG4N: Да, все верно. if (a) { ... }будет означать «если aверно», где «правда» - это ненулевое, ненулевое, ненулевое, ненулевое, непустое строковое значение. :-)
TJ Crowder

4
Хм ... неужели downvoter хотел бы поделиться некоторыми полезными отзывами о том, почему вы думаете, что это "бесполезно" (чтобы процитировать подсказку кнопки downvote)?
TJ Crowder

2
@ Željko: Я думаю, что Крокфорд может ошибаться в этом вопросе. Это правда, что nullэто не объект , это ссылка на объект, означающая «нет объекта». Это важно, потому что это то, что используется с предоставленными хостом интерфейсами, когда они предоставляют ссылки на объекты, но не имеют их для предоставления (например, node.nextSiblingкогда nodeпоследний элемент в его родительском элементе или getElementByIdкогда нет элемента с таким идентификатором). Технология, используемая хостом для этого, может быть не такой гибкой, как в JavaScript для типов переменных / свойств, поэтому было необходимо иметь nullobj ref (в отличие от undefined).
TJ Crowder

2
Я должен согласиться, что Крокфорд ошибается. typeof nullвозвращать «объект» имеет смысл. Единственное другое значение, которое имело бы смысл, было бы «нулевым», поскольку оно определенно должно возвращать что-то отличное от typeof undefined. null представляет нулевую ссылку на объект, что, по крайней мере, означает, что переменная, содержащая ее, предназначена для некоторого типа «объекта». Если это была ошибка, это была хорошая ошибка. В любом случае, что касается ответа, совет о undefined! == undefinedво время написания сценариев в разных окнах полезен, особенно для целей отладки.
Трийнко

93

Разница неуловима.

В JavaScript undefinedпеременная - это переменная, которая никогда не объявлялась или никогда не присваивала значение. Допустим, вы объявляете, var a;к примеру, так aи будет undefined, потому что ему никогда не присваивалось никакого значения.

Но если потом назначить, a = null;то aтеперь будет null. В JavaScript nullэто объект (попробуйте typeof nullв консоли JavaScript, если вы мне не верите), что означает, что null является значением (фактически даже undefinedявляется значением).

Пример:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

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

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

Если вы опустите optionalпараметр, doSomething(1, 2) thenнеобязательной будет "three"строка, но если вы передадите, doSomething(1, 2, null)то необязательной будет null.

Что касается равных ==и строго равных ===компараторов, то первый тип имеет слабый тип, тогда как строго равный также проверяет тип значений. Это означает, что 0 == "0"вернет истину; while 0 === "0"вернет false, потому что число не является строкой.

Вы можете использовать эти операторы , чтобы проверить между . Например:undefinednull

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

Последний случай интересен, потому что он позволяет вам проверить, является ли переменная неопределенной или нулевой, и ничего больше:

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

1
Кайл Симпсон утверждает, что typeof null, возвращающий «объект», является ошибкой: github.com/getify/You-Dont-Know-JS/blob/master/…
bzrk

15

Спецификация - это место, где можно получить полные ответы на эти вопросы. Вот резюме:

  1. Для переменной xвы можете:

    • проверьте, если это nullпутем прямого сравнения с помощью ===. Пример:x === null
    • проверьте, является ли это undefinedодним из двух основных методов: прямое сравнение с undefinedили typeof. По разным причинам я предпочитаю typeof x === "undefined".
    • проверить , является ли это один из nullи undefinedс помощи ==и опираясь на несколько негласных правилах типа принуждения , что средний x == nullделают именно то , что вы хотите.

  2. Основное различие между ==и ===заключается в том, что если операнды имеют разные типы, ===они всегда будут возвращаться, в falseто время как ==один или оба операнда будут преобразованы в один и тот же тип с использованием правил, которые приводят к некоторому слегка неинтуитивному поведению. Если операнды имеют одинаковый тип (например, оба являются строками, как в приведенном typeofвыше сравнении) ==и ===будут вести себя точно так же.

Больше чтения:


9

Как проверить переменную, если она пуста или не определена

просто проверьте, имеет ли переменная допустимое значение, например:

if(variable)

он вернет true, если переменная не содержит:

  • значение NULL
  • не определено
  • 0
  • ложный
  • «» (пустая строка)
  • NaN

8

не определено

Это означает, что переменная еще не инициализирована.

Пример :

var x;
if(x){ //you can check like this
   //code.
}

равно (==)

Это только проверка значения равно, а не тип данных.

Пример :

var x = true;
var y = new Boolean(true);
x == y ; //returns true

Потому что он проверяет только значение.

Строгое равенство (===)

Проверяет значение и тип данных должны быть одинаковыми.

Пример :

var x = true;
var y = new Boolean(true);
x===y; //returns false.

Поскольку он проверяет, тип данных x является примитивным типом, а y является логическим объектом.


4

Объявление 1. nullне является идентификатором свойства глобального объекта, как undefined может быть

Объявление 2. ===Проверка значений и типов. Не ==требуют одинаковых типов и сделали неявное преобразование перед сравнением (используя .valueOf()и .toString()). Здесь у вас есть все ( SRC ):

если

введите описание изображения здесь

== (его отрицание ! = )

введите описание изображения здесь

=== (это отрицание ! == )

введите описание изображения здесь


1
Стоит отметить, что document.all == nullиdocument.all !== null
пользователь

1

Если ваша (логическая) проверка предназначена для отрицания (!) И вы хотите захватить как JS, так nullи undefined (поскольку разные браузеры будут давать разные результаты), вы бы использовали менее ограничительное сравнение: например:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

Это захватит nullиundefined


0

Попробуйте с другой логикой . Вы можете использовать приведенный ниже код для проверки всех четырех (4) условий для проверки, например, не ноль, не пустой, не неопределенный и не ноль, используйте только этот код (! (! (Variable))) только в javascript и jquery.

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}

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