it-swarm.com.ru

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

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

if (elem) { // or !elem

или же

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

или же

if (elem != null) {
1514
Samuel Liew

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

778
Samuel Liew

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

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

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

198
Brian Kelley

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

if (elem) { // or !elem

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

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

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

if(elem) {

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

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

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

undefined, null, etc

177
Alireza

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

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

116
David Tang

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

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

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.

65
John Slegers

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

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

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

могут быть доступны как свойства объекта окна.

Таким образом, метод hasOwnProperty(), который

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

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

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():

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

49
Fred Gandt

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

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

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

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

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

var values = variable ? variable : '';
42
RajeshKdev

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

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

=== null или !== null только проверит, точно ли значение переменной null.

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

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

29
Alan Geleynse

не определено, логическое, строка, число, функция

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

Объект, Массив

if( foo instanceof Array ) { 

}
28
Yuan Zhaohao

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

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

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

12
shadowstorm
if (typeof console != "undefined") {    
   ...
}

Или лучше

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Работает во всех браузерах

11
boslior

Чтобы внести свой вклад в дискуссию, если я знаю, что переменная должна быть строкой или объектом, я всегда предпочитаю if (!variable), поэтому проверяю, не ложно ли это. Это может привести к более чистому коду, например:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

.. может быть уменьшено до:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 
9
de3

Краткий способ проверки переменной не объявлен (не определен)

if (typeof variable === "undefined") {
  ...
}

Я нашел это полезным для обнаружения скрипта, работающего вне браузера (не объявив переменную window).

8
user2878850

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


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);
8
Jith

Нулевое значение в JavaScript, и typeof null возвращает "object"

Поэтому принятый ответ не будет работать, если вы передадите нулевые значения. Если вы передаете нулевые значения, вам нужно добавить дополнительную проверку для нулевых значений:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}
8
Razan Paul

Эти ответы (кроме решения Фреда Гандта) являются либо неправильными, либо неполными.

Предположим, мне нужен мой variableName; для переноса значения undefined, и поэтому он был объявлен таким образом, как var variableName;, что означает, что он уже инициализирован; - Как я могу проверить, если он уже объявлен?

Или еще лучше - как я могу сразу проверить, существует ли "Book1.chapter22.paragraph37" при одном вызове, но не вызвать ошибку ссылки?

Мы делаем это, используя самый мощный оператор JasvaScript, оператор in .:

"[variable||property]" in [context||root] 
>> true||false

Во времена пиковой популярности AJAX я написал метод (позднее названный) isNS (), который способен определить, существует ли пространство имен, включая глубокие тесты для имен свойств, такие как "Book1.chapter22.paragraph37" и намного больше.

Но так как он был ранее опубликован и из-за его большой важности он заслуживает публикации в отдельной ветке, я не буду размещать его здесь, но предоставлю ключевые слова (javascript + isNS), которые помогут вам найти Исходный код, подкрепленный всеми необходимыми пояснениями.

7
Bekim Bacaj

Самая надежная проверка 'это определено' с typeof

if (typeof elem === 'undefined')

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

elem = elem || defaultElem;

Это часто хорошо использовать, смотрите: Идиоматический способ установить значение по умолчанию в javascript

Также есть один вкладыш, использующий ключевое слово typeof:

elem = (typeof elem === 'undefined') ? defaultElem : elem;
7
Zv_oDD

вы можете использовать оператор typeof.

Например,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

Вышеупомянутый фрагмент кода вернет вывод как

переменная dataSet: неопределенная.

7
Ravindra Miyani

В конкретной ситуации, изложенной в вопросе,

typeof window.console === "undefined"

идентично

window.console === undefined

Я предпочитаю последнее, так как оно короче.

Обратите внимание, что мы ищем console только в глобальной области (которая является объектом window во всех браузерах). В этой конкретной ситуации это желательно. Мы не хотим, чтобы console был определен в другом месте.

@BrianKelley в своем великолепном ответе объясняет технические детали. Я только добавил недостающее заключение и переварил его во что-то более простое для чтения.

6
skalee

Я использую два разных способа в зависимости от объекта.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

Иногда я не хочу оценивать пустую строку как Falsey, поэтому я использую этот случай

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Если вам нужно обратное, то в первом случае переменная становится переменной !!, а в недопустимой функции === становится! =, А имена функций изменяются на notInvalid.

5
SoEzPz

Если вы хотите, чтобы определенный блок что-то делал, используйте это

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

Если вы хотите, чтобы неопределенный блок что-то делал или назначал или определял переменную, используйте эту

if (typeof variable === 'undefined') {
    // the variable is undefined
}
5
Vinayak Shedgeri

Я предпочитаю typeof(elem) != 'undefined' && elem != null.

Как бы вы ни выбрали, подумайте над тем, чтобы поставить проверку в функцию

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Если вы не знаете, объявлена ​​ли переменная, переходите к typeof (x) != 'undefined' && x != null;

Если вы знаете, что переменная объявлена, но может не существовать, вы можете использовать

existy(elem) && doSomething(elem);

Переменная, которую вы проверяете, иногда может быть вложенным свойством. Вы можете использовать опору || {}, чтобы пройти строку, проверяющую существование рассматриваемого свойства:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

После каждого свойства используйте (... '|| {}'). NextProp, чтобы отсутствующее свойство не выдавало ошибку.

Или вы можете использовать существовать, как existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

4
curtwphillips

Это зависит от ситуации. Если вы проверяете что-то, что может или не может быть определено глобально за пределами вашего кода (например, jQuery), вы хотите:

if (typeof(jQuery) != "undefined")

(Нет необходимости в строгом равенстве, typeof всегда возвращает строку.) Но если у вас есть аргументы для функции, которые могут или не могли быть переданы, они всегда будут определены, но будут нулевыми, если опущены.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"
4
jpsimons

Немного более функциональный и простой в использовании:

function exist(obj)
{
    return (typeof obj !== 'undefined');
}

Функция вернет true если существует, иначе false если не существует.

3
tfont

Имейте в виду, что когда вы проверяете! == или! = Против "undefined", это не сработает

Проверено на Firfox Quantom 60.0.1

используйте тест как этот вместо этого, чтобы избежать конфликта

if(!(typeof varibl['fl'] === 'undefined')) {

            console.log(varibl['fl']);
            console.log("Variable is Defined");
        }else{

            console.log(varibl['fl']);
            console.log("Variable is Un-Defined");
        }
3
Aylian Craspa

Как насчет простого:

if(!!variable){
  //the variable is defined
}
2
JasoonS

Я удивлен, что это еще не упомянуто ...

вот несколько дополнительных вариантов, использующих this['var_name']

преимущество использования этого метода в том, что его можно использовать до определения переменной.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!
2
Daniel

Чтобы проверить, была ли переменная объявлена ​​/ установлена, я сделал этот подвох.

Я не нашел способа извлечь код из функции, даже с eval.

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}
1
Ferran Maylinch