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

if (elem) { // or !elem

или

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

или

if (elem != null) {

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

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

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?

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

if (elem) { // or !elem

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

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

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

if(elem) {

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

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

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

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

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

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

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

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

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

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

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

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

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

varиз «» перем объявлена глобально т.е. является собственностью 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оператора, этот метод не проверяет цепочку прототипов объекта.

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

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

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значение.

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

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

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

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

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

var values = variable ? variable : '';

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

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

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

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

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

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

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

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

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

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

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

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

Или лучше

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

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

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

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

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

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

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

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

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

if (typeof elem === 'undefined')

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

elem = elem || defaultElem;

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

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

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

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

Например,

var dataSet;

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

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

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

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

Я не нашел способ извлечь код в функцию, даже с 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");
}

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

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

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

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

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

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

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

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

typeof window.console === "undefined"

идентично

window.console === undefined

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

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

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

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

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.

Мое предпочтение 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)

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

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

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

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

Попробуйте поймать

Если переменная вообще не была определена, вы можете проверить это без выполнения кода разрыва, используя блок try-catch следующим образом (вам не нужно use strictпереключаться в режим)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

БОНУС: (ссылаясь на другие ответы) Почему ===это более понятно, чем ==( источник )

если (а == б)

если (а === б)

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

вот несколько дополнительных вариантов, использующих 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!

Вы можете использовать блок try ... catch следующим образом:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Недостатком является то, что вы не можете поместить его в функцию, так как это вызовет ReferenceError.

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))