Which method of checking if a variable has been initialized is better/correct? (Assuming the variable could hold anything (string, int, object, function, etc.))
if (elem) { // or !elem
or
if (typeof(elem) !== 'undefined') {
or
if (elem != null) {
This question is related to
javascript
variables
initialization
undefined
You could use a try...catch block like the following:
var status = 'Variable exists'
try {
myVar
} catch (ReferenceError) {
status = 'Variable does not exist'
}
console.log(status)
_x000D_
A disadvantage is you cannot put it in a function as it would throw a ReferenceError
function variableExists(x) {
var status = true
try {
x
} catch (ReferenceError) {
status = false
}
return status
}
console.log(variableExists(x))
_x000D_
Edit:
If you were working in front-end Javascript and you needed to check if a variable was not initialized (var x = undefined
would count as not initialized), you could use:
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"))
_x000D_
Edit 2:
If you needed to check if a variable existed in the current scope, you could simply pass this
to the function, along with the name of the variable contained in a string:
function variableExists(variable, thisObj) {
if (thisObj[variable] !== undefined) {
return true
}
return false
}
class someClass {
constructor(name) {
this.x = 99
this.y = 99
this.z = 99
this.v = 99
console.log(variableExists(name, this))
}
}
new someClass('x')
new someClass('y')
new someClass('z')
new someClass('v')
new someClass('doesNotExist')
_x000D_
Short way to test a variable is not declared (not undefined) is
if (typeof variable === "undefined") {
...
}
I found it useful for detecting script running outside a browser (not having declared window
variable).
It depends if you just care that the variable has been defined or if you want it to have a meaningful value.
Checking if the type is undefined will check if the variable has been defined yet.
=== null
or !== null
will only check if the value of the variable is exactly null
.
== null
or != null
will check if the value is undefined
or null
.
if(value)
will check if the variable is undefined
, null
, 0
, or an empty string.
if (variable === undefined) {}
works just fine, and only checks for undefined.
The most robust 'is it defined' check is with typeof
if (typeof elem === 'undefined')
If you are just checking for a defined variable to assign a default, for an easy to read one liner you can often do this:
elem = elem || defaultElem;
It's often fine to use, see: Idiomatic way to set default value in javascript
There is also this one liner using the typeof keyword:
elem = (typeof elem === 'undefined') ? defaultElem : elem;
If variable was not defined at all, you can check this without break code execution using try-catch block as follows (you don't need to use strict
mode)
try{
notDefinedVariable;
} catch(e) {
console.log('detected: variable not exists');
}
console.log('but the code is still executed');
notDefinedVariable; // without try-catch wrapper code stops here
console.log('code execution stops. You will NOT see this message on console');
_x000D_
BONUS: (referring to other answers) Why ===
is more clear than ==
(source)
In JavaScript, a variable can be defined, but hold the value undefined
, so the most common answer is not technically correct, and instead performs the following:
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
}
That may suffice for your purposes. The following test has simpler semantics, which makes it easier to precisely describe your code's behavior and understand it yourself (if you care about such things):
if ("v" in window) {
// global variable v is defined
} else {
// global variable v is not defined
}
This, of course, assumes you are running in a browser (where window
is a name for the global object). But if you're mucking around with globals like this you're probably in a browser. Subjectively, using 'name' in window
is stylistically consistent with using window.name
to refer to globals. Accessing globals as properties of window
rather than as variables allows you to minimize the number of undeclared variables you reference in your code (for the benefit of linting), and avoids the possibility of your global being shadowed by a local variable. Also, if globals make your skin crawl you might feel more comfortable touching them only with this relatively long stick.
You can also use !!
before a variable to check if it's defined. E.g.
let dog = "woof";
let chineseCat; // Undefined.
console.log("1.");
console.log(!!dog && !!chineseCat ? "Both are defined" : "Both are NOT defined");
chineseCat= "mao"; // dog and chineseCat are now defined.
console.log("2.");
console.log(!!dog && !!chineseCat ? "Both are defined" : "Both are NOT defined");
Output:
1.
Both are NOT defined
2.
Both are defined
The highest answer is correct, use typeof.
However, what I wanted to point out was that in JavaScript undefined
is mutable (for some ungodly reason). So simply doing a check for varName !== undefined
has the potential to not always return as you expect it to, because other libs could have changed undefined. A few answers (@skalee's, for one), seem to prefer not using typeof
, and that could get one into trouble.
The "old" way to handle this was declaring undefined as a var to offset any potential muting/over-riding of undefined
. However, the best way is still to use typeof
because it will ignore any overriding of undefined
from other code. Especially if you are writing code for use in the wild where who knows what else could be running on the page...
In ReactJS, things are a bit more complicated! This is because it is a compiled environment, which follows ESLint's no-undef
rule since [email protected]
(released Oct. 1st, 2018). The documentation here is helpful to anyone interested in this problem...
In JavaScript, prior to ES6, variable and function declarations are hoisted to the top of a scope, so it's possible to use identifiers before their formal declarations in code....
This [new] rule [of ES6] will warn when it encounters a reference to an identifier that has not yet been declared.
So, while it's possible to have an undefined
(or "uninitialized") variable, it is not possible to have an undeclared variable in ReactJS without turning off the eslint rules.
This can be very frustrating -- there are so many projects on GitHub that simply take advantage of the pre-ES6 standards; and directly compiling these without any adjustments is basically impossible.
But, for ReactJS, you can use eval()
. If you have an undeclared variable like...
if(undeclaredvar) {...}
You can simply rewrite this part as...
if(eval('typeof undeclaredvar !== "undefined"')) {...}
For instance...
if(eval("false")) {
console.log("NO!");
}
if(eval("true")) {
console.log("YEAH!");
}
_x000D_
For those importing GitHub repositories into a ReactJS project, this is simply the only way to check if a variable is declared. Before closing, I'd like to remind you that there are security issues with eval()
if use incorrectly.
you can use the typeof
operator.
For example,
var dataSet;
alert("Variable dataSet is : " + typeof dataSet);
Above code snippet will return the output like
variable dataSet is : undefined.
To contribute to the debate, if I know the variable should be a string or an object I always prefer if (!variable)
, so checking if its falsy. This can bring to more clean code so that, for example:
if (typeof data !== "undefined" && typeof data.url === "undefined") {_x000D_
var message = 'Error receiving response';_x000D_
if (typeof data.error !== "undefined") {_x000D_
message = data.error;_x000D_
} else if (typeof data.message !== "undefined") {_x000D_
message = data.message;_x000D_
}_x000D_
alert(message); _x000D_
}
_x000D_
..could be reduced to:
if (data && !data.url) {_x000D_
var message = data.error || data.message || 'Error receiving response';_x000D_
alert(message)_x000D_
}
_x000D_
In the majority of cases you would use:
elem != null
Unlike a simple if (elem)
, it allows 0
, false
, NaN
and ''
, but rejects null
or undefined
, making it a good, general test for the presence of an argument, or property of an object.
The other checks are not incorrect either, they just have different uses:
if (elem)
: can be used if elem
is guaranteed to be an object, or if false
, 0
, etc. are considered "default" values (hence equivalent to undefined
or null
).
typeof elem == 'undefined'
can be used in cases where a specified null
has a distinct meaning to an uninitialised variable or property.
elem
is not declared (i.e. no var
statement, not a property of window
, or not a function argument). This is, in my opinion, rather dangerous as it allows typos to slip by unnoticed. To avoid this, see the below method.Also useful is a strict comparison against undefined
:
if (elem === undefined) ...
However, because the global undefined
can be overridden with another value, it is best to declare the variable undefined
in the current scope before using it:
var undefined; // really undefined
if (elem === undefined) ...
Or:
(function (undefined) {
if (elem === undefined) ...
})();
A secondary advantage of this method is that JS minifiers can reduce the undefined
variable to a single character, saving you a few bytes every time.
This is a pretty bulletproof solution for testing if a variable exists and has been initialized :
var setOrNot = typeof variable !== typeof undefined;
It is most commonly used in combination with a ternary operator to set a default in case a certain variable has not been initialized :
var dark = typeof darkColor !== typeof undefined ? darkColor : "black";
Unfortunately, you cannot simply encapsulate your check in a function.
You might think of doing something like this :
function isset(variable) {
return typeof variable !== typeof undefined;
}
However, this will produce a reference error if you're calling eg. isset(foo)
and variable foo
has not been defined, because you cannot pass along a non-existing variable to a function :
Uncaught ReferenceError: foo is not defined
While our isset
function cannot be used to test whether a variable exists or not (for reasons explained hereabove), it does allow us to test whether the parameters of a function are undefined :
var a = '5';
var test = function(x, y) {
console.log(isset(x));
console.log(isset(y));
};
test(a);
// OUTPUT :
// ------------
// TRUE
// FALSE
Even though no value for y
is passed along to function test
, our isset
function works perfectly in this context, because y
is known in function test
as an undefined
value.
if (typeof console != "undefined") {
...
}
Or better
if ((typeof console == "object") && (typeof console.profile == "function")) {
console.profile(f.constructor);
}
Works in all browsers
window
.hasOwnProperty
("varname
")An alternative to the plethora of typeof
answers;
Global variables declared with a var varname = value;
statement in the global scope
can be accessed as properties of the window object.
As such, the hasOwnProperty()
method, which
returns a boolean indicating whether the object has the specified property as its own property (as opposed to inheriting it)
can be used to determine whether
a var
of "varname" has been declared globally i.e. is a property of the 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
] );
_x000D_
What's great about hasOwnProperty()
is that in calling it, we don't use a variable that might as yet be undeclared - which of course is half the problem in the first place.
Although not always the perfect or ideal solution, in certain circumstances, it's just the job!
The above is true when using var
to define a variable, as opposed to let
which:
declares a block scope local variable, optionally initializing it to a value.
is unlike the
var
keyword, which defines a variable globally, or locally to an entire function regardless of block scope.At the top level of programs and functions,
let
, unlikevar
, does not create a property on the global object.
For completeness: const
constants are, by definition, not actually variable (although their content can be); more relevantly:
Global constants do not become properties of the window object, unlike
var
variables. An initializer for a constant is required; that is, you must specify its value in the same statement in which it's declared.The value of a constant cannot change through reassignment, and it can't be redeclared.
The const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned.
Since let
variables or const
constants are never properties of any object which has inherited the hasOwnProperty()
method, it cannot be used to check for their existence.
Regarding the availability and use of hasOwnProperty()
:
Every object descended from Object inherits the
hasOwnProperty()
method. [...] unlike thein
operator, this method does not check down the object's prototype chain.
It is difficult to distinguish between undefined and null. Null is a value you can assign to a variable when you want to indicate that the variable has no particular value. Undefined is a special value which will be the default value of unassigned variables.
var _undefined;
var _null = null;
alert(_undefined);
alert(_null);
alert(_undefined == _null);
alert(_undefined === _null);
This was the best solution from me:
var $;
if($.css == undefined){console.log('JQ IS NOT PRESENT')}else{console.log('JQ VERSION ' + jQuery.fn.jquery + ' IS PRESENT')}
In the particular situation outlined in the question,
typeof window.console === "undefined"
is identical to
window.console === undefined
I prefer the latter since it's shorter.
Please note that we look up for console
only in global scope (which is a window
object in all browsers). In this particular situation it's desirable. We don't want console
defined elsewhere.
@BrianKelley in his great answer explains technical details. I've only added lacking conclusion and digested it into something easier to read.
It depends on the situation. If you're checking for something that may or may not have been defined globally outside your code (like jQuery perhaps) you want:
if (typeof(jQuery) != "undefined")
(No need for strict equality there, typeof always returns a string.) But if you have arguments to a function that may or may not have been passed, they'll always be defined, but null if omitted.
function sayHello(name) {
if (name) return "Hello, " + name;
else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"
I prefer this method for it's accuracy and succinctness:
var x
if (x === void 0) {
console.log(`x is undefined`)
} else {
console.log(`x is defined`)
}
_x000D_
As has been mentioned in other comments and answers, undefined
isn't guaranteed to be undefined. Because it's not a keyword, it can be redefined as a variable in scopes other than the global scope. Here's little example that demonstrates this nuance:
var undefined = 'bar'
console.log(`In the global scope: ${undefined}`)
function foo() {
var undefined = 'defined'
var x
if (x === undefined) {
console.log(`x === undefined`)
} else {
console.log(`x !== undefined`)
}
if (x === void 0) {
console.log(`x === void 0`)
} else {
console.log(`x !== void 0`)
}
}
foo()
_x000D_
See void for compatibility (supported in IE5!?!! Wow!).
You want the typeof
operator. Specifically:
if (typeof variable !== 'undefined') {
// the variable is defined
}
I'm surprised this wasn't mentioned yet...
here are a couple of additional variations using this['var_name']
the benefit of using this method that it can be used before a variable is defined.
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!
In many cases, using:
if (elem) { // or !elem
will do the job for you!... this will check these below cases:
undefined
''
So it will cover off kind of all cases, but there are always weird cases which we'd like to cover as well, for example, a string with spaces, like this ' '
one, this will be defined in javascript as it has spaces inside string... for example in this case you add one more check using trim(), like:
if(elem) {
if(typeof elem === 'string' && elem.trim()) {
///
Also, these checks are for values only, as objects and arrays work differently in Javascript, empty array []
and empty object {}
are always true.
I create the image below to show a quick brief of the answer:
There is another short hand way to check this, when you perform simple assignments and related checks. Simply use Conditional (Ternary) Operator.
var values = typeof variable !== 'undefined' ? variable : '';
Also this will be helpful, when you try to declare the Global variable with instance assignment of the reference variable.
If you wanted to check variable shouldn't be undefined
or null
. Then perform below check.
When the variable is declared, and if you want to check the value, this is even Simple: and it would perform undefined
and null
checks together.
var values = variable ? variable : '';
Attention :: people who don't understand the difference between a proposition let
, a constant const
and a variable var
should refrain themselves from commenting.
These answers (aside from the Fred Gandt solution ) are all either incorrect or incomplete.
Suppose I need my variableName;
to carry an undefined
value, and therefore it has been declared in a manner such as var variableName;
which means it's already initialized; - How do I check if it's already declared?
Or even better - how do I immediately check if "Book1.chapter22.paragraph37" exists with a single call, but not rise a reference error?
We do it by using the most powerful JasvaScript operator, the in operator.:
"[variable||property]" in [context||root]
>> true||false
In times of AJAX peaking popularity I've written a method (later named) isNS() which is capable of determining if the namespace exists including deep tests for property names such as "Book1.chapter22.paragraph37" and a lot more.
But since it has been previously published and because of its great importance it deserves to be published in a separate thread I will not post it here but will provide keywords (javascript + isNS ) which will help you locate the source code, backed with all the necessary explanations.
I use two different ways depending on the object.
if( !variable ){
// variable is either
// 1. '';
// 2. 0;
// 3. undefined;
// 4. null;
// 5. false;
}
Sometimes I do not want to evaluate an empty string as falsey, so then I use this case
function invalid( item ){
return (item === undefined || item === null);
}
if( invalid( variable )){
// only here if null or undefined;
}
If you need the opposite, then in the first instance !variable becomes !!variable, and in the invalid function === become != and the function names changes to notInvalid.
To check if a variable has been declared/set I did this dirty trick.
I haven't found a way to extract the code to a function, even with 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");
}
Null is a value in JavaScript and typeof null
returns "object"
Therefore, accepted answer will not work if you pass null values. If you pass null values, you need to add an extra check for null values:
if ((typeof variable !== "undefined") && (variable !== null))
{
// the variable is defined and not null
}
My preference is typeof(elem) != 'undefined' && elem != null
.
However you choose, consider putting the check in a function like so
function existy (x) {
return typeof (x) != 'undefined' && x != null;
}
If you don't know the variable is declared then continue with typeof (x) != 'undefined' && x != null;
Where you know the variable is declared but may not be existy, you could use
existy(elem) && doSomething(elem);
The variable you are checking may be a nested property sometimes. You can use prop || {} to go down the line checking existance to the property in question:
var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;
After each property use (...' || {}').nextProp so that a missing property won't throw an error.
Or you could use existy like existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)
Source: Stackoverflow.com