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

Question

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

if (elem) { // or !elem

или

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

или

if (elem != null) {

Answer 1

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

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

Answer 2

Оператор 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?

Answer 3

В 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, а не как к переменным, позволяет минимизировать количество необъявленных переменных, на которые вы ссылаетесь в своем коде (для облегчения линтинга), и исключает возможность того, что глобальные переменные будут скрыты локальной переменной. Кроме того, если глобалы заставляют вашу кожу ползти, вам будет удобнее прикасаться к ним только этой относительно длинной палочкой.

Answer 4

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

if (elem) { // or !elem

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

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

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

if(elem) {

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

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

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

Answer 5

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

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 до одного символа, экономя каждый раз несколько байтов.

Answer 6

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

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

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.

Answer 7

Проверьте, если window. hasOwnProperty ( "varname" )

Альтернатива множеству typeof ответов;

Глобальные переменные, объявленные с помощью оператора var varname = value; в глобальной области действия

можно получить как свойства объекта окна.

Как таковой, метод hasOwnProperty(), который

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

может использоваться для определения того,

a var из "varname" объявлено глобально , т.е. является свойством window.

// 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
] );

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

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

Примечания

Вышесказанное верно при использовании var для определения переменной , в отличие от let, которая:

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

отличается от ключевого слова var, которое определяет переменную глобально или локально для всей функции независимо от области видимости блока.

На верхнем уровне программ и функций let, в отличие от var, не создает свойства для глобального объекта.

Для полноты: const константы по определению не являются фактически переменными (хотя их содержание может быть); более актуально:

Глобальные константы не становятся свойствами объекта окна, в отличие от var переменных. Требуется инициализатор для константы; то есть вы должны указать его значение в том же операторе, в котором он объявлен.

Значение константы не может быть изменено путем переназначения и не может быть повторно объявлено.

Объявление const создает доступную только для чтения ссылку на значение. Это не означает, что значение, которое оно содержит, является неизменным, просто то, что идентификатор переменной не может быть переназначен.

Поскольку переменные let или const никогда не являются свойствами какого-либо объекта, унаследовавшего метод hasOwnProperty(), его нельзя использовать для проверки их существования.

Относительно наличия и использования hasOwnProperty():

Каждый объект, произошедший от Объект наследует метод hasOwnProperty(). [...] в отличие от оператора in, этот метод не проверяет цепочку прототипов объекта.

Answer 8

Есть еще один короткий способ проверить это, когда вы выполняете простые задания и связанные проверки. Просто используйте Условный (троичный) оператор.

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

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

Если вы хотите проверить переменную, она не должна быть undefined или null. Затем выполните проверку ниже.

Когда переменная объявлена ​​и если вы хотите проверить значение, это даже просто: , и она будет выполнять undefined и null проверки вместе.

var values = variable ? variable : '';

Answer 9

Зависит от того, заботитесь ли вы о том, что переменная была определена или хотите, чтобы она имела значимое значение.

Проверка, является ли тип неопределенным, проверит, была ли переменная определена.

=== null или !== null будет проверять, является ли значение переменной точно null.

== null или != null, будет проверять, является ли значение undefined или null.

if(value) проверит, является ли переменная undefined, null, 0 или пустой строкой.

Answer 10

Самый высокий ответ правильный, используйте typeof.

Однако я хотел отметить, что в JavaScript undefined является изменчивым (по какой-то безбожной причине).Поэтому простое выполнение проверки для varName !== undefined может не всегда возвращаться так, как вы ожидаете, потому что другие библиотеки могли измениться неопределенно.Несколько ответов (например, @ skalee's) предпочитают не использовать typeof, и это может привести к неприятностям.

«Старый» способ справиться с этим - объявить undefined как переменную для смещениялюбое потенциальное отключение звука / перегрузка undefined.Тем не менее, лучший способ по-прежнему использовать typeof, поскольку он игнорирует любое переопределение undefined из другого кода.Особенно, если вы пишете код для использования в дикой природе, где кто знает, что еще может быть запущено на странице ...