哪种方法检查变量是否已初始化是更好/正确的方法？（假设变量可以容纳任何内容（字符串，整数，对象，函数等）。

if (elem) { // or !elem

要么

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

要么

if (elem != null) {

你想要的typeof操作。特别：

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
}

有关使用严格比较===而不是简单相等的更多信息==，请参见：
JavaScript比较中应使用哪个equals运算符（== vs ===）？

在许多情况下，使用：

if (elem) { // or !elem

将为您完成工作！...这将检查以下情况：

1. undefined：如果该值未定义且为undefined
2. null：如果为null，例如，如果DOM元素不存在...
3. 空字符串：''
4. 0：数字零
5. NaN：不是数字
6. 假

因此，它将涵盖所有情况，但总有一些奇怪的情况我们也要介绍，例如，一个带有空格的字符串，例如这样的字符串' '，将在javascript中定义，因为它在字符串中包含空格...例如，在这种情况下，您可以使用trim（）再添加一张支票，例如：

if(elem) {

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

同样，这些检查仅针对值，因为对象和数组在Javascript中的工作方式不同，因此空数组[]和空对象{}始终为true。

我创建下面的图像以快速显示答案：

在JavaScript中，可以定义一个变量，但是保留value 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是全局对象的名称）。但是，如果您想像这样的全局变量，则可能是在浏览器中。从主观上讲，using 'name' in window在样式上与window.nameuse引用全局变量一致。通过将全局变量作为属性window而不是变量来访问，可以使您在代码中引用的未声明变量的数量最小化（以利于衬里），并避免全局变量被局部变量覆盖的可能性。另外，如果全局对象使您的皮肤爬行，则仅用此相对较长的棍子，您可能会更舒适地触摸它们。

在大多数情况下，您将使用：

elem != null

不同于简单的if (elem)，它允许0，false，NaN和''，但是废品null或者undefined，使其成为一个好，一般试验的参数的存在，或对象的属性。

其他检查也不是不正确，只是用途不同：

• if (elem)：如果可以被用于elem保证是一个对象，或者如果false，0等被认为是“默认”值（因此等同于undefined或null）。

• typeof elem == 'undefined'当指定null的变量对未初始化的变量或属性具有不同的含义时，可以使用此命令。

  • 如果未声明（即，没有语句，不是属性或函数参数），这是唯一不会引发错误的检查。在我看来，这是非常危险的，因为它会使错别字误入歧途。为避免这种情况，请参见以下方法。elemvarwindow

与undefined以下内容进行严格比较也很有用：

if (elem === undefined) ...

但是，由于undefined可以用另一个值覆盖全局，因此最好undefined在使用前在当前作用域中声明该变量：

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

要么：

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

该方法的第二个优点是，JS缩小器可以将undefined变量减少为单个字符，每次都可以节省几个字节。

检查是否window。hasOwnProperty（“ varname”）

大量typeof答案的替代方法；

var varname = value;在全局范围内用语句声明的全局变量

可以作为窗口对象的属性进行访问。

因此，该hasOwnProperty()方法

返回一个布尔值，指示对象是否具有指定的属性作为其自身的属性（而不是继承它）

可以用来确定是否

一var的“varname的”已在全球宣布即是的一个属性window。

// 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
] );

最好的hasOwnProperty()是，在调用它时，我们不会使用尚未声明的变量-当然，这首先是问题的一半。

虽然不是经常的完美或理想的解决方案，在某些情况下，它只是工作！

笔记

与var用于定义变量相比，上述情况适用let：

声明一个块范围局部变量，可以选择将其初始化为一个值。

与var关键字不同，该关键字在全局范围内或整个函数本地定义变量，而与块范围无关。

在程序和函数的顶层let，与不同var，它不会在全局对象上创建属性。

为了完整起见： const从定义上来说，常量实际上不是变量（尽管其内容可以是变量）；更相关地：

与var变量不同，全局常量不会成为窗口对象的属性。需要一个常量的初始化程序；也就是说，您必须在声明它的同一条语句中指定它的值。

常量的值不能通过重新分配而更改，也不能重新声明。

const声明创建对值的只读引用。这并不意味着它拥有的值是不可变的，只是不能重新分配变量标识符。

由于let变量或const常量绝不是继承该hasOwnProperty()方法的任何对象的属性，因此不能将其用于检查它们的存在。

关于以下产品的可用性和使用hasOwnProperty()：

从Object派生的每个对象都继承该hasOwnProperty()方法。[...]与in运算符不同，此方法不会检查对象的原型链。

如何检查变量是否存在

这是一个相当不错的解决方案，用于测试变量是否存在并已初始化：

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尚未定义变量，因为您无法将不存在的变量传递给函数：

未捕获的ReferenceError：未定义foo

测试功能参数是否未定义

虽然我们的isset函数不能用于测试变量是否存在（出于上述原因），但它确实允许我们测试函数的参数是否未定义：

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

即使没有将值for y传递给function test，我们的isset函数在这种情况下也可以完美运行，因为y在函数中test称为undefined值。

当您执行简单的分配和相关检查时，还有另一种简便的方法可以进行检查。只需使用条件（三元）运算符。

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

当您尝试使用引用变量的实例分配声明全局变量时，这也将有所帮助。

如果要检查变量，则不应为undefined或null。然后执行以下检查。

当声明变量时，如果您想检查该值，这甚至很简单： 它将执行undefined并null一起检查。

var values = variable ? variable : '';

未声明（未定义）测试变量的简短方法是

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

我发现它对于检测在浏览器外部运行的脚本（没有声明window变量）很有用。

这取决于您是否只关心已定义变量，还是希望它具有有意义的值。

检查类型是否未定义将检查变量是否已定义。

=== 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是一个值，您可以在要指示变量没有特定值时将其分配给该变量。未定义 是一个特殊值，它将是未分配变量的默认值。

var _undefined;
var _null = null;

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

Null是JavaScript中的值并typeof null返回"object"

因此，如果您传递空值，则可接受的答案将不起作用。如果传递空值，则需要对空值进行额外检查：

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

最强大的“是否已定义”检查是使用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);

