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

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

elem != null

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

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

• if (elem): может использоваться, если elem гарантированно будет объектом, или если false, 0, etc. считаются значениями "по умолчанию" (следовательно, эквивалентны 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 переменная к одиночному характеру, сохраняя вас немного байтов каждый раз.

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

if (elem) { // or !elem

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

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

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

if(elem) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var values = variable ? variable : '';

undefined, boolean, string, number, function

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

}

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

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

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

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

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

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

однако я хотел указать, что в JavaScript undefined является изменяемым (по какой-то нечестивой причине). Поэтому просто делаем проверку на varName !== undefined имеет потенциал не всегда возвращаться, как вы ожидаете, потому что другие библиотеки могли измениться неопределенными. Несколько ответов (@skalee, например), похоже, предпочитают не использовать 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)
} 

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

var _undefined;
var _null = null;

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

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

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

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

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

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

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

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

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

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

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

самый надежный "это определено" проверка с 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);

выше фрагмент кода вернет вывод, как

набор данных переменных: undefined.

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

typeof window.console === "undefined"

идентичен

window.console === undefined

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

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

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

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

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

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 как existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

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

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

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

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

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

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

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

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

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

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

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

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

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

функция возвращает правда если существует, то false, если не существует.

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

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

имейте в виду, что при проверке !== или != против "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");
        }

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

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

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

function isDefined(x) { return !!x }

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

!x вернет true, если x равно null или неопределено, так !!x вернет только true, если x не является ни неопределенным, ни нулевым.

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