您可以使用typeof，如下所示：

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

如果未定义，它将不等于包含字符“undefined”的字符串，因为该字符串未定义。

您可以检查变量的类型：

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

有时你甚至不必检查类型。如果变量的值在设置时不能求值为false（例如，如果它是一个函数），那么可以只对变量求值。例子：

if (something) {
  something(param);
}

if (typeof foo == 'undefined') {
 // Do something
};

注意，在这种情况下不需要严格比较（！==），因为typeof将始终返回字符串。

如果您有兴趣了解变量是否已声明，而不管其值如何，那么使用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

如果您想知道变量是否尚未声明或值未定义，请使用typeof运算符，它保证返回字符串：

if (typeof myVar !== 'undefined')

与undefined的直接比较很麻烦，因为undefineed可以被覆盖。

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

正如@CMS所指出的，这已经在ECMAScript第5版中修补，undefined是不可写的。

if（window.myVar）也将包含这些虚假值，因此它不是很健壮：

false
0
""
NaN
null
undefined

感谢@CMS指出您的第三种情况-if（myVariable）在两种情况下也会抛出错误。第一种情况是尚未定义引发ReferenceError的变量。

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

另一种情况是定义了变量，但有一个getter函数，在调用时抛出错误。例如

// 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?
}

我使用它作为函数参数，并在函数执行时排除它，这样我就得到了未定义的“真实”。尽管它确实需要您将代码放在函数中。我在阅读jQuery源代码时发现了这一点。

undefined = 2;

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

当然，你可以使用typeof。但无论如何，我的所有代码通常都在一个包含函数中，所以使用这个方法可能会在这里和那里节省一些字节。

2020年更新

我倾向于检查类型（即，可以重新定义未定义的）的原因之一与ECMAScript 5的大量采用无关。另一个，你可以使用typeof来检查未声明变量的类型，总是小众的。因此，我现在建议在大多数情况下使用直接比较：

myVariable === undefined

2010年的原始答案

我喜欢使用typeof。当变量从未声明时，它将起作用，这与使用if.与==或==运算符或类型强制进行的任何比较不同（undefined，与null不同，也可能在ECMAScript 3环境中重新定义，这使得它不可靠，尽管现在几乎所有常见环境都符合ECMAScript5或更高版本）。

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

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

我个人使用

myVar === undefined

警告：请注意==用于==，并且myVar先前已声明（未定义）。

我不喜欢myVar==“undefined”的类型。我认为这是长篇大论，没有必要。（我可以用更少的代码完成同样的任务。）

现在有些人读到这篇文章时，会痛苦万分，尖叫道：“等等！WAAITT！！！undefined可以被重新定义！”

凉的我知道这一点。同样，Javascript中的大多数变量都可以重新定义。你应该永远不要使用任何可以重新定义的内置标识符吗？

如果你遵循这条规则，对你有好处：你不是伪君子。

问题是，为了在JS中做大量的实际工作，开发人员需要依赖于可重新定义的标识符。我没有听到有人告诉我我不应该使用setTimeout，因为有人可以

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

总之，不使用原始==undefined的“它可以被重新定义”参数是假的。

（如果您仍然害怕未定义被重新定义，为什么要盲目地将未经测试的库代码集成到代码库中？或者更简单：一个linting工具。）

此外，与typeof方法一样，该技术可以“检测”未声明的变量：

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

但这两种技术在抽象方面都存在漏洞。我劝你不要用这个甚至

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

考虑：

var iAmUndefined;

要获取该变量是否已声明，可能需要使用in运算符。（在许多情况下，您可以简单地读取代码O_O）。

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

但是等等！还有更多！如果一些原型连锁魔法正在发生…？现在，即使是高级操作员也不够。（好吧，我已经完成了这一部分的工作，只是说99%的时间里，==未定义（和***咳嗽***类型）工作正常。如果你真的关心，你可以单独阅读这个主题。）

由于其他答案对我都没有帮助，我建议这样做。它在Internet Explorer 8中对我有效：

if (typeof variable_name.value === 'undefined') {
    // variable_name is undefined
}

说明各种答案结果的一些场景：http://jsfiddle.net/drzaus/UVjM4/

（请注意，在测试中使用var会在作用域包装器中产生差异）

参考代码：

(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

与@Thomas Eding的回答相反：

如果我忘记在代码中声明myVar，那么我将得到myVar未定义。

让我们举一个真实的例子：

我有一个变量名，但我不确定它是否在某处声明。

那么@Anurak的回答会有所帮助：

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.");

更新2018-07-25

自从这篇文章发表以来，已经将近五年了，JavaScript已经取得了长足的进步。在重复原始帖子中的测试时，我发现以下测试方法之间没有一致的差异：

abc==未定义abc==无效0typeof abc==“未定义”abc类型==“未定义”

即使当我修改测试以防止Chrome优化它们时，差异也微不足道。因此，为了清楚起见，我现在建议abc===undefined。

相关内容来自chrome://version:

谷歌Chrome：67.0.3396.99（官方版本）（64位）（队列：稳定）修订：a337fbf3c2ab8ebc6b64b0bfdce73a20e2e2252b参考/分支头/3396@{#790}操作系统：WindowsJavaScript：V8 6.7.288.46用户代理：Mozilla/5.0（Windows NT 10.0；Win64；x64）AppleWebKit/537.36（KHTML，类似Gecko）Chrome/67.03396.99 Safari/537.36

原帖子2013-11-01

在Google Chrome中，以下测试比一种测试速度稍快：

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

差异可以忽略不计。然而，这段代码更加简洁，对于了解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

请注意，第一行以毫秒为单位，而第二行以纳秒为单位。3.4纳秒的差异并不重要。在随后的测试中，时间相当一致。

在本文中，我了解到Undercore.js等框架使用此函数：

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

就我个人而言，我总是使用以下方法：

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

window.undefined属性在所有现代浏览器（JavaScript 1.8.5或更高版本）中都是不可写的。Mozilla文档中：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined，我看到了这一点：使用typeof（）的一个原因是，如果尚未定义变量，它不会抛出错误。

我更喜欢使用

x === undefined 

因为如果x之前没有声明过，它会失败并在我面前爆炸，而不是默默地通过/失败。这提醒我x未声明。我认为JavaScript中使用的所有变量都应该声明。

我知道检查undefined最可靠的方法是使用void 0。

这与较新和较旧的浏览器都兼容，并且不能像window那样被覆盖。在某些情况下，未定义的浏览器可以被覆盖。

if( myVar === void 0){
    //yup it's 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 

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

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

}