На этот вопрос уже есть ответ здесь:

Каков наиболее подходящий способ проверить, является ли переменная неопределенной в JavaScript? Я видел несколько возможных способов:

if (window.myVariable)

или

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

или

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

Этот вопрос уже задавался ранее и уже имеет ответ. Если эти ответы не в полной мере отвечают на ваш вопрос, пожалуйста, задайте новый вопрос. Глядя на вывод

Если вам интересно узнать, была ли объявлена ​​переменная независимо от ее значения, то с помощью in Оператор является самым безопасным. Рассмотрите этот пример. для более надежной проверки.

// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"

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

"theFu" in window; // true
"theFoo" in window; // false

Если вам интересно узнать, не была ли переменная объявлена ​​или имеет значение undefined гарантированно вернет строку. Прямые сравнения с typeof.

if (typeof myVar !== 'undefined')

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

window.undefined = "omg";
"omg" == undefined // true

Как указывало @CMS, это было исправлено в 5-м издании ECMAScript и undefined также будет включать эти ложные значения, поэтому он не очень надежен:

if (window.myVar) Спасибо @CMS за указание на то, что ваш третий случай —

false
0
""
NaN
null
undefined

используется поверх if (myVariable) также может выдать ошибку в двух случаях. Во-первых, когда переменная не была определена, генерируется javascript ReferenceError Глядя на вывод

// abc was never declared.
if (abc) {
    // ReferenceError: abc is not defined
} 

Другой случай, когда переменная была определена, но имеет функцию получения, которая выдает ошибку при вызове. Например,

// or it's a property that can throw an error
Object.defineProperty(window, "myVariable", { 
    get: function() { throw new Error("W00t?"); }, 
    set: undefined 
});
if (myVariable) {
    // Error: W00t?
}

Я лично использую

myVar === undefined

Определите метод с именем remove () для объектов массива, используя функцию прототипирования JavaScript. ===, и {{} был ранее == объявлен myVar (не определен Объявленный . Мне не нравится . Я думаю, что это долго и не нужно. (Я могу сделать то же самое в меньшем количестве кода.) ).


Можно переопределить! «typeof myVar === "undefined" Круто. Я знаю это. Опять же, большинство переменных в Javascript можно переопределить. Если вы никогда не используете какой-либо встроенный идентификатор, который можно переопределить?

Пожалуйста, используйте это: undefined потому что кто-то может

(Если вы все еще боитесь подхода

Если вы следуете этому правилу, это хорошо для вас: вы не лицемер.

Дело в том, что для выполнения большой работы в JS разработчикам нужно полагаться на переопределенные идентификаторы, чтобы что они. Я не слышал, чтобы люди говорили мне, что я не должен использовать setTimeout, этот метод может «обнаружить» необъявленные переменные:

window.setTimeout = function () {
    alert("Got you now!");
};

В нижней строке аргумент «его можно переопределить», чтобы не использовать необработанный === undefined, является поддельным.

Но оба эти метода просочились в свою абстракцию. Я призываю вас не использовать этот или даже undefined Переопределение, почему вы слепо интегрируете непроверенный библиотечный код в свою кодовую базу? Или даже проще: инструмент linting.)


Кроме того, как typeof оператор. (Во многих случаях вы можете просто прочитать код O_o).

if (window.someVar === undefined) {
    doSomething();
}

Но подождите! Есть еще кое-что! Что если произойдет какая-то магия цепочки прототипов …? Теперь даже превосходящий

if (typeof myVar !== "undefined") {
    doSomething();
}

У меня есть данные, которые я хочу записать в файл, и откройте диалоговое окно файла, чтобы пользователь мог выбрать, где сохранить файл. Было бы здорово, если бы он работал во всех браузерах, но он должен работать в Chrome. Я ш …

var iAmUndefined;

Шаблон модуля раскрытия in оператор не достаточен. (Хорошо, я закончил об этой части, за исключением того, чтобы сказать, что для 99 % времени,

if ("myVar" in window) {
    doSomething();
}

операторов или приведение типов с помощью in. (=== undefined (и **** кашляет **** typeof) работает просто отлично. Если вас это действительно волнует, вы можете прочитать об этом самостоятельно.)

массивов typeof: == или ===, в отличие от , также может быть переопределено в средах ECMAScript 3, что делает его ненадежным для сравнения, хотя почти все распространенные среды теперь совместимы с ECMAScript 5 или выше). if Обновление 2018-07-25 undefined, в отличие от null, также может быть переопределен в ECMAScript 3 среды, что делает его ненадежным для сравнения, хотя почти все распространенные среды в настоящее время совместимы с ECMAScript 5 или выше).

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

Вам нужно использоватьtypeof И, кроме того, существует наиболее гибкое решение, которое позволяет переключаться между обоими режимами просто путем предоставления альтернативного значения.

if (typeof something != "undefined") {
    // ...
}

Обновление 2018-07-25

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

  • abc === undefined
  • abc === void 0
  • typeof abc == 'undefined'
  • typeof abc === 'undefined'

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

