尝试捕获

Question

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

if (elem) { // or !elem

或

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

或

if (elem != null) {

Answer 1

你想要the typeof operator。具体做法是：

if (typeof variable !== 'undefined') {
    // the variable is defined
}

Answer 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?

Answer 3

在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），并避免全局被局部变量遮蔽的可能性。此外，如果全球化使你的皮肤爬行，你可能会感觉更舒服只用这个相对长的棍子接触它们。

Answer 4

在许多情况下，使用：

if (elem) { // or !elem

将为您完成这项工作！...这将检查以下案例：

undefined ：如果未定义该值并且该值为undefined
null ：如果它为null，例如，如果DOM元素不存在...
空字符串：''
0 ：数字
NaN ：不是数字
的假

所以它将涵盖所有情况，但总有一些奇怪的情况，我们也想覆盖，例如，一个带空格的字符串，如' '一个，这将被定义在javascript中，因为它在字符串中有空格...例如，在这种情况下，你使用trim（）添加一个检查，如：

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

此外，这些检查仅适用于值，因为对象和数组在Javascript中的工作方式不同，空数组[]和空对象{}始终 true < / strong>即可。

我创建了下面的图片，以显示答案的简要说明：

Answer 5

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

elem != null

与简单的if (elem)不同，它允许0，false，NaN和''，但拒绝null或{{1}对于参数的存在或对象的属性，它是一个很好的通用测试。

其他检查也不正确，它们只是有不同的用途：

undefined：如果if (elem)保证是对象，或者elem，false等被视为“默认”值，则可以使用（因此相当于0或undefined）。
null可用于指定的typeof elem == 'undefined'与未初始化的变量或属性具有明显含义的情况。
- 如果null未声明（即没有elem声明，则这是不会抛出错误的唯一检查，而不是var的属性，或者不是函数参数）。在我看来，这是相当危险的，因为它允许拼写错误被忽视。为避免这种情况，请参阅以下方法。

对window进行严格比较也很有用：

undefined

但是，因为全局if (elem === undefined) ...可以用另一个值覆盖，所以最好在使用它之前在当前范围内声明变量undefined：

undefined

或者：

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

此方法的第二个优点是JS minifiers可以将(function (undefined) { if (elem === undefined) ... })();变量减少为单个字符，每次都节省几个字节。

Answer 6

如何检查变量是否存在

这是一个非常灵活的解决方案，用于测试变量是否存在且已初始化：

var setOrNot = typeof variable !== typeof undefined;

最常与ternary operator结合使用，以便在某个变量尚未初始化时设置默认值：

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

封装问题

不幸的是，你不能简单地将你的支票封装在一个函数中。

您可能会想到这样的事情：

function isset(variable) {
    return typeof variable !== typeof undefined;
}

但是，如果您正在调用eg，则会产生引用错误。 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

即使y的值没有传递给函数test，我们的isset函数也可以在此上下文中完美运行，因为函数{{1}中已知y }}作为test值。

Answer 7

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

value()

当您尝试使用引用变量的实例赋值声明Global变量时，这也会有所帮助。

如果您想检查变量不应该是var values = typeof variable !== 'undefined' ? variable : '';或undefined。然后执行以下检查。

当声明变量时，如果要检查该值，这甚至是简单的： ，它将同时执行null和undefined检查的

null

Answer 8

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

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

=== null或!== null只会检查变量的值是否正好为null。

== null或!= null会检查值是undefined还是null。

if(value)会检查变量是undefined，null，0还是空字符串。

Answer 9

最高答案是正确的，请使用typeof。

但是，我想指出的是，JavaScript undefined中的内容是可变的（出于某种不正当的理由）。因此，简单地检查varName !== undefined有可能不会像您期望的那样始终返回，因为其他库可能已经更改未定义。一些答案（@ skalee，一个）似乎不喜欢使用typeof，这可能会让人陷入困境。

处理此问题的“旧”方法是声明未定义为var以抵消undefined的任何潜在静音/覆盖。但是，最好的方法仍然是使用typeof，因为它会忽略来自其他代码的任何覆盖undefined。特别是如果你在野外编写代码，谁知道页面上还有什么可以运行...

Answer 10

if (typeof console != "undefined") {    
   ...
}

或更好

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

适用于所有浏览器

Answer 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');

奖金：（请参阅其他答案）为什么===比==（source）更清楚

if（a == b）

if（a === b）

Answer 12

为了讨论，如果我知道变量应该是字符串或对象，我总是更喜欢if (!variable)，所以检查它是否是假的。这可以带来更干净的代码，例如：

＆＃13;

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

＆＃13;

..可以简化为：

＆＃13;

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
}

＆＃13;

Answer 13

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

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

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

Answer 14

很难区分undefined和null。 Null 是您希望指示变量没有特定值时可以分配给变量的值。的未定义是一个特殊值，它将是未分配变量的默认值。

var _undefined; var _null = null; alert(_undefined); alert(_null); alert(_undefined == _null); alert(_undefined === _null);

Answer 15

您可以使用typeof运算符。

例如，

var dataSet;

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

上面的代码片段会返回输出，如

变量dataSet是：undefined。

Answer 16

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

假设我需要我的variableName;带有undefined值，因此它已经以var variableName;的方式声明，这意味着它已经初始化; - 我如何检查它是否已经宣布？

甚至更好 - 如何立即检查＆＃34; Book1.chapter22.paragraph37＆＃34;存在一个单独的调用，但不会引起参考错误？

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

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

在AJAX普及时，我已经编写了一个方法（后来命名）isNS（），它能够确定命名空间是否存在，包括对属性名称的深度测试，例如＆＃34; Book1.chapter22.paragraph37＆＃34;还有更多。

但由于它之前已经发布过，因为它非常重要，所以它应该在一个单独的帖子中发布，我不会在这里发布，但会提供关键字（ javascript + isNS ），这将有所帮助找到源代码，并附上所有必要的解释。

Answer 17

最强大的定义是＆＃39;检查是 typeof

if (typeof elem === 'undefined')

如果您只是检查已定义的变量以指定默认值，则可以轻松读取一个班轮你经常可以这样做：

elem = elem || defaultElem;

使用它通常很好，请参阅：Idiomatic way to set default value in javascript

还有一个使用 typeof 关键字的线路：

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

Answer 18

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

typeof window.console === "undefined"

与

相同

window.console === undefined

我更喜欢后者，因为它更短。

请注意，我们仅在全局范围内查找console（在所有浏览器中都是window个对象）。在这种特殊情况下，这是可取的。我们不希望console在别处定义。

@BrianKelley在他的精彩回答中解释了技术细节。我只是添加了缺乏结论并将其消化为易于阅读的内容。

Answer 19

我根据对象使用两种不同的方式。

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。

Answer 20

我的偏好是typeof(elem) != 'undefined' && elem != null。

但是你选择，考虑把支票放在像这样的函数

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

如果您不知道变量已声明，请继续typeof (x) != 'undefined' && x != null;

如果您知道变量已声明但可能不存在，则可以使用

existy(elem) && doSomething(elem);

您正在检查的变量有时可能是嵌套属性。你可以使用prop || {}下线检查有问题的财产：

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

每个属性使用后（...'|| {}'）。nextProp，以便丢失属性不会抛出错误。

或者您可以使用像existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

这样的存在

Answer 21

这取决于具体情况。如果你正在检查你的代码之外可能已经或可能没有在全局范围内定义的东西（比如jQuery）：

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

（那里不需要严格的相等，typeof总是返回一个字符串。）但是如果你有一个函数的参数可能已经或者没有被传递，它们将被定义，但是如果被省略则为null。

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

Answer 22

if (variable === undefined) {}

工作正常，并且仅检查未定义的内容。

Answer 23

未声明（不是未定义）测试变量的捷径

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

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

Answer 24

我更喜欢这种方法的准确性和简洁性：

           Container(
                height: 200.0,
                child: ListView.builder(
                    scrollDirection: Axis.vertical,
                    shrinkWrap: true,
                  itemCount: _mEmployeeList==null?0:_mEmployeeList.Length,
                    itemBuilder: (context,index)
                        {
                          print(_mEmployeeList[index].EMP_NAME);
                          DropdownButton(
                              items: [
                                DropdownMenuItem(
                                     value:_mEmployeeList[index].EMP_NAME,
                                     child: Text(_mEmployeeList[index].EMP_NAME)
                              ,
                                ),
                              ],
                            // value: _mEmployeeList[index].EMP_NAME,
                            onChanged: (sal){
                                setState(() {
                                  Fhelper.showToast(sal);
                                });
                            },
                          );
                        }
                ),
              ),

正如其他评论和答案中提到的，var x if (x === void 0) { console.log(`x is undefined`) } else { console.log(`x is defined`) } 不能保证是未定义的。因为它不是关键字，所以它可以被重新定义为全局作用域以外的作用域中的变量。下面是展示这种细微差别的小例子：

undefined

有关兼容性，请参阅 void（在 IE5 中支持！？！哇！）。

Answer 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')

Answer 26

我很惊讶尚未提及...

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

Answer 27

在 ReactJS 中，情况有点复杂！这是因为它是一个已编译的环境，自ESLint's no-undef（发布react-scripts@2.0.3起，遵循Oct. 1st, 2018)规则。此处的文档对于对此问题感兴趣的任何人都将有所帮助...

在JavaScript中，在ES6之前，变量和函数声明被提升到作用域的顶部，因此可以在代码的形式声明之前使用标识符...。

[ES6] [新]规则在遇到对尚未声明的标识符的引用时将发出警告。

因此，虽然可能有一个undefined（或“未初始化”）变量，但在没有关闭eslint规则的情况下，在ReactJS中没有声明的变量是不可能。 / p>

这可能非常令人沮丧-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。

Answer 28

您还可以在变量前使用!!来检查其是否已定义。例如

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

Answer 29

要检查变量是否已被声明/设置，我做了这个肮脏的技巧。

即使使用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");
}

Answer 30

Lodash和下划线

如果您使用的是lodash或underscore，则解决方案已经在库中进行了编码：

_.isUndefined(undefined)  // true
_.isUndefined(null)       // false
_.isUndefined("a string") // false

文档：

https://underscorejs.org/#isUndefined
https://lodash.com/docs/4.17.15#isUndefined
http://moutjs.com/docs/latest/lang.html#isUndefined（奖金：另一个下划线，如lib）

Answer 31

这是我最好的解决方案：

  var $;
  if ($.css == undefined){
    console.log('JQ IS NOT PRESENT')
  } else {
    console.log('JQ VERSION ' + jQuery.fn.jquery + ' IS PRESENT')
  }

JavaScript检查变量是否存在（定义/初始化）

31 个答案:

如何检查变量是否存在

封装问题

测试函数参数是否未定义

尝试捕获

if（a == b）

if（a === b）

Lodash和下划线