JavaScript检查变量是否存在（已定义/初始化）窗口hasOwnProperty varname

问题描述 投票：1522回答：24

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

if (elem) { // or !elem

要么

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

要么

if (elem != null) {
javascript variables if-statement initialization undefined
24个回答
2779
投票

你想要the typeof operator。特别：

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

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

但是，我想要指出的是，在JavaScript中，varName !== undefined是可变的（出于一些不道德的原因）。所以简单地检查typeof有可能不会像你期望的那样总是返回，因为其他的库可能已经改变了undefined。一些答案（@ skalee的，一个），似乎不喜欢不使用undefined，这可能会让人陷入困境。

处理这种情况的“旧”方式是声明未定义为var以抵消typeof的任何潜在的静音/覆盖。但是，最好的方法仍然是使用undefined，因为它将忽略来自其他代码的任何覆盖if (typeof console != "undefined") { ... } 。特别是如果您正在编写代码以便在野外使用，谁知道页面上还有什么可以运行...

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

或更好

if (!variable)

适用于所有浏览器

9
投票

为了促成辩论，如果我知道变量应该是一个字符串或一个对象我总是更喜欢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)
}

..可以简化为：


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);
8
投票

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

typeof null
8
投票

Null是JavaScript中的值，"object"返回if ((typeof variable !== "undefined") && (variable !== null)) { // the variable is defined and not null }

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

if (typeof variable === "undefined") {
  ...
}
8
投票

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

window

我发现它有助于检测在浏览器外运行的脚本（没有声明if (typeof elem === 'undefined') 变量）。

7
投票

最强大的'它定义'检查是与typeof

elem = elem || defaultElem;

如果您只是检查已定义的变量以指定默认值，那么通常可以执行以下操作：

Idiomatic way to set default value in javascript

它通常很好用，请参阅：elem = (typeof elem === 'undefined') ? defaultElem : elem;

还有一个使用typeof关键字的班轮：

typeof
7
投票

你可以使用var dataSet; alert("Variable dataSet is : " + typeof dataSet); 运算符。

例如，

variableName;

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

变量dataSet是：undefined。

7
投票

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

假设我需要我的undefined携带var variableName;值，因此它已经以"[variable||property]" in [context||root] >> true||false 的方式声明，这意味着它已经初始化; - 如何检查是否已经申报？

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

我们使用最强大的JavaScript运算符，in运算符：

typeof window.console === "undefined"

在AJAX达到普及的时候，我编写了一个方法（后来命名）isNS（），它能够确定命名空间是否存在，包括对属性名称的深度测试，如“Book1.chapter22.paragraph37”等等。

但由于它以前已经发布，并且由于其非常重要，它值得在一个单独的线程中发布，我不会在这里发布，但会提供关键字（javascript + isNS），它将帮助您找到源代码，支持所有必要的解释。

6
投票

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

window.console === undefined

是完全相同的

console

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

请注意，我们仅在全局范围内查找window（这是所有浏览器中的console对象）。在这种特殊情况下，这是可取的。我们不希望if( !variable ){ // variable is either // 1. ''; // 2. 0; // 3. undefined; // 4. null; // 5. false; } 在其他地方定义。

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

781
投票

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?

5
投票

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

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

有时我不想将空字符串评估为falsey，所以我使用这种情况

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

如果你需要相反，那么在第一个实例中！变量变为!!变量，并且在无效函数中===变为！=并且函数名称变为notInvalid。

4
投票

这取决于实际情况。如果您正在检查可能在代码之外全局定义的内容（可能是jQuery），您需要：

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

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

typeof(elem) != 'undefined' && elem != null
4
投票

我的偏好是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;

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

existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

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

或者你可以使用像this['var_name']这样的存在

2
投票

我很惊讶这还没有提到......

这里有几个使用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! 的其他变体

使用此方法的好处是它可以在定义变量之前使用。

eval
1
投票

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

我还没有找到一种方法来将代码提取到函数中，即使使用"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"); } 也是如此。

qazxswpoi
199
投票

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

178
投票

在许多情况下，使用：

if (elem) { // or !elem

会为你做这个工作！...这将检查以下案例：

  1. undefined：如果没有定义值，那就是undefined
  2. null：如果它为null，例如，如果DOM元素不存在...
  3. 空字符串：''
  4. 0：数字零
  5. NaN：不是一个数字
  6. 假

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

if(elem) {

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

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

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

undefined, null, etc

116
投票

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

elem != null

与简单的if (elem)不同，它允许0，false，NaN和''，但拒绝null或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) ...

要么：

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

这种方法的第二个优点是JS minifiers可以将undefined变量减少为单个字符，每次节省几个字节。

66
投票

如何检查变量是否存在

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

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函数在这种情况下完美地起作用，因为y在函数test中被称为undefined值。

49
投票

Check if window.hasOwnProperty("varname")

替代过多的typeof答案;

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

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

因此，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()的优点在于，在调用它时，我们不使用可能尚未声明的变量 - 这当然是问题的一半。

虽然并不总是完美或理想的解决方案，但在某些情况下，这只是工作！

Notes

使用var定义变量时，上述情况属实，与let相反：

声明一个块作用域局部变量，可选择将其初始化为一个值。

与var关键字不同，let关键字全局定义变量，或者无论块范围如何，都在本地定义整个函数。

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

为了完整性：根据定义，var常量实际上并不是变量（尽管它们的内容可以是）;更相关：

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

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

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

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

关于Object的可用性和使用：

来自hasOwnProperty()的每个对象都继承了in方法。 [...]与var values = typeof variable !== 'undefined' ? variable : ''; 运算符不同，此方法不会检查对象的原型链。

42
投票

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

undefined

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

如果你想检查变量不应该是null或undefined。然后执行以下检查。

声明变量时，如果要检查值，这甚至是简单的：它将同时执行null和var values = variable ? variable : ''; 检查。

=== null
29
投票

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

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

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

!= null或undefined将检查该值是否为null或if(value)。

undefined将检查变量是否为null，0，undefined或空字符串。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.