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

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

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

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

if (elem) { // or !elem

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

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

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

if(elem) {

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

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

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

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

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

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

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

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 не определена, потому что вы не можете передать несуществующую переменную функции:

Неподготовлено ReferenceError: foo не определен

Тестирование параметров функции undefined

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

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 : '';

Проверьте, если объект hasOwnProperty()

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

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

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

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

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

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

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

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

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

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

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

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

}

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

if( foo instanceof Array ) { 

}

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

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

"Старый" способ справиться с этим заключался в объявлении undefined как var, чтобы компенсировать любое возможное отключение/переключение 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)
} 

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

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

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

Мы делаем это с помощью самого мощного оператора JasvaScript оператора in.:

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

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

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

Null - это значение в JavaScript и typeof null возвращает "object"

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

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

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

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _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: undefined.

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

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

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

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

Мое предпочтение - typeof(elem) != 'undefined' && elem != null.

Однако вы выбираете, рассмотрите возможность поместить проверку в такую ​​функцию

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

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

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

existy(elem) && doSomething(elem);

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

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

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

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

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

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;
}

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

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

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

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

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

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

Функция вернет true, если существует, else false, если этого не существует.

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

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

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

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

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

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

Помните, что когда вы проверяете! == or! = Против "undefined", он не будет работать

Протестировано на Firfox Quantum 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");
        }

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

вот несколько дополнительных вариантов, использующих 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 been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it 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!

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

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

Не уверен, что это поможет, мне нужно было проверить, был ли выбран Var, который был определен на странице, перед запуском связанных скриптов, и для меня это работало отлично.

if (window.myvar) { // run scripts here }

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

Я не вижу этого в приведенных выше ответах, поэтому я предлагаю его здесь, я думаю.

function isDefined(x) { return !!x }

if( isDefined(x) ) {
    //The variable is defined
}

! x вернет true iff x либо null, либо undefined, поэтому!! x вернет true, если x не является ни undefined, ни нулевым.

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