Вопрос: JavaScript проверяет, существует ли переменная (определена / инициализирована)


Какой метод проверки правильности инициализации переменной лучше / правильно? (Предполагая, что переменная может содержать что угодно (строка, int, объект, функция и т. Д.))

if (elem) { // or !elem

или

if (typeof(elem) !== 'undefined') {

или

if (elem != null) {

1254


источник


Ответы:


Вы хотите typeofоператор , В частности:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

2469



typeofоператор проверяет, действительно ли переменная не определена.

if (typeof variable === 'undefined') {
    // variable is undefined
}

typeofоператор, в отличие от других операторов, не бросает ReferenceError исключение при использовании с необъявленной переменной.

Однако обратите внимание, что typeof nullвернется "object", Мы должны быть осторожны, чтобы избежать ошибки инициализации переменной null, Чтобы быть в безопасности, это то, что мы могли бы использовать вместо этого:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Для получения дополнительной информации об использовании строгого сравнения ===вместо простого равенства ==, видеть:
Какой оператор равен (== vs ===) должен использоваться в сравнении JavaScript?


682



В JavaScript переменная может быть определена, но удерживать значение undefined, поэтому наиболее распространенный ответ не является технически корректным и вместо этого выполняет следующее:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

Этого может быть достаточно для ваших целей. Следующий тест имеет более простую семантику, что упрощает точное описание поведения вашего кода и его само понимание (если вас это беспокоит):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

Это, конечно, предполагает, что вы работаете в браузере (где windowэто имя для глобального объекта). Но если вы дергаетесь с подобными глобалами, вы, вероятно, находитесь в браузере. Субъективно, используя 'name' in windowстилистически согласуется с использованием window.nameдля ссылки на глобальные переменные. Доступ к глобалам как свойствам windowа не как переменные, позволяет свести к минимуму количество необъявленных переменных, которые вы ссылаетесь в своем коде (в пользу листинга), и избегает возможности того, что ваш глобальный объект будет затенен локальной переменной. Кроме того, если глобалы заставят вашу кожу сканировать, вы можете чувствовать себя более комфортно, касаясь их только этой относительно длинной палкой.


180



В большинстве случаев вы будете использовать:

elem != null

В отличие от простого if (elem), Это позволяет 0, false, NaNа также '', но отвергает nullили undefined, что делает его хорошим, общим тестом для наличия аргумента или свойства объекта.


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

  • if (elem): может использоваться, если elemгарантированно является объектом, или если false, 0и т. д. считаются значениями «по умолчанию» (что эквивалентно undefinedили null).

  • typeof elem == 'undefined'могут использоваться в тех случаях, когда указанная nullимеет четкое значение для неинициализированной переменной или свойства.

    • Это единственная проверка, что не будет выдавать ошибку если elemне является объявленный (т. е. нет varутверждение, а не свойство window, или не аргумент функции). Это, на мой взгляд, довольно опасно, поскольку позволяет опечаткам незаметно проскальзывать. Чтобы этого избежать, см. Метод ниже.

Также полезно строгое сравнение с undefined:

if (elem === undefined) ...

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

var undefined; // really undefined
if (elem === undefined) ...

Или:

(function (undefined) {
    if (elem === undefined) ...
})();

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


110



Во многих случаях использование:

if (elem) { // or !elem

сделают эту работу за вас! ... это проверит следующие случаи:

  1. не определено : если значение не определено, и это undefined
  2. ноль : если оно равно null, например, если элемент DOM не существует ...
  3. пустая строка : ''
  4. 0 : число ноль
  5. NaN : не число
  6. ложный

Таким образом, он будет охватывать все случаи, но всегда есть странные случаи, которые мы хотели бы затронуть, например, строку с пробелами, например ' 'один, это будет определено в javascript, поскольку в нем есть пробелы внутри строки ... например, в этом случае вы добавляете еще одну проверку с помощью trim (), например:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Кроме того, эти проверки значения только, поскольку объекты и массивы работают по-разному в Javascript, пустом массиве []и пустой объект {}всегда правда ,

Я создаю изображение ниже, чтобы показать краткое изложение ответа:

undefined, null, etc


64



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

Это довольно пуленепробиваемое решение для тестирования, если переменная существует и была инициализирована:

var setOrNot = typeof variable !== typeof undefined;

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

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Проблемы с инкапсуляцией

К сожалению, вы не можете просто инкапсулировать свою проверку в функцию.

Вы можете подумать о том, чтобы сделать что-то вроде этого:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

Однако, если вы вызываете, например, это приведет к эталонной ошибке. isset(foo)и переменная fooне определено, потому что вы не можете передать несуществующую переменную функции:

Uncaught ReferenceError: foo не определен


Проверка неопределенности параметров функции

Хотя наши issetфункция не может использоваться для проверки наличия или отсутствия переменной (по причинам, описанным выше), это позволяет нам проверить, не определены ли параметры функции:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Несмотря на то, что для yпередается вдоль функции test, наши issetфункция отлично работает в этом контексте, потому что yизвестно в функции testкак undefinedстоимость.


57



Убедитесь, что объект hasOwnProperty()

Альтернатива множеству typeofответов, является использование hasOwnProperty()который, конечно, проверяет, обладает ли объект (почти все в JS) свойством то есть переменная (между прочим).

hasOwnProperty()метод возвращает логическое значение, указывающее, имеет ли объект указанное свойство как собственное (не наследуемое) свойство.

Каждый объект, с которого объект наследует hasOwnProperty()метод. Этот метод может быть использован для определения того, имеет ли объект указанное свойство как прямое свойство этого объекта; в отличие от в оператора, этот метод не проверяет цепочку прототипов объекта.

// Globally established (therefore) properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
// window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ),             // true
    window.hasOwnProperty( "bar" ),             // true
    window.hasOwnProperty( "baz" ),             // true
    window.hasOwnProperty( "qux" ),             // false
    { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true
] );

Что здорово в hasOwnProperty()заключается в том, что при вызове его мы не используем переменную, которая пока еще не определена, что, разумеется, вдвое меньше проблемы.

Хотя нет всегда идеально или идеальный решение, в определенных обстоятельствах, это просто работа!


39



There is another short hand way to check this, when you perform simple assignments and related checks. Simply use Conditional (Ternary) Operator.

var values = typeof variable !== 'undefined' ? variable : '';

Also this will be helpful, when you try to declare the Global variable with instance assignment of the reference variable.

If you wanted to check variable shouldn't be undefined or null. Then perform below check.

When the variable is declared, and if you want to check the value, this is even Simple: and it would perform undefined and null checks together.

var values = variable ? variable : '';

37



undefined,boolean,string,number,function

if( typeof foo !== 'undefined' ) { 

}

Object,Array

if( foo instanceof Array ) { 

}

26



It depends if you just care that the variable has been defined or if you want it to have a meaningful value.

Checking if the type is undefined will check if the variable has been defined yet.

=== null or !== null will only check if the value of the variable is exactly null.

== null or != null will check if the value is undefined or null.

if(value) will check if the variable is undefined, null, 0, or an empty string.


23



The highest answer is correct, use typeof.

However, what I wanted to point out was that in JavaScript undefined is mutable (for some ungodly reason). So simply doing a check for varName !== undefined has the potential to not always return as you expect it to, because other libs could have changed undefined. A few answers (@skalee's, for one), seem to prefer not using typeof, and that could get one into trouble.

The "old" way to handle this was declaring undefined as a var to offset any potential muting/over-riding of undefined. However, the best way is still to use typeof because it will ignore any overriding of undefined from other code. Especially if you are writing code for use in the wild where who knows what else could be running on the page...


10