上面的代码片段将返回类似的输出

变量dataSet是：未定义。

为了检查变量是否已经声明/设置，我做了这个肮脏的把戏。

我什至没有找到一种将代码提取到函数中的方法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");
}

这些答案（除了Fred Gandt解决方案之外）都是不正确或不完整的。

假设我需要variableName;携带一个undefined值，因此已经以某种方式声明了var variableName;它，这意味着它已经被初始化了；-如何检查它是否已经声明？

甚至更好-如何通过一次调用立即检查“ Book1.chapter22.paragraph37”是否存在，但不会出现引用错误？

我们通过使用功能最强大的JasvaScript运算符in来实现。

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

在AJAX达到顶峰时期，我编写了一个方法isis（）（后来称为isNS（）），该方法可以确定名称空间是否存在，包括对属性名称（例如“ Book1.chapter22.paragraph37”）的深入测试等等。

但是，由于它以前已经发布过，并且由于它的重要性，它值得在单独的线程中发布，因此我不会在此处发布，而是会提供关键字（javascript + isNS），它将帮助您找到源代码，并附带所有必要的解释。

在问题概述的特定情况下，

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

如果需要相反的功能，则第一个实例中！variable变为!! variable，而在无效函数中===变为！=，并且函数名称更改为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总是返回一个字符串。）但是，如果您对某个函数的参数进行了传递，则可能会始终将它们定义，但如果省略则将其定义为null。

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

试着抓

如果根本没有定义变量，则可以使用try-catch块按如下所示检查此代码，而无需执行中断代码（无需进行use strict模式设置）

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

奖励：（参考其他答案）为什么===比==（来源）更清楚

如果（a == b）

如果（a === b）

我很惊讶尚未提及...

这是使用 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!