JavaScript 检查变量是不是存在（已定义/初始化）
Posted
技术标签:
【中文标题】JavaScript 检查变量是不是存在（已定义/初始化）【英文标题】：JavaScript check if variable exists (is defined/initialized)JavaScript 检查变量是否存在（已定义/初始化） 【发布时间】：2010-10-05 20:54:07 【问题描述】：哪种检查变量是否已初始化的方法更好/正确？ （假设变量可以保存任何东西（字符串、整数、对象、函数等））
if (elem) // or !elem
或
if (typeof elem !== 'undefined')
或
if (elem != null)
【问题讨论】：
如果您想知道是否声明了foo，typeof foo === 'undefined' 或typeof foo === typeof undefined
高度赞成的答案不适用于已声明但值为 undefined 的变量。正确答案是这个：***.com/a/36432729/772035
@Paulpro，使用hasOwnProperty('bar')的版本没有其他相同的缺陷，但需要对Node进行一些调整（将window替换为global）。
@Paulpro 确实，但是在您回复之前，我一直在思考，我得出的结论是，这并不是一个真正的实际问题。当您处理块或函数范围的变量时，它通常是您拥有或具有写入权限的代码，因此在任何情况下您都会遇到可修复的运行时错误。而尚未定义（不存在）的变量的常见问题通常在于您无法控制的代码，因此您需要一种检测方法。所以这是 80/20 解决方案。
【参考方案1】：
你想要the typeof operator。具体来说：
if (typeof variable !== 'undefined')
// the variable is defined
【讨论】：
这看起来是一个不错的解决方案，但您能解释一下为什么会这样吗？ 实际上，您应该检查对象是否是您需要的对象。所以这就是 if( typeof console == 'object' ) // 变量是我需要的 @George IV: "just do `if( variable ) " -- 嗯，不，失败为 false 和 0。 'if( variable )' 也无法测试对象属性是否存在。 当变量为null时失败【参考方案2】：
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
有关使用严格比较 === 而不是简单相等 == 的更多信息，请参阅：Which equals operator (== vs ===) should be used in javascript comparisons?
【讨论】：
@StevenPenny 检查时间线。此答案发布后，最佳答案从another question 合并 警告：这不适用于对象的成员，如果您尝试使用some_object.a_member 中的点符号访问它们。
这不会检查变量是否存在，它会检查其值类型。您想检查是否已声明变量。 @BrianKelley 的答案是正确的。
为什么不只是 variable != null 它似乎也能捕获“未定义”变量【参考方案3】：
在很多情况下，使用：
if (elem) // or !elem
将为您完成这项工作！...这将检查以下情况：
-
undefined：如果该值未定义且为
undefined
null：如果为null，例如DOM元素不存在...
空字符串：''
0：数字零
NaN：不是数字
错误
所以它会涵盖所有情况，但总有一些奇怪的情况我们也想涵盖，例如，带有空格的字符串，例如 ' ' 之一，这将在 javascript 中定义因为它在字符串中有空格...例如，在这种情况下，您可以使用 trim() 添加一个检查，例如：
if(elem)
if(typeof elem === 'string' && elem.trim())
///
此外，这些检查仅针对值，因为对象和数组在 Javascript 中的工作方式不同，空数组[] 和空对象 始终true。
我创建了下面的图片来显示答案的简要说明：
【讨论】：
@Alireza，很好！你的回答会帮助很多人。我已经记住了这些虚假值，唯一不确定的就是 []。 我收到“ReferenceError: elem is not defined” @ropo，这是因为您甚至没有定义 elem 来检查它是什么，如果是您的情况，则需要使用提到的 typeof(elem)==="string" 来检查它已经... 那么当它说if(elem) 检查未定义（虽然它返回未定义错误）时，答案是具有误导性的，不是吗？
让我惊讶的点赞数。答案是错误的。上面在cmets中提到，“if(elem)”不检查undefined，如果变量没有定义就会抛出错误。但是，如果 elem 未定义，“if (window.elem) ”不会抛出错误。【参考方案4】：
在 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 的属性而不是变量来访问，可以最大限度地减少代码中引用的未声明变量的数量（为了 linting），并避免全局变量被局部变量遮蔽的可能性。此外，如果全局变量让您的皮肤爬行，您可能会觉得只用这根相对较长的棍子触摸它们会更舒服。
【讨论】：
这仅检查变量是否是全局声明的。如果你编码正确，那么你就是在限制你的全局变量。它将报告本地变量为假： (function() var sdfsfs = 10; console.log( "sdfsfs" in window); )() ` 这是最好的 f$#^%ing 答案。我对此束手无策，试图弄清楚如何确切地解决这个极端情况。杰出的。不知道你能做到这一点。 注意：您的答案已从***.com/questions/519145/…迁移到这里 对于 Angular 用户：不幸的是，在 ng-if 语句中似乎不允许这样做。 这不适用于const 或let 变量【参考方案5】：
在大多数情况下，您会使用：
elem != null
与简单的if (elem) 不同，它允许0、false、NaN 和''，但拒绝null 或undefined，使其成为一个很好的通用测试参数或对象的属性。
其他检查也没有错，只是用途不同：
if (elem)：如果elem被保证是一个对象，或者false、0等被认为是“默认”值（因此相当于undefined或null)。
typeof elem == 'undefined' 可用于指定的null 对未初始化的变量或属性具有不同含义的情况。
elem 没有声明（即没有var 语句，不是@987654339 的属性，则这是唯一一个不会抛出错误的检查@，或者不是函数参数）。在我看来，这是相当危险的，因为它会让错别字在不知不觉中溜走。为避免这种情况，请参阅以下方法。
与undefined 进行严格比较也很有用：
if (elem === undefined) ...
不过，因为全局的undefined可以被另一个值覆盖，所以最好在使用前在当前作用域内声明变量undefined：
var undefined; // really undefined
if (elem === undefined) ...
或者：
(function (undefined)
if (elem === undefined) ...
)();
此方法的第二个优点是 JS 压缩器可以将 undefined 变量减少为单个字符，每次可以节省几个字节。
【讨论】：
我很震惊你可以覆盖undefined。我什至认为答案中不值得一提。可能是所有 Javascript 中唯一可接受的最差变量名。
这会导致异常，如果在全局上下文中使用，则需要在变量前使用window....这不是最好的方法。
由于这个最重要的问题，您应该始终使用void(0) 而不是undefined。
+1，因为这个答案指出，有时您实际上可能想要将false、0 等标识为无效值。【参考方案6】：
检查window.hasOwnProperty("varname")
大量typeof 答案的替代方案；
在全局范围内使用var varname = value; 语句声明的Global 变量
可以作为窗口对象的属性访问。
因此，hasOwnProperty() 方法，
返回一个布尔值，指示对象是否具有指定的属性作为它自己的属性（而不是继承它）
可以用来判断是否
“varname” 的var 已被全局声明即 是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运算符不同，此方法不会检查对象的原型链。
【讨论】：
这是一个很棒的选择，应该在这个问题的顶部被赞成。请使用返回true（例如window.hasOwnProperty('console') 或var hop = "p";window.hasOwnProperty('hop')）的工作示例简化答案标题。
最后因为访问不存在的成员而不会引发错误的东西......所有typeof 的答案都忽略了。
这个答案已经过时了——根据标准 ECMAScript，您可以使用 let 定义变量，其中这些变量不能用作 window [或任何其他可用] 对象的属性。 hasOwnProperty 测试是否存在 属性，而不是变量，因此不能用于检测 let 定义的变量。
@amn 关于var 的使用，答案仍然正确，并且在这方面没有过时。然而，我添加了一个注释，概述了 let 和 const 的使用与 var 的使用有何不同。感谢您的启发；我们一起崛起:)
@amn 我已经重写了答案（希望是最后一次），以更清楚地说明hasOwnProperty 只能以规定的方式用于检查var 变量的存在。我觉得没问题。【参考方案7】：
如何检查变量是否存在
这是一个非常安全的解决方案，用于测试变量是否存在并已被初始化：
var setOrNot = typeof variable !== typeof undefined;
它最常与ternary operator 结合使用，以在某个变量尚未初始化的情况下设置默认值：
var dark = typeof darkColor !== typeof undefined ? darkColor : "black";
封装问题
不幸的是，您不能简单地将检查封装在一个函数中。
你可能会想到做这样的事情：
function isset(variable)
return typeof variable !== typeof undefined;
但是，如果您调用例如，这将产生一个参考错误。 isset(foo) 和变量 foo 尚未定义，因为您无法将不存在的变量传递给函数：
Uncaught ReferenceError: foo is not defined
测试函数参数是否未定义
虽然我们的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 值。
【讨论】：
【参考方案8】：测试变量的短方法未声明（未定义）是
if (typeof variable === "undefined")
...
我发现它对于检测在浏览器外部运行的脚本很有用（没有声明 window 变量）。
【讨论】：
这是可移植的“规范方式”吗？ 这是错误的。window.bar=undefined 已定义并设置为一个值。您的答案无法检测到此变量与变量不存在之间的区别。如果你这样做了this.hasOwnProperty('bar')，它可能会奏效。
此代码不起作用，您可以使用任何浏览器控制台验证这一点
考虑const x = 0; (() => console.log(x, this.hasOwnProperty('x')))();。变量x 已定义但返回false...【参考方案9】：
当您执行简单的分配和相关检查时，还有另一种简便的检查方法。只需使用 条件（三元）运算符。
var values = typeof variable !== 'undefined' ? variable : '';
当您尝试使用引用变量的实例赋值来声明全局变量时，这也会很有帮助。
如果你想检查变量不应该是undefined 或null。然后执行以下检查。
当变量被声明时，如果你想检查它的值，这甚至很简单： 它会同时执行undefined和null检查。
var values = variable ? variable : '';
【讨论】：
答案是完全错误的。 typeof 变量总是返回一个字符串，因此永远不会是假的。例如如果typeof(booooo) 是"undefined" 那么typeof(typeof boooooo) 是"string" 并且typeof boooooo && true 总是true。 @John-Slegers 的答案几乎是你可以用 typeof 得到的缩写。
绝对正确的答案。 Here is an working Fiddle。而且我不知道你在说什么场景。问题是关于检查变量是否存在。
@mpag 不要说错。 证明它。发现错误真的很容易，相反，您可以在这里提供很好的答案！！！。如果答案完全错误 28 程序员不会在不检查我的答案的情况下投票。由于这里有很多著名的答案，他们本可以投票赞成，而不是这个。
其实第二段代码，是不是和上面的条件一样检查。我认为人们会通过这一行 If you wanted to check variable shouldn't be undefined or null. 理解，通过此评论，它清楚地说明，它不执行变量声明检查。那是检查变量值。
您的第二次检查将失败，值为 0【参考方案10】：
这取决于您是否只关心变量是否已定义，或者您是否希望它具有有意义的值。
检查类型是否未定义将检查变量是否已定义。
=== null 或 !== null 只会检查变量的值是否正好是 null。
== null 或 != null 将检查值是否为 undefined 或 null。
if(value) 将检查变量是 undefined、null、0 还是空字符串。
【讨论】：
【参考方案11】：尝试捕捉
如果根本没有定义变量（例如：尚未加载定义全局变量的外部库 - 例如谷歌地图），您可以使用 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');BONUS：（参考其他答案）为什么=== 比== 更清楚（source）
如果（a == b）
如果（a === b）
【讨论】：
仅供参考，(a == b) 放在 Game of Life 网格上并不是那么令人兴奋。【参考方案12】：最高答案是正确的，使用typeof。
但是，我想指出的是，在 JavaScript 中 undefined 是可变的（出于某种不敬虔的原因）。因此，简单地检查varName !== undefined 有可能不会总是像您期望的那样返回，因为其他库可能已更改为未定义。一些答案（一个是@skalee 的），似乎不喜欢使用typeof，这可能会给一个人带来麻烦。
处理此问题的“旧”方法是将 undefined 声明为 var 以抵消 undefined 的任何潜在静音/覆盖。但是，最好的方法仍然是使用typeof，因为它会忽略其他代码对undefined 的任何覆盖。尤其是如果您正在编写用于野外使用的代码，谁知道页面上还可以运行什么......
【讨论】：
这一点没有实际意义，因为如果 varName 未定义，那么varName !== undefined 只会导致 ReferenceError。 undefined 的可变性无关紧要。
注意：您的答案已从***.com/questions/519145/…迁移到这里
在较新的 Javascript 版本中，undefined 是只读属性。但是为了防弹，您可以使用typeof mvVar === typeof void 0。 void 0 总是返回 undefined。【参考方案13】：
if (typeof console != "undefined")
...
或者更好
if ((typeof console == "object") && (typeof console.profile == "function"))
console.profile(f.constructor);
适用于所有浏览器
【讨论】：
为什么您认为后者更好？ @skalee 我同意后者更好。这是因为您在使用它们之前检查类型是否是您想要的类型。 注意：您的答案已从***.com/questions/519145/…迁移到这里【参考方案14】：为了促进辩论，如果我知道变量应该是字符串或对象，我总是更喜欢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)
【讨论】：
这不是 OP 所要求的。如果 data.url 等于'' 您的解决方案会认为它未定义，而实际上它被定义为包含一个空字符串。
我同意这不是所要求的，你是对的：空字符串 '' 将被视为未定义。但我发布了这个，因为我认为它可能对不同答案之间产生的辩论很有用。在示例中，以及在许多其他情况下，如果确实有内容，您只想打印一个字符串，因此可以利用 javascript 认为空字符串和未定义的错误这一事实【参考方案15】：
最强大的“是否已定义”检查是使用 typeof
if (typeof elem === 'undefined')
如果您只是检查一个定义的变量来分配一个默认值，那么为了一个易于阅读的行 你可以经常这样做：
elem = elem || defaultElem;
经常用，看：Idiomatic way to set default value in javascript
还有一个使用 typeof 关键字的衬里：
elem = (typeof elem === 'undefined') ? defaultElem : elem;
【讨论】：
【参考方案16】：Null 是 JavaScript 中的一个值，typeof null 返回 "object"
因此，如果您传递空值，则接受的答案将不起作用。如果传递空值，则需要对空值添加额外的检查：
if ((typeof variable !== "undefined") && (variable !== null))
// the variable is defined and not null
【讨论】：
【参考方案17】：为了检查变量是否已被声明/设置，我做了这个肮脏的把戏。
我还没有找到将代码提取到函数的方法，即使使用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");
【讨论】：
“将代码提取到函数”是什么意思？ @Melab 理想情况下，您可以拥有function isDefined(x)...，然后致电isDefined(myVar)。但是没有办法安全地将一个可能未定义的变量传递给isDefined，因为在变量可以传递给函数之前，它必须被评估，如果它不存在，那么它会抛出（外部try/catch 块，它是 in 函数）。您必须直接在 try/catch 块内评估变量，因此您不能将测试包装在函数中。
虽然从技术上讲这是一个很好的答案，但如果你真的需要它，这将是糟糕设计的证据。【参考方案18】：
很难区分 undefined 和 null。 Null 是当您想指示变量没有特定值时可以分配给变量的值。 未定义 是一个特殊值，它将是未分配变量的默认值。
var _undefined;
var _null = null;
alert(_undefined);
alert(_null);
alert(_undefined == _null);
alert(_undefined === _null);
【讨论】：
将有助于显示每个警报的内联输出。 @demisx 同意，但不建议编辑，为什么不直接做呢？该选项的存在是有原因的。有些人可能认为这很粗鲁；我认为它很有效 - 所以我自己编辑了答案（待审核）。 @Fred - 我查看了编辑历史记录，可以猜到为什么您的编辑被拒绝了......而不是像 demisx 建议的那样仅仅添加行来显示输出是什么，您显着改变了 Jith已经发布了。【参考方案19】：您可以使用typeof 运算符。
例如，
var dataSet;
alert("Variable dataSet is : " + typeof dataSet);
上面的代码sn-p会像这样返回输出
变量数据集是：未定义。
【讨论】：
注意：您的答案已从***.com/questions/519145/…迁移到这里【参考方案20】：我根据对象使用两种不同的方式。
if( !variable )
// variable is either
// 1. '';
// 2. 0;
// 3. undefined;
// 4. null;
// 5. false;
有时我不想将空字符串评估为假，所以我使用这种情况
function invalid( item )
return (item === undefined || item === null);
if( invalid( variable ))
// only here if null or undefined;
如果您需要相反的情况，则首先 !variable 变为 !!variable，在无效函数中 === 变为 != 并且函数名称更改为 notInvalid。
【讨论】：
【参考方案21】：在问题中概述的特定情况下，
typeof window.console === "undefined"
等同于
window.console === undefined
我更喜欢后者，因为它更短。
请注意，我们仅在全局范围内查找 console（在所有浏览器中都是 window 对象）。在这种特殊情况下，这是可取的。我们不想在别处定义console。
@BrianKelley 在他的精彩回答中解释了技术细节。我只是添加了缺乏结论并将其消化成更易于阅读的内容。
【讨论】：
注意：您的答案已从***.com/questions/519145/…迁移到这里 错误。后者在我的控制台中引发异常。【参考方案22】：我的偏好是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)这样的存在
【讨论】：
如果你把它放在一个函数中，那就是多余的。当x 被声明时，typeof (x) != 'undefined' && x != null 等同于 x != null。【参考方案23】：
if (variable === undefined)
工作正常，只检查未定义。
【讨论】：
【参考方案24】：视情况而定。如果您正在检查您想要的可能或可能未在您的代码之外全局定义的内容（可能像 jQuery）：
if (typeof(jQuery) != "undefined")
（这里不需要严格相等，typeof 总是返回一个字符串。）但是如果你有一个函数的参数可能已经或可能没有被传递，它们总是被定义，但如果省略则为 null。
function sayHello(name)
if (name) return "Hello, " + name;
else return "Hello unknown person";
sayHello(); // => "Hello unknown person"
【讨论】：
【参考方案25】：您可以使用如下所示的 try...catch 块：
var status = 'Variable exists'
try
myVar
catch (ReferenceError)
status = 'Variable does not exist'
console.log(status)一个缺点是你不能把它放在一个函数中，因为它会抛出一个 ReferenceError
function variableExists(x)
var status = true
try
x
catch (ReferenceError)
status = false
return status
console.log(variableExists(x))编辑：
如果您使用前端 Javascript 并且需要检查变量是否未初始化（var x = undefined 将被视为未初始化），您可以使用：
function globalVariableExists(variable)
if (window[variable] != undefined)
return true
return false
var x = undefined
console.log(globalVariableExists("x"))
console.log(globalVariableExists("y"))
var z = 123
console.log(globalVariableExists("z"))编辑 2：
如果您需要检查当前范围内是否存在变量，您可以简单地将this 以及包含在字符串中的变量名称传递给函数：
function variableExists(variable, thisObj)
if (thisObj[variable] !== undefined)
return true
return false
class someClass
constructor(name)
this.x = 99
this.y = 99
this.z = 99
this.v = 99
console.log(variableExists(name, this))
new someClass('x')
new someClass('y')
new someClass('z')
new someClass('v')
new someClass('doesNotExist')【讨论】：
【参考方案26】：这些答案（除了 Fred Gandt 解决方案）要么不正确，要么不完整。
假设我需要我的variableName; 来携带undefined 值，因此它已以var variableName; 之类的方式声明，这意味着它已经初始化； - 如何检查它是否已经声明？
甚至更好 - 我如何通过一次调用立即检查“Book1.chapter22.paragraph37”是否存在，但不会引发参考错误？
我们使用最强大的 JasvaScript 运算符，即 in 运算符来做到这一点。：
"[variable||property]" in [context||root]
>> true||false
【讨论】：
if ( ("url" in req.body) == false && req.body.url.length > 1【参考方案27】：我更喜欢这种方法，因为它的准确性和简洁性：
var x
if (x === void 0)
console.log(`x is undefined`)
else
console.log(`x is defined`)
正如在其他 cmets 和答案中所提到的，undefined 不能保证是未定义的。因为它不是关键字，所以它可以在全局范围以外的范围内重新定义为变量。下面是一个展示这种细微差别的小例子：
var undefined = 'bar'
console.log(`In the global scope: $undefined`)
function foo()
var undefined = 'defined'
var x
if (x === undefined)
console.log(`x === undefined`)
else
console.log(`x !== undefined`)
if (x === void 0)
console.log(`x === void 0`)
else
console.log(`x !== void 0`)
foo()请参阅void 了解兼容性（在 IE5 中支持！？！！哇！）。
【讨论】：
【参考方案28】：我很惊讶这还没有被提及......
这里有几个使用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!
【讨论】：
这是错误的。window.bar=undefined 已定义并设置为一个值。您的答案无法检测到此变量与变量不存在之间的区别。如果你这样做了this.hasOwnProperty('bar')，它可能会奏效。【参考方案29】：
在 ReactJS 中，事情有点复杂！这是因为它是一个编译环境，自react-scripts@2.0.3（发布Oct. 1st, 2018)）遵循ESLint's no-undef 规则。此处的文档对任何对此问题感兴趣的人都有帮助...
在 JavaScript 中，在 ES6 之前，变量和函数声明被提升到作用域的顶部，因此可以在代码中的正式声明之前使用标识符......
当遇到对尚未声明的标识符的引用时，[ES6] 的[新] 规则将发出警告。
因此，虽然可以有一个 undefined（或“未初始化”）变量，但 不可能在 ReactJS 中拥有一个未声明的变量而不关闭 eslint 规则。
这可能非常令人沮丧——GitHub 上有很多项目只是利用了 ES6 之前的标准；而直接编译这些不做任何调整基本上是不可能的。
但是，对于 ReactJS， 你可以使用eval()。如果您有一个未声明的变量，例如...
if(undeclaredvar) ...
您可以简单地将这部分重写为...
if(eval('typeof undeclaredvar !== "undefined"')) ...
比如……
if(eval("false"))
console.log("NO!");
if(eval("true"))
console.log("YEAH!");
对于那些将 GitHub 存储库导入 ReactJS 项目的人来说，这只是检查变量是否被声明的唯一方法。在结束之前，我想提醒您there are security issues with eval() if use incorrectly。
【讨论】：
【参考方案30】：您还可以在变量前使用!! 来检查它是否已定义。例如
let dog = "woof";
let chineseCat; // Undefined.
console.log("1.");
console.log(!!dog && !!chineseCat ? "Both are defined" : "Both are NOT defined");
chineseCat= "mao"; // dog and chineseCat are now defined.
console.log("2.");
console.log(!!dog && !!chineseCat ? "Both are defined" : "Both are NOT defined");
输出：
1.
Both are NOT defined
2.
Both are defined
【讨论】：
这是一个节点构造，如果是，是哪个版本...我正在寻找这个，但似乎找不到它... JavaScript :shakesfirst: 这是完全错误的，它只检查变量是否真实，没有定义。!!0 为假，即使 0 已定义。以上是关于JavaScript 检查变量是不是存在（已定义/初始化）的主要内容，如果未能解决你的问题，请参考以下文章
JavaScript 检查Javascript函数是否存在或是否已定义