From the book Maintainable JavaScript it mentioned :
// Bad: Testing to see if an argument was passed
function doSomething(arg1, arg2, arg3, arg4){
if (arg4 != null){
doSomethingElse();
}
}
but I feel using != null here is quite effective, it filtered both the case of argument not passed or it is passed as null
any reason why the author suggest it is bad ?
!= null is false for undefined, it basically means x !== null && x !== undefined. != does type coercion, and one of the effects of that is that it treats null and undefined as equivalent (null == undefined is true).
So unless you want that, some people recommend not using != with null (or undefined).
And you're quite right that the code defends against two (well actually three) possibilities:
Nothing was passed for the argument at all.
null was passed.
undefined was passed.
But the comment says it's a bad way to test whether an argument was passed, and it is: Because it doesn't catch passing null or undefined. (Passing in null and not passing in anything are different cases.) That doesn't necessarily mean it's a bad way to check the argument for a specific function.
Sure. In javascript you can have null values and undefined values. And they're not the same. A fast and easy approach to check if the arg is valid would probably be:
if (arg4)
And this way you check arg4 is not null, not undefined, and not false. Please be careful with this last condition, you may inform a false value consciously here :-)
EDIT: T.J. Crowder is right here. It's easy to use this and will work in most cases, but be careful.
"", 0, NaN, and false (in addition to null and undefined). There are lots of times when that will bite you. It's a great check for optional object arguments, but other than those, it gets dicey. (Not my dv)I would highly recommend watching http://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare - a brilliant presentation on this matter from the man who created it himself.
Because you can pass anything to a function, also null. If you would to the following:
var obj = new MyObject();
// ...
obj = null;
// ...
doSomething(arg1, arg2, arg3, obj);
You would have passed an argument but your checking would fail because the passed reference is null. Always use the following:
if(typeof arg4 != 'undefined')
// ...
obj = undefined should be identical to omitting an argument. You should address the difference between null and undefined.null, don't check against != null. Checking against null is offered (in this case) as a defect of the code, where the actual intent is only to test the number of defined arguments.
nulland no argument.undefinedusually means "not yet given a value" whilenullusually means "deliberately given a value of nothing".==. But ultimately it depends on what you're trying to guard against.