JavaScript: how to protect from "undefined" is defined confusion? - javascript

In JavaScript undefined is not a keyword, it is a variable. Sort of special variable. This is known to cause trouble because undefined could be reassigned. I do not really know why would anyone want to do that, but this is possible, and maybe you can experience this by using one of those genius frameworks out there, see the code:
function f() {
var z, undefined = 42
console.log(z, undefined, z == undefined)
} f()
Outputs:
undefined 42 false
Now how does one protect himself from such a confusion? Should one just cross his fingers that undefined is undefined?

Just use void 0, it's simply bulletproof. And it's a keyword too.

You can pass undefined as a function parameter, this will ensure that undefined is undefined in the scope of the function.
Many JavaScript libraries use this technique, for example look at jQuery source code
//jQuery
(function( window, undefined ) {
...
})( window );
Because the function expects two formal parameters, but we only give it one, the other gets the (true) value undefined, and then we can rely on that within the function.

one possibility is to check the type of the variable instead of checking equality to undefied:
if (typeof(VARIABLE) != "undefined")
or read on here: How to check for “undefined” in JavaScript?.

Related

Uncaught ReferenceError: myVarible is not defined in if statement comparing to undefined

Does anyone know why would this happen for below code
if(myVarible !=undefined){ myVarible.doSomething() }
myVariable is A global object that is used only on some pages
I am sure I've done this in a past and it always worked.
I also tried
if(!!s){}
Which I am also sure I've used in the past.
finally got it to work with if(typeof s!=="undefined"){}
but I would like to know why undefined variable is not equal to undefined
and why did it work in the past?
Thanks
From what I understood, the problem is, that on some pages you don't create the global myVarible variable at all.
For such case checks
myVarible !== undefined
and
typeof myVarible !== "undefined"
are not equal. The difference is, that only typeof operator can handle non-existing references to names (e.g. variables). All other language constructs throw ReferenceError when encountering reference that cannot be resolved. typeof returns the string "undefined" for this case.
So, in your case, you should use the typeof operator or check existence of the variable property on global object.
if (window.myVarible) {}
link to ecma-script specification defining typeof behavior
Use if(window.myVarible) instead. If you check for the variable per se, JavaScript will try to execute or check the value of the variable1 which in turn yields this error message.
You can also use if(typeof myVarible !== "undefined") which will only look at the type of the variable but not at its value.
1The way that JavaScript checks for the value of a variable depends on whether that variable was written as an object property like window.myVar or without.

Want To Know More About Undefined