Соответствующее содержимое из chrome://version:

  • У меня была проблема с ошибками округления в моде 3. Иногда, когда я получал 0, я получал .000 … 01. Это достаточно просто для обработки, просто проверьте & Lt ; = .01. Но тогда иногда я получал бы 2.99999999999998. ОЙ!
  • Редакция: a337fbf3c2ab8ebc6b64b0bfdce73a20e2e2252b-refs / branch -head / 3396 @ {# 790}
  • ОС: Windows
  • JavaScript: V8 6.7.288.46
  • Пользовательский агент: Mozilla / 5.0 (Windows NT 10.0 ; Win64 { ***} x64) AppleWebKit / 537.36 (KHTML, как Gecko) Chrome / 67.0.3396.99 Safari / 537.36

Исходное сообщение 2013-11-01

В Google Chrome следующее было немного быстрее, чем тест typeof:

if (abc === void 0) {
    // Undefined
}

решение ES6 с помощью limit (fixed): void 0 означает. Обратите внимание, однако, что abc все равно должен быть объявлен Глядя на вывод

обоих typeof и void были значительно быстрее, чем сравнение непосредственно с undefined. Я использовал следующий тестовый формат в консоли разработчика Chrome:

var abc;
start =  new Date();
for (var i = 0; i < 10000000; i  ) {
    if (TEST) {
        void 1;
    }
}
end =  new Date();
end - start;

. Результаты были следующими:

Test: | abc === undefined      abc === void 0      typeof abc == 'undefined'
------ ---------------------------------------------------------------------
x10M  |     13678 ms               9854 ms                 9888 ms
  x1  |    1367.8 ns              985.4 ns                988.8 ns

Обратите внимание, что первая строка находится в операции milli секунд, пока вторая строка находится в nano секунд. Разница в 3,4 наносекунды — ничто. Время было довольно последовательным в последующих тестах.

Если он не определен, он не будет равен строке, содержащей символы «неопределено», так как строка не является неопределенной.

Вы можете проверить тип переменной:

if (typeof(something) != "undefined") ...

Иногда вам даже не нужно проверять тип. Если значение переменной не может иметь значение false, когда оно установлено (например, если это функция), тогда вы можете просто оценить переменную. Пример:

if (something) {
  something(param);
}

В ES-6 вы можете просто использовать Object.assign (…). : Это никогда не упоминается в этих nfowindow спрашивает, что стандартное infowindow

(Обратите внимание, что использование var для тестов in имеют значение, когда они находятся в оболочке с ограничениями)

Код для ссылки:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--'   ex;
        }
        console.log(tests[t], result);
        output.innerHTML  = "n"   tests[t]   ": "   result;
    }
})();

Если я сделаю работу над

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined
if (typeof foo == 'undefined') {
 // Do something
};

Обратите внимание, что при строгом сравнении (!==) в этом случае не требуется, поскольку typeof событие, которое устанавливает

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

function isUndefined(obj){
    return obj === void 0;
}

Лично я всегда использую следующее:

var x;
if( x === undefined) {
    //Do something here
}
else {
   //Do something else here
}

Как узнать количество дней между двумя датами в JavaScript? Например, учитывая две даты в полях ввода: https: //developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined , Я вижу это: одна из причин использования typeof () состоит в том, что он не выдает ошибку, если переменная не была определена.

Я предпочитаю использовать подход

x === undefined 

потому что это терпит неудачу и взрывается на моем лице, а не молча проходит / терпит неудачу, если x не был объявлен ранее. Это предупреждает меня, что х не объявлен. Я считаю, что все переменные, используемые в JavaScript, должны быть объявлены.

Самый надежный из известных мне способов проверки может undefined вырожденный код. НЕ ИСПОЛЬЗУЙТЕ. void 0 Глядя на вывод

проблемы. Так что ваш код взаимозаменяем с этим: window.undefined в некоторых случаях.

if( myVar === void 0){
    //yup it's undefined
}

Поскольку ни один из других ответов не помог мне, я предлагаю сделать это. Это сработало для меня в Internet Explorer 8:

if (typeof variable_name.value === 'undefined') {
    // variable_name is undefined
}
// x has not been defined before
if (typeof x === 'undefined') { // Evaluates to true without errors.
   // These statements execute.
}

if (x === undefined) { // Throws a ReferenceError

}

вопреки ответу @Thomas Eding:

. myVar в моем коде, тогда я получу myVar is not defined Глядя на вывод

Давайте рассмотрим реальный пример:

У меня есть имя переменной, но я не уверен, объявлено ли оно где-то или нет. Конечно, вы можете просто использовать

Тогда ответ @ Anurag поможет:

var myVariableToCheck = 'myVar';
if (window[myVariableToCheck] === undefined)
    console.log("Not declared or declared, but undefined.");

// Or you can check it directly 
if (window['myVar'] === undefined) 
    console.log("Not declared or declared, but undefined.");
    var x;
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    if (typeof y === "undefined") {
        alert ("I am not even declared.")
    };

    /* One more thing to understand: typeof ==='undefined' also checks 
       for if a variable is declared, but no value is assigned. In other 
       words, the variable is declared, but not defined. */

    // Will repeat above logic of x for typeof === 'undefined'
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    /* So typeof === 'undefined' works for both, but x === undefined 
       only works for a variable which is at least declared. */

    /* Say if I try using typeof === undefined (not in quotes) for 
       a variable which is not even declared, we will get run a 
       time error. */

    if (z === undefined) {
        alert ("I am neither declared nor defined.")
    };
    // I got this error for z ReferenceError: z is not defined 

Я использую его как параметр функции и исключаю его при выполнении функции, так что я получаю «реальное» неопределенное значение. Хотя для этого требуется, чтобы вы поместили свой код в функцию. Я нашел это во время чтения исходного кода jQuery.

undefined = 2;

(function (undefined) {
   console.log(undefined); // prints out undefined
   // and for comparison:
   if (undeclaredvar === undefined) console.log("it works!")
})()

В другом вопросе пользователь указал, что ключевое слово new опасно для использования, и предложил решение для создания объекта, в котором не использовался новый. Я не верил, что это правда, главным образом потому, что I’v … typeof jQuiteLight