我经常看到检查未定义参数等的javascript代码。这样：
1
2
3
| if (typeof input !=="undefined") {
// do stuff
} |
这似乎有点浪费，因为它涉及类型查找和字符串比较，更不用说它的冗长。但它是必需的，因为"undefined"可以被重命名。我的问题是：该代码如何优于此方法：
1
2
3
| if (null != input) {
// do stuff
} |
据我所知，您不能重新定义空值，因此它不会意外中断。而且，因为类型强制的！=运算符，这将检查未定义和空…这通常正是您想要的(例如，对于可选函数参数)。然而，这种形式似乎并不普遍，它甚至导致jslint对你大喊大叫，因为你使用了邪恶！＝算符。为什么这被认为是不好的风格？
- 你为什么把if (input != null)改成if (null != input)？有什么区别？
- @马塞尔，没有真正的区别，但有两个原因去做。第一，对某些人来说，阅读更清晰。第二个原因是，它防止了变量的意外重写。您是否曾经这样做过：如果(foo="value")打算进行比较。如果你养成了在赋值/比较运算符中反转变量的习惯，那么你就不会有这个问题了。
- 对一些人(包括我)来说，这实际上更难理解。此外，大多数IDE都会警告您意外分配任务。但是如果比较变量很长，我仍然使用这个形式。YMMV。
- @Marcelkorpel这被称为"Yoda条件"：umumble.com/blogs/programming/321
- 更难阅读。没有人说"瓶子不空"。
- 一般来说，我更喜欢容易阅读的代码，但我也更喜欢以这种方式编写条件。我认为，@marcel的形式是优越的。对我来说，比传统的书写方式更简洁地说"一个值不等于一个变量"，而这种书写方式很容易出错，正如马塞尔所解释的。空的意思是"空的不是瓶子"。也许是我的数学家。
- if (null != input)只是"yoda speak"的英语使用者(我是其中之一……uuammm)，所以如果它们等同于相同的东西，那么它实际上只是语义。恕我直言。
- 真正的问题是这个问题不应该被编辑成编码样式。例如，我不会将变量命名为"input"，但我不会编辑问题来更改它。
- @Noelabrahams如果你甚至有一次必须在条件中追踪到一个意外的任务，你就会看到if(空！= x)。我们在英语中也不使用递归或三元运算符，但它们值得学习阅读。
- @Spike0Xff您建议使用类似这样的反向语法，但还建议使用递归和三元运算符？写代码不适合每个人，你不需要花这么多时间来确保清洁女工不会损失5分钟来跟踪一个意外的任务。
typeof更安全，因为它允许标识符以前从未声明过：
1
2
3
| if(typeof neverDeclared ==="undefined") // no errors
if(neverDeclared === null) // throws ReferenceError: neverDeclared is not defined |
- 如果(Typeof Neverdeclared)-=Undefined]&Amp；&Amp；=Neverdeclared！【中文解释】：重回原形】【重回原形】
- Use==When comparing with null/undefined.
- @Myggan only if you want to distinguish between the two.In many cases，EDOCX1 original 0 can be better，because it tests for both null and undefined.
- That's very true
- I can't find any difference between typeof some var=============================================对于无效，将返回"目标"。或者我可能是错的？
- I believe@tomtomtom's comment to be the crux of the problem-I can't understand why one would use the EDOCX1 niplifical 1或EDOCX1 niplifical 2 operators when they comparing a value whose type i s known to be a string.
- @Tomtom is right-in case of typeof comparison，==-and=-will give the same results.See symfony-world.blogspot.com/2013/07/Javascript-dataypes.html for more about typeof(and instancef)
- 不使用类型操作程序，当检查未开发变量。这是不可接受的。When you need to check global variable which might throw an mistake，just write it with global object-like this in browsers：if(window.never rdekered===)
- @Capaj I disagree with the readability argument，not that my opinion matters.但是，如果我们只是在处理全球变量，你就提出了一种替代办法。In any other case，we must use typeof to avoid errors，yes？
- @Thekingoftruth well when I want to know if some property of an object is undefined，I already suppose the object exists，therefore I can write it as：if(Myobj.prop====================================================Myobj does
- So either check typeof foo="undefined"and foo=="null is doing the same thing except you will get a mistake for check if it is null？"
- @Capaj，actually you can declare undefined as an actual variable：try var undefined="Now I'm a string！"专员
- @Mydoglisu in modern browsers initializing this way does nothing-it will still return the"undefined"value.
- @Rgripper，there have been some changes lately，and while you're correct，we should stick with best practices and address this backwards as well，I.E.Use typeof instead
- @Mydoglisu Clear Code should be prefered unless otherwise.The only reasons for that legacy check are a usage of legalcy libraries or expectation that script will be used by an external developer.最重要的是不应该说关于那个IMO。
- @Seanmonstar how do I know that you mean to check for both and did't make a mistake？如果你想为both EDOCX1检查3个音标和4个音标和4个音标的编码，就应该对它进行清理。如果有一个评论要解释，both are meant，你可能已经写好了，在第一个地方有充分的条件。
- Well，if you're using es6 stuff like EDOCX1 penal 5 or EDOCX1 6，weocx1 penal 7 is no longer safe.字母名称
- Putting the constant first like this：EDOCX1 universal 10(or EDOCX1 universal 11)prevents the not-so-obvious mistakes like this：EDOCX1 universifical 12 oIQ 35GoodcodingPractice
如果声明变量(使用var关键字、作为函数参数或作为全局变量)，我认为最好的方法是：
1
| if (my_variable === undefined) |
jquery做到了，所以对我来说已经足够好了：-)
否则，您必须使用typeof来避免ReferenceError。
如果希望重新定义未定义，可以这样包装代码：
1
2
3
| (function(undefined){
// undefined is now what it's supposed to be
})(); |
- 如果已经定义了未定义，那么您不会通过一个名为undefined的参数将它传递给匿名函数，而什么也没有完成吗？
- @Anthony Disanti:不，undefined是函数参数的名称，而不是其值。没有向函数传递任何内容，这意味着第一个参数的值未定义。
- 啊，我错了，谢谢你的跟进。我已经取消了投票，对不起。
- 为什么要编写一个异常来处理另一个开发人员声明的未定义，而您只需在开始时正确地执行它？jquery按照您在函数中显示的方式包装初始匿名函数，以确保未定义，并减少缩小的大小。简单地说，如果它能以这种方式给出意想不到的结果，为什么要冒险让懒惰的编程避免输入(typeof variable==‘undefined’)。如果我们想要(typeof variable=='object')，我们应该提供一个默认变量，它也是一个对象，所以我们可以这样做(variable===object)？
好方法：
1
| if(typeof neverDeclared =="undefined") //no errors |
但最好的方法是通过以下途径进行检查：
1
| if(typeof neverDeclared === typeof undefined) //also no errors and no strings |
- var undefined=function()；if(typeof neverdeclared==typeof undefined)；neverdecalled！='函数'；jsfiddle.net/hbpz5返回typeof var；返回字符串。没有错误或字符串，但不会始终给出预期的结果。授权开发人员不应该声明未定义，但是有一些框架和库可以这样做。
- 所以用这个……
- 我主要是使用if (typeof neverDeclared === typeof undefined) {但lint throws是错误的。"一个字符串，而不是预期的和看到的"typeof。""你怎么会"绕过这个错误？我们应该submit到lint’s的需求和使用的"好"，而不是通？？？？？？？
- "fyrye做你知道任何JavaScript的大学图书馆/ frameworks那真的mutate undefined？？？？？？？我知道它是可能的，但我很喜欢to find安在野生example of"，这里是在你的爱encounter这讨厌的wildebeest！！！！！！！"
- typeof neverDeclared === typeof void 0；D
- 它的易错的事实，因为你们是relying是某一变量("undefined")不被定义的。这可以是虚假的，表现出的其他文章。你不能总是做if(typeof neverDeclared === typeof undefined_variable_with_a_name_assumed_to_be_never_defined) {页，但它的长。
你不必担心未定义的被重命名。如果有人重命名未定义，那么如果检查失败，您将面临比仅几个更大的麻烦。如果您真的想保护您的代码，请将其包装在iffe(立即调用的函数表达式)中，如下所示：
1
2
3
| (function($, Backbone, _, undefined) {
//undefined is undefined here.
})(jQuery, Backbone, _); |
如果您在浏览器环境中使用全局变量(已经是错误的)，我将检查未定义的，如下所示：
1
2
3
| if(window.neverDefined === undefined) {
//Code works
} |
因为全局变量是window对象的一部分，所以您可以简单地检查未定义的变量，而不是强制转换为字符串并比较字符串。
除此之外，为什么没有定义变量？我见过很多代码，它们检查变量的存在并基于此执行一些操作。我从未见过这种方法的正确之处。
- 输入验证和依赖性检查都是使用它的好理由。如果我的javascript文件依赖于已加载的其他文件或已声明的init对象，那么测试文件依赖于未定义的对象或属性，并抛出一个好的异常，而不是让脚本在不可预知的地方失败是很有用的。
- 听起来你可能需要一些AMD的产品(require.js)
- 或者我可能只想做一个非常简单的比较，而不是在我的项目中包含另一个库：)
- 编辑太迟：(.想要添加-require.js也不是输入验证的正确解决方案(我在初始注释中提到的init对象)。如果有一个对象希望在加载脚本之前用某些值填充，那么在未定义这些值的情况下抛出异常是很有用的。
- 使用此方法是否意味着您可以使用"输入类型"！=未定义的？如果没有未定义的引号，因为没有人会重命名它？
- 不，因为typeof返回字符串。所以typeof undefined返回"undefined"。窗口输入！==未定义(如果变量在全局spoce中)
- //此处未定义。我不熟悉JavaScript。那是什么意思？
- 在JavaScript中，每个函数都有自己的作用域。用3个引用调用IIFE，但它接受4个参数，第4个参数命名为undefined。因为只有3个参数被传递给该函数，所以第4个参数被自动分配给原始值undefined。Peeter这样做的目的是，即使有人在其他地方为变量undefined指定了不同的值，它仍然在这个函数的范围内具有undefined的原始值。developer.mozilla.org/en-us/docs/web/javascript/reference/&hellip；
如果您真的担心未定义被重新定义，您可以使用如下辅助方法来防止这种情况：
1
2
3
4
| function is_undefined(value) {
var undefined_check; // instantiate a new variable which gets initialized to the real undefined value
return value === undefined_check;
} |
这是因为当有人写undefined ="foo"时，他只允许名称undefined引用一个新值，但他不改变undefined的实际值。
- 然而，你现在介绍一个功能呼吁，这将有助于业绩。
- 我不认为这一职能会导致死亡，这是一个非常相似的领域，这个领域将是bottleneck。但是，任何方式，如果你有你通常的大匿名功能，其中包含你的图书馆whatever，你也可以定义EDOCX1 13在顶部，他们只是使用它的每一个地方在你的法典。
- Agreed，and I'm not saying this is a bad idea.It's just worth pointing out that calling this function will perform slower than doing a EDOCX1
- I think this function is simple enough that i t would be inlined，so performance would't be affected.
- @蒂姆：首先写代码，这是可读的。第二步写代码，这是可维护的，然后，如果真的慢了的话。然后考虑性能。
- @安德烈亚斯：我对此没有意见。我想我只是谨慎地提出了关于性能的观点，而实际上没有提出任何建议。
- 您也可以使用void 0代替变量。
- 它是否仍然只对已显式声明的变量有效？例如，如果我在等待我的代码检查函数是否被定义，它仍然会导致一个错误。
还可以使用void运算符获取未定义的值：
1
2
3
| if (input !== void 0) {
// do stuff
} |
(是的，正如另一个答案所指出的那样，如果变量没有声明，这将抛出一个错误，但这种情况通常可以通过代码检查或代码重构排除，例如使用window.input !== void 0测试全局变量或添加var input)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| function greet(name, greeting) {
name = (typeof name !== 'undefined') ? name : 'Student';
greeting = (typeof greeting !== 'undefined') ? greeting : 'Welcome';
console.log(greeting,name);
}
greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!
//ES6 provides new ways of introducing default function parameters this way:
function greet2(name = 'Student', greeting = 'Welcome') {
// return '${greeting} ${name}!';
console.log(greeting,name);
}
greet2(); // Welcome Student!
greet2('James'); // Welcome James!
greet2('Richard', 'Howdy'); // Howdy Richard! |
在这个场景中，如果(typeof input !== 'undefined')被用于提供默认的函数参数，我实际上会遇到：
1
2
3
4
5
6
7
8
9
10
| function greet(name, greeting) {
name = (typeof name !== 'undefined') ? name : 'Student';
greeting = (typeof greeting !== 'undefined') ? greeting : 'Welcome';
return `${greeting} ${name}!`;
}
greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard! |
ES6提供了引入默认函数参数的新方法：
1
2
3
4
5
6
7
| function greet(name = 'Student', greeting = 'Welcome') {
return `${greeting} ${name}!`;
}
greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard! |
这比第一个选项更详细、更清晰。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| var bar = null;
console.log(typeof bar ==="object"); //true yes
//because null a datatype of object
var barf ="dff";
console.log(typeof barf.constructor);//function
console.log(Array.isArray(bar));//falsss
console.log((bar !== null) && (bar.constructor === Object)); //false
console.log((bar !== null) && (typeof bar ==="object")); // logs false
//because bar!==null, bar is a object
console.log((bar !== null) && ((typeof bar ==="object") || (typeof bar ==="function"))); //false
console.log(typeof bar === typeof object); //false
console.log(typeof bar2 === typeof undefined); //true
console.log(typeof bar3 === typeof undefinedff); //true
console.log(typeof bar2 == typeof undefined); //true
console.log((bar !== null) && (typeof bar ==="object") && (toString.call(bar) !=="[object Array]")); //false |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
| (function(){
var a= b = 3;
var ed = 103;
})();
//console.log(ed); //ed is not defined
console.log("a defined?" + (typeof a !== 'undefined')); //no define
console.log("b defined?" + (typeof b !== 'undefined')); //yes define
console.log(typeof(b)); //number
console.log(typeof(4+7)); //number
console.log(b); //3
console.log(typeof("4"+"7")); //string
var e="ggg";
console.log(typeof(e)); //string
var ty=typeof(b);
console.log(ty); //number
console.log(typeof false); //boolean
console.log(typeof 1); //number
console.log(typeof 0); //number
console.log(typeof true); //boolean
console.log(typeof Math.tan); //function
console.log(typeof function(){}); //function
if(typeof neverDeclared =="undefined") //no errors
if(typeof neverDeclared ==="undefined") //no errors
//if(neverDeclared == null) //showing error
console.log(typeof {a:1}); //object
console.log(typeof null); //object
console.log(typeof JSON); //object
console.log(typeof Math); //object
console.log(typeof /a-z/); //object
console.log(typeof new Date()); //object
console.log(typeof afbc); //undefined
//console.log(typeof new);//error
document.write(" * oprator as math");
var r=14*"4";
document.write(r);
document.write(" + oprator as string");
var r=14+"44";
document.write(r);
document.write(" Minus Operator work as mathematic");
var r=64-"44";
document.write(r);
document.write("");
console.log(typeof(4*"7")); //returns number
console.log(typeof(4+"7")); //returns string |
1
| Interview Question in JavaScript |
- 你能提供的解释吗？
- 这是个可能的值：那typeof时返回布尔值，对象，函数，字符串，数字，和undefined。。。。。。。在typeof算子是用来获取的数据类型(时返回一个字符串的ITS operand)。在operand可以either literal A或A的数据结构，如作为一个变量的函数，或是面向。在操作时返回的数据类型。语法typeof operand或typeof(operand)
1
| if (input == undefined) { ... } |
工作很好。当然，这不是一个null比较，但我通常会发现，如果我需要区分undefined和null的话，我实际上更需要区分undefined和任何虚假值，所以
做到了。
如果一个程序重新定义了undefined，那么不管怎样，它真的是脑死亡。
我能想到的唯一原因是为了IE4的兼容性，它不理解undefined关键字(不幸的是，它实际上不是关键字)，但当然值可以是undefined，所以您必须具备：
上面的比较就可以了。
在第二个例子中，您可能需要双括号来让lint高兴？
- 您的input == undefined将在null输入上返回true。