As you see,undefined is not a keyword in javascript(Is it right?).So we can use it as a variable though I'm sure this is a bad idea.Now my question is why I can't give a value to undefined.
Code:
var undefined=3;
undefined;//still undefined
Any suggestions will be thankfull.
Because in older environments(before JS 1.8.5) it was possible to change the value of undefined, and checking for something that didn't exist was made in a way that was possible to break. It is a common choice to develop libraries inside their own closures, using the IIFE pattern to create a variable undefined which is not touched from external code(jQuery for example, and most libraries), this is an example:
(function(undefined) {
//code which safely uses undefined
})();
Note that there is a parameter called undefined and the IIFE is invoked without any parameter, making that undefined effectively become undefined. In newer environments it is not possible to change the value of undefined, but for retrocompatibility it is yet used a lot.
Yet the safest way to check for an undefined type is to use typeof. Its usage, in fact, cannot be overridden in any way, and it can be used safely: typeof foo == 'undefined'.
Remember that there is a slight difference between undefined and undeclared:
var x; //declared but undefined
x === undefined; //true
But in older environments you were able to do
var undefined = 1;
var x; //declared, of type undefined, but...
x === undefined // false, because undefined is 1 and x is of type undefined
As I said before, the safest way to check for an undefined variable(being sure it will work in older environments) is to use typeof:
var undefined = 1;
var x;
typeof x == 'undefined'; //true
Remember also that using equality check(==) with undefined also checks for null(in fact, undefined == null but undefined !== null), so I recommend using strictly equality operator(===), which checks only for undefined.
According to the MDN, undefined became non-writable, starting in JavaScript 1.8.5.
That yields that it was fully "legal" to use it as a variable until then.
But it obviously isn't a good idea.
See a full explanation (I'm not the author) of how 'undefined' is used in JavaScript here http://javascriptweblog.wordpress.com/2010/08/16/understanding-undefined-and-preventing-referenceerrors/
Compared to other languages, JavaScript’s concept of undefined is a
little confusing. In particular, trying to understand ReferenceErrors
(“x is not defined”) and how best to code against them can be
frustrating.
In JavaScript there is Undefined (type), undefined (value) and
undefined (variable).
Undefined (type) is a built-in JavaScript type.
undefined (value) is a primitive and is the sole value of the
Undefined type. Any property that has not been assigned a value,
assumes the undefined value. (ECMA 4.3.9 and 4.3.10). A function
without a return statement, or a function with an empty return
statement returns undefined. The value of an unsupplied function
argument is undefined.
undefined (variable) is a global property whose initial value is
undefined (value), Since its a global property we can also access it
as a variable.
As of ECMA 3, its value can be reassigned :
undefined = "washing machine"; //assign a string to undefined (variable)
typeof undefined //"string"
f = undefined;
typeof f; //"string"
f; //"washing machine"
Needless to say, re-assigning values to the undefined variable is very
bad practice, and in fact its not allowed by ECMA 5 (though amongst
the current set of full browser releases, only Safari enforces this).

When do I initialize variables in JavaScript with null or not at all?

I have seen different code examples with variables declared and set to undefined and null. Such as:
var a; // undefined - unintentional value, object of type 'undefined'
var b = null; // null - deliberate non-value, object of type 'object'
If the code to follow these declarations assigns a value to a or to b, what is the reason for using one type of declaration over another?
The first example doesn't assign anything to the variable, so it implicitly refers to the undefined value (see 10.5 in the spec for the details). It is commonly used when declaring variables for later use. There is no need to explicitly assign anything to them before necessary.
The second example is explicitly assigned null (which is actually of type null, but due to a quirk of the JavaScript specification, claims to have type "object"). It is commonly used to clear a value already stored in an existing variable. It could be seen as more robust to use null when clearing the value since it is possible to overwrite undefined, and in that situation assiging undefined would result in unexpected behaviour.
As an aside, that quirk of null is a good reason to use a more robust form of type checking:
Object.prototype.toString.call(null); // Returns "[object Null]"
I just saw this link which clarified my question.
What reason is there to use null instead of undefined in JavaScript?
Javascript for Web Developers states "When defining a variable that is meant to later hold an object, it is advisable to initialize the variable to null as opposed to anything else. That way, you can explicitly check for the value null to determine if the variable has been filled with an object reference at a later time."
I don't think there's a particular better way of doing things, but I'm inclined to avoid undefined as much as possible. Maybe it's due to a strong OOP background.
When I try to mimic OOP with Javascript, I would generally declare and initialize explicitly my variables to null (as do OOP languages when you declare an instance variable without explicitly initializing it).
If I'm not going to initialize them, why even declare them in the first place? When you debug, if you haven't set a value for a variable you watch, you will see it as undefined whether you declared it or not...
I prefer keeping undefined for specific behaviours:
when you call a method, any argument you don't provide would have an undefined value. Good way of having an optional argument, implementing a specific behaviour if the argument is not defined.
lazy init... in my book undefined means "not initialized: go fetch the value", and null means "initialized but the value was null (eg maybe there was a server error?)"
arrays: myArray[myKey] === null if there is a null value for this key, undefined if a value has never been set for this key.
Be careful though, that myVar == null and myVar == undefined return the same value whether myVar is undefined, null or something else. Use === if you want to know if a variable is undefined.
I would explicitly choose null, to not create an object whose id is later overwritten anyway:
var foo = {}; // empty object, has id etc.
var foo2 = null; // good practice, // filled with an object reference at a later time
var foo3;// undefined, I would avoid it
console.log(typeof foo);
console.log(typeof foo2);
console.log(typeof foo3);
Setting null also ensures good readability to identify the datatype (object),
results in
object
object
undefined
Source (Professional JavaScript for Web Developers 3rd Edition):
When defining a variable that is meant to later hold an object, it is
advisable to initialize the variable to null as opposed to anything
else. That way, you can explicitly check for the value null to
determine if the variable has been filled with an object reference at
a later time, such as in this example:
if (foo2 != null){
//do something with foo2
}
The value undefined is a derivative of null, so ECMA-262 defines them to be superficially equal as follows:
console.log(null == undefined); // prints true
console.log(null === undefined);// prints false
null is an object.. When something is undefined it is nothing.. it is not an object, neither a string, because it hasn't been defined yet.. obviously.. then it is simply a property with no function..
example:
You declare a variable with var but never set it.
var foo;
alert(foo); //undefined.
You attempt to access a property on an object you've never set.
var foo = {};
alert(foo.bar); //undefined
You attempt to access an argument that was never provided.
function myFunction (foo) {
alert(foo); //undefined.
}

why is window.foo undefined whereas a call to foo throws an error?

In my understanding defining a variable without the var keyword just evaluates to adding this variable to the window object. And on the other hand, trying to access a member of an object, that isn't yet defined, evaluates to undefined. So I can do things like this:
> foo = "bar";
"bar"
> window.foo;
"bar"
> window.bar;
undefined
Why am I not able to get an undefined variables value (undefined) when accessing it directly?
> bar;
ReferenceError: bar is not defined
There is another thing that I don't quite get, that I think could be related. When I type some literals into the console, they always evaluate to themselves. 1 evaluates to 1, [1] to [1] and so on. I always thought of a function to also be a literal because it has some value-like qualities (beeing first class citizen). But when I try to evaluate an anonymous function, I get a syntax error.
> function() {}
SyntaxError: Unexpected token (
I know that I can define a named function, but that evaluates to undefined (it defines the function somewhere rather then being it itself). So why arent functions literals?
thanks
For the first part of your question, see ReferenceError and the global object. Basically, explicitly referencing a non-existent property of an object will return undefined because there may be cases where you would want to handle that and recover. Referencing a variable that doesn't exist should never happen, though, so it will fail loudly.
For the second part of your question, you are trying to declare a function without a name, which isn't possible. There's a subtle difference between a function declaration and a function expression. Function expressions, for which the function name is optional, can only appear as a part of an expression, not a statement. So these are legal:
var foo = function () { };
(function () { });
But not this:
function () { };
If you just access 'bar', the scope is unclear. The variable is first sought in the local scope (if your inside a function). If it's not found there' the window object is checked. But any error you get logically refers to the 'bar' that doesn't exist in the local scope.
What would you expect to be displayed if you want to show a function like that? A function has no value and its declaration certainly hasn't. You could expect the console to be able to execute a function and return the result, but that's also dangerous. Not only can you have a function that doesn't return a value, but also, functions can contain code that modify their environment, in other words, running a function in the console could modify the current state of the document and the current Javascript state in it.
Javascript has been coded such that if you try to read a property of an object, you get undefined.
But, if you try to read the value of a variable that doesn't exist without referencing it as a property of the global object, it throws an error.
One could explain this choice a number of ways, but you'd have to interview one of the original designers to find out exactly why they chose it. The good news is that once you understand the behavior, you can code it one way or the other depending upon which behavior you want. If you know a global variable might not be defined, then you can preface it with window.xxx and check for undefined.
In any case, if you want to test if a global variable exists, you can do so like this:
if (typeof bar !== "undefined")
or
if (window.bar !== undefined)
Also, be very careful about assuming the console is exactly the same as a real javascript execution because it's not quite the same in a number of ways. If you're testing a borderline behavior, it's best to test it in the actual javascript execution context (I find jsFiddle very useful for that).

What is the purpose of passing-in undefined?

I have noticed jQuery and related keynote plugins like jQuery.UI pass undefined as a parameter into anonymous functions used in their module definitions, like so:
(function($, undefined) { ... })(jQuery);
Alternatively, I have noticed other plugins recommended by jQuery and/or others do NOT pass undefined in as a parameter.
This is probably a silly question, but...
Shouldn't it always be available anyway? Why pass it in? Is there some sort of other purpose or trick going on here?
There are two reasons for that:
1) If undefined is a variable in the function scope rather than a global object property, minifiers can reduce it to a single letter thus achieving a better compression rate.
2) Before ES5*, undefined was a property of the global object without write-protection. So it could be overwritten, resulting in strange and unexpected behavior. You could do something like this:
var test = 123;
undefined = 123;
if (test === undefined){
// this will actually be true, since undefined now equals 123
}
By having an function argument undefined (the name actually does not matter) which you don't pass a parameter to, you could make sure you have a variable which really is undefined so you can test "undefinedness" against this variable.
Btw. the safest method to test for undefined is: typeof ( var ) === 'undefined'
(*) With EcmaScript 5, the global properties undefined, NaN and Infinity became readonly. So with its general adoption in all modern browsers - of course with the exception of IE 9 - overwriting those values was not possible anymore.
That is done to make sure that undefined always is undefined. In older versions of the ECMAScript spec (prior to ECMAScript 5), undefined wasn't a reserved word but a regular variable. In older browsers this would be allowed for instance:
undefined = 2; // Assign a different value to undefined
// Now this statement would be true
if (undefined == 2)
So to make sure that undefined is in fact undefined, even if some other "evil" script would have reassigned undefined with another value, you create a parameter that you call undefined, and then when you call the function, you make sure to not pass a value to that parameter - thus you can be sure that the variable undefined will always be undefined within your function.
So in the case of jQuery:
(function($, undefined) { ... })(jQuery);
They pass in jQuery and assign it to the $ variable for convenience, but then they don't pass a second value to the undefined parameter, thus undefined will be undefined.
Modern browsers
In modern browsers, undefined is a non-configurable, non-writable property per the ECMAScript 5 specification.
undefined is not a reserved word in javascript, it is simply a variable. jQuery is ensuring that if some bad developer overwrites the value of undefined in their javascript, then jQuery will ignore it and establish it's own variable, undefined, which is never passed a value (see the self-executing (jQuery) at the end) and is therefore actually undefined.

Categories