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

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

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

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

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

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

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, пустом массиве [] и пустом объекте {} всегда верны.

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

Знайте, что, когда вы проверяете! == 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");
        }

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

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

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

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

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

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

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

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

Или лучше

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

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

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

Я предпочитаю 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например,

var dataSet;

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

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

переменная dataSet: undefined.

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

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

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

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

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

var values = variable ? variable : '';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

function isDefined(x) { return !!x }

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

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

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

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

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

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

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

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

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

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

undefined, boolean, string, number, function

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

}

Object, Array

if( foo instanceof Array ) { 

}