哪种方法检查变量是否已初始化是更好/正确的方法?(假设变量可以容纳任何内容(字符串,整数,对象,函数等))
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
将为您完成工作!...这将检查以下情况:
- undefined:如果该值未定义且为
undefined
- null:如果为null,例如,如果DOM元素不存在...
- 空字符串:
''
- 0:数字零
- NaN:不是数字
- 假
因此,它将涵盖所有情况,但总有一些奇怪的情况我们也要介绍,例如,一个带有空格的字符串,例如这样的字符串' '
,它将在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
是全局对象的名称)。但是,如果您想像这样的全局变量,则可能是在浏览器中。从主观上讲,'name' in window
use在风格上与window.name
use引用全局变量一致。通过将全局变量作为属性window
而不是变量来访问,可以使您在代码中引用的未声明变量的数量最小化(以利于行进),并避免全局变量被局部变量覆盖的可能性。另外,如果全局对象使您的皮肤爬行,则仅用此相对较长的棍子接触它们时,您可能会感到更舒适。
在大多数情况下,您将使用:
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缩小器可以将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
value。
未声明(未定义)测试变量的简短方法是
if (typeof variable === "undefined") {
...
}
我发现它对于检测在浏览器(未声明window
变量)之外运行的脚本很有用。
当您执行简单的分配和相关检查时,还有另一种简便的方法可以进行检查。只需使用条件(三元)运算符。
var values = typeof variable !== 'undefined' ? variable : '';
当您尝试使用引用变量的实例分配声明全局变量时,这也将有所帮助。
如果要检查变量,则不应为undefined
或null
。然后执行以下检查。
声明变量后,如果要检查该值,它甚至很简单: 它将执行undefined
并null
一起检查。
var values = variable ? variable : '';
这取决于您是否只关心已定义变量,还是希望它具有有意义的值。
检查类型是否未定义将检查变量是否已定义。
=== 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)
}
Null是JavaScript中的值并typeof null
返回"object"
因此,如果您传递空值,则可接受的答案将不起作用。如果传递空值,则需要对空值进行额外检查:
if ((typeof variable !== "undefined") && (variable !== null))
{
// the variable is defined and not null
}
很难区分undefined和null。Null是一个值,您可以在要指示变量没有特定值时将其分配给该变量。未定义
是一个特殊值,它将是未分配变量的默认值。
var _undefined;
var _null = null;
alert(_undefined);
alert(_null);
alert(_undefined == _null);
alert(_undefined === _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),它将帮助您找到源代码,并附带所有必要的解释。
我根据对象使用两种不同的方式。
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 window.console === "undefined"
等同于
window.console === undefined
我更喜欢后者,因为它更短。
请注意,我们console
仅在全局范围(window
所有浏览器中的对象)中查找。在这种特殊情况下,这是可取的。我们不想console
在其他地方定义。
@BrianKelley在他的出色回答中解释了技术细节。我仅添加了缺少的结论,并将其摘要为更易于阅读的内容。
试着抓
如果根本没有定义变量,则可以使用try-catch块按以下步骤检查此代码,而无需执行中断代码(无需进行use strict
模式设置)
奖励:(参考其他答案)为什么===
比==
(来源更清晰))
如果(a == b)
如果(a === b)
我的偏好是 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"
我很惊讶尚未提及...
这是使用 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!
if (variable === undefined) {}
正常工作,并且仅检查未定义。
您可以使用try ... catch块,如下所示:
缺点是您不能将其放在函数中,因为它将引发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"))
在ReactJS中,事情有点复杂!这是因为它是一个编译后的环境,自从(2018年10月1日发布)以来遵循ESLint的no-undef
规则。这里的文档对任何对此问题感兴趣的人都有帮助...react-scripts@2.0.3
在JavaScript中,在ES6之前,变量和函数声明被提升到作用域的顶部,因此可以在代码的形式声明之前使用标识符。
[[ES6]的此[新]规则在遇到对尚未声明的标识符的引用时将发出警告。
因此,尽管可能有一个undefined
(或“未初始化的”)变量,但在不关闭eslint规则的情况下,在ReactJS中就不可能有一个未声明的变量。
这可能非常令人沮丧-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项目的人来说,这只是检查是否声明了变量的唯一方法。在结束之前,我想提醒您,如果使用不当会带来安全问题eval()
。
文章标签:initialization , javascript , undefined , variables
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!
评论已关闭!