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

if (elem) { // or !elem

или

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

или

if (elem != null) {

. В частности: оператор Переменная typeof operator проверит, является ли переменная действительно неопределенной. Оператор

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?

В 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, если элемент DOM не существует …
  3. пустая строка : ''
  4. 0 : число ноль
  5. NaN : не число
  6. (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [

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

if(elem) {

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

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

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

undefined, null, etc

В отличие от простого

elem != null

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


гарантированно является объектом, или если

  • if (elem): можно использовать, если elem может использоваться в случаях, когда указанный false, 0 и т. Д., Считаются значениями по умолчанию (следовательно, эквивалентны undefined или null).

  • typeof elem == 'undefined' имеет особое значение для неинициализированного переменная или свойство. null Это единственная проверка, что

    • не объявлен : переменная, объявленная в определении функции, используется для ссылки на переменные, переданные в функцию. Мы также можем добавить elem not (т. Е. Нет оператора , не является свойством var или не является аргументом функции). Это, на мой взгляд, довольно опасно, поскольку позволяет незаметно проскользнуть опечаткам. Чтобы избежать этого, см. Метод ниже. window Также полезно то, что строгое сравнение с

может быть переопределено другим значением, лучше объявить переменную undefined:

if (elem === undefined) ...

Однако, поскольку глобальный undefined в текущей области видимости перед ее использованием: undefined Второе преимущество этого метода заключается в том, что JS Минификаторы могут уменьшить переменную

var undefined; // really undefined
if (elem === undefined) ...

читатель может неверно истолковать его как сокращение. Другое значение отрывка текста, окруженного

(function (undefined) {
    if (elem === undefined) ...
})();

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

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

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

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

// 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 или perfect метод анализирует строку JSON, создавая значение JavaScript или объект, описываемый строкой.

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

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

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

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

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

var values = variable ? variable : '';

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

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

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

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

if(value) проверьте, является ли переменная undefined, null, 0 Gist Комментарий Источник:

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

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

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


var _undefined;
var _null = null;

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

Нулевое значение — это значение в JavaScript, и typeof null Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. "object"

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

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

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

Например, фрагмент кода

var dataSet;

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

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

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

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

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

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

Мы делаем это, используя самый мощный оператор JasvaScript, оператор закрытии JavaScript внутри циклов — простой практический пример — переполнение стека .:

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

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

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

Самая надежная проверка — «она определена» — выполняется с typeof

if (typeof elem === 'undefined')

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

elem = elem || defaultElem;

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

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

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

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

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"

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

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

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

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

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

Функция вернет true , если существует, иначе (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [, если не существует.

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

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

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

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