Как проверить переменную, если она
null
илиundefined
и в чем разница междуnull
иundefined
?В чем разница между
==
и===
(трудно найти в Google "===")?
Как проверить переменную, если она null
или undefined
и в чем разница между null
и undefined
?
В чем разница между ==
и ===
(трудно найти в Google "===")?
Ответы:
Как проверить переменную, если она
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
верно).
Больше в спецификации:
==
также называемое «свободным» равенством)===
)if (a) { ... }
будет означать «если a
верно», где «правда» - это ненулевое, ненулевое, ненулевое, ненулевое, непустое строковое значение. :-)
null
это не объект , это ссылка на объект, означающая «нет объекта». Это важно, потому что это то, что используется с предоставленными хостом интерфейсами, когда они предоставляют ссылки на объекты, но не имеют их для предоставления (например, node.nextSibling
когда node
последний элемент в его родительском элементе или getElementById
когда нет элемента с таким идентификатором). Технология, используемая хостом для этого, может быть не такой гибкой, как в JavaScript для типов переменных / свойств, поэтому было необходимо иметь null
obj ref (в отличие от undefined
).
typeof null
возвращать «объект» имеет смысл. Единственное другое значение, которое имело бы смысл, было бы «нулевым», поскольку оно определенно должно возвращать что-то отличное от typeof undefined
. null представляет нулевую ссылку на объект, что, по крайней мере, означает, что переменная, содержащая ее, предназначена для некоторого типа «объекта». Если это была ошибка, это была хорошая ошибка. В любом случае, что касается ответа, совет о undefined
! == undefined
во время написания сценариев в разных окнах полезен, особенно для целей отладки.
Разница неуловима.
В 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, потому что число не является строкой.
Вы можете использовать эти операторы , чтобы проверить между . Например:undefined
null
null === null # => true
undefined === undefined # => true
undefined === null # => false
undefined == null # => true
Последний случай интересен, потому что он позволяет вам проверить, является ли переменная неопределенной или нулевой, и ничего больше:
function test(val) {
return val == null;
}
test(null); # => true
test(undefined); # => true
Спецификация - это место, где можно получить полные ответы на эти вопросы. Вот резюме:
x
вы можете:null
путем прямого сравнения с помощью ===
. Пример:x === null
undefined
одним из двух основных методов: прямое сравнение с undefined
или typeof
. По разным причинам я предпочитаю typeof x === "undefined"
.null
и undefined
с помощи ==
и опираясь на несколько негласных правилах типа принуждения , что средний x == null
делают именно то , что вы хотите.==
и ===
заключается в том, что если операнды имеют разные типы, ===
они всегда будут возвращаться, в false
то время как ==
один или оба операнда будут преобразованы в один и тот же тип с использованием правил, которые приводят к некоторому слегка неинтуитивному поведению. Если операнды имеют одинаковый тип (например, оба являются строками, как в приведенном typeof
выше сравнении) ==
и ===
будут вести себя точно так же.Больше чтения:
Как проверить переменную, если она пуста или не определена
просто проверьте, имеет ли переменная допустимое значение, например:
if(variable)
он вернет true, если переменная не содержит:
не определено
Это означает, что переменная еще не инициализирована.
Пример :
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 является логическим объектом.
Объявление 1. null
не является идентификатором свойства глобального объекта, как undefined
может быть
Объявление 2. ===
Проверка значений и типов. Не ==
требуют одинаковых типов и сделали неявное преобразование перед сравнением (используя .valueOf()
и .toString()
). Здесь у вас есть все ( SRC ):
если
== (его отрицание ! = )
=== (это отрицание ! == )
document.all == null
иdocument.all !== null
Если ваша (логическая) проверка предназначена для отрицания (!) И вы хотите захватить как JS, так null
и undefined
(поскольку разные браузеры будут давать разные результаты), вы бы использовали менее ограничительное сравнение: например:
var ItemID = Item.get_id();
if (ItemID != null)
{
//do stuff
}
Это захватит null
иundefined
Попробуйте с другой логикой . Вы можете использовать приведенный ниже код для проверки всех четырех (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);
}
}
==
и===
хорошо описана здесь .