Conclusion. In JavaScript, the main difference between “undefined” and “not defined” is declaration and initialization. The keyword “undefined” means the variable is declared but not assigned or initialized any value. While the keyword “not defined” means the variable is not yet declared.
Undefined means a variable has been declared, but the value of that variable has not yet been defined. For example: var test2; console.log(test2); // undefined.
The JavaScript exception "variable is not defined" occurs when there is a non-existent variable referenced somewhere.
An undeclared variable (that is, one that doesn't exist) does not have a type - and so its type is undefined. I believe that the generally accepted way to test if something is undefined is
typeof var === 'undefined'
rather than
var === undefined
since if the variable does not exist, you cannot access it. The latter case might be more useful if you are sure the variable should exist, since the difference between the two is that an undeclared variable will return false in the first case but cause an error in the second case.
Make sure that you use the triple-equals operator though if you're using the second variant; the (more usual) double-equals operator performs type coercion, so null == undefined
is true while null === undefined
is false. Sometimes you might want the first behaviour, though often you'll want the second, especially if you're testing against undefined, so it's important to recognise the difference. (This is another benefit of the first case since it's not possible to make this subtle error).
Yes, variables can have a value of undefined and you can explicitly assign values to them. Assigning undefined
to a variable though is probably confusing, since it's a bit of a paradox (you've defined the variable as undefined) and it's not possible to distinguish that variable from either variables that don't exist or uninitialised variables. Use null if you want to signify that a variable has no value currently, or if you want to "undeclare" the variable altogether, use delete {varname}
. Assigning undefined to a variable does not remove that variable's declaration; and it will still appear in the list of its owning object's properties if you iterate over them, so I can't think of any situation this would benefit you.
Edit: In response to the comment, when comparing the values with === (or ==), the variable must be deferenced to obtain its current value in order to do the comparison. Since the variable doesn't exist, this dereferencing fails (no real surprises so far). While you might expect the typeof operator to work in a similar way (get the current value, see what its type is) it specifically works with undefined variables. The "short version" (as used by the Mozilla reference ) is simply that "The typeof operator returns a string indicating the type of the unevaluated operand."
The long version, extracted from the ECMAScript spec, is that there's a special case for undefined variables:
11.4.3 typeof UnaryExpression is evaluated as follows:
- Evaluate UnaryExpression (as per 10.1.4 this returns "a value of type Reference whose base object is null and whose property name is the identifier" if the variable is undeclared).
- If Type(Result(1)) is not Reference, go to step 4. (It is a Reference)
- If GetBase(Result(1)) is null, return "undefined". (This is the special case matching undefined variables)
As for your comment to the first question, "how can you classify what does not exist" - it's easy! Simply divide all concepts into things that do exist (e.g. squirrel, rock) and those that don't exist (unicorns, warp drives). That's what undefined means; regardless of its semantics in English, its Javascript meaning is that the variable hasn't been declared or populated yet, and so while the concept of "a variable called foo" is valid, there exists no variable with that name holding a real value.
JavaScript provides several different notions of missing or empty variables (and object properties):
Variables that are actually 'not defined', i.e. they don't exists as a given name isn't bound in the current lexical environment. Accessing such a variable will throw an error, but using typeof
won't and will return 'undefined'
. In contrast, accessing non-existing properties will not throw an error and return undefined
instead (and you may use the in
operator or the hasOwnProperty()
method to check if properties actually do exist).
Existing variables which have not been assigned a value (which is common because of var hoisting) or which have been explicitly set to undefined
. Accessing such a variable will return undefined
, typeof
will return 'undefined'
.
Existing variables which have been explicitly set to null
. Accessing such a variable will return null
, typeof
will return 'object'
. Note that this is misleading: null
is not an object, but a primitive value of type Null (which has the consequence that you can't return null
from constructor functions - you have to throw an error instead to denote failure).
I'd recommend the following practices:
typeof
to check for undefined
, as it will cover the first two cases.undefined
to properties: Use delete
to get rid of them instead; note that you cannot delete variables (but also note that globals are actually properties of the global object and thus can be deleted).null
to mark the absence of a meaningful value (eg the forward reference of the last node of a linked list) or if you want to clear a variable as a hint to the garbage collector.You could go with undefined
for 3. as well and never use null
at all.
I believe it's a difference between JavaScript definition and firebugs of the same thing.
Undefined is just the state of something that has not been defined as a value. So it has no type.
Also what is the difference between var a; and var b = undefined;
var a; alert(a); // undefined
a; alert(a); // "Error "a" not defined"
a = undefined; alert(a); // undefined
2nd example is not valid JavaScript code and the execution will stop. Since this is an error.
alert(a);
Here a
is not defined.
alert(a);
var a=10;
Here a
is undefined because javascript
engine convert this code to
var a;
alert(a); // that's why `a` is defined here
a=10;
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With