JavaScript check if variable exists is defined initialized

Question

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

User · Answer

Try-catch

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)

_x000D_

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)

if( a == b )

if( a === b )

User · Answer

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    amp  amp   variable     null             the variable is defined and not null

User · Answer

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

User · Answer

if  typeof console     undefined                    Or better  if   typeof console     object    amp  amp   typeof console profile     function             console profile f constructor           Works in all browsers

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

The typeof operator will check if the variable is really undefined   if  typeof variable      undefined            variable is undefined     The typeof operator  unlike the other operators  doesn t throw a ReferenceError exception when used with an undeclared variable   However  do note that typeof null will return  object   We have to be careful to avoid the mistake of initializing a variable to null  To be safe  this is what we could use instead   if  typeof variable      undefined     variable     null           variable is undefined or null       For more info on using strict comparison     instead of simple equality     see Which equals operator     vs      should be used in JavaScript comparisons

User · Answer

You could use a try   catch block like the following   x000D   x000D  var status    Variable exists   try     myVar   catch  ReferenceError      status    Variable does not exist     console log status  x000D   x000D   x000D   A disadvantage is you cannot put it in a function as it would throw a ReferenceError  x000D   x000D  function variableExists x      var status   true   try       x     catch  ReferenceError        status   false          return status    console log variableExists x   x000D   x000D   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   x000D   x000D  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   x000D   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   x000D   x000D  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   x000D   x000D

User · Answer

How to check if a variable exists 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    quot black quot     Problems with encapsulation 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   Testing whether function parameters are undefined 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

User · Answer

You can also use    before a variable to check if it s defined  E g  let dog    quot woof quot   let chineseCat     Undefined  console log  quot 1  quot    console log   dog  amp  amp    chineseCat    quot Both are defined quot     quot Both are NOT defined quot     chineseCat   quot mao quot      dog and chineseCat are now defined  console log  quot 2  quot    console log   dog  amp  amp    chineseCat    quot Both are defined quot     quot Both are NOT defined quot     Output  1  Both are NOT defined 2   Both are defined

User · Answer

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    This is the only check that won t throw an error if 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

User · Answer

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

User · Answer

if  variable     undefined      works just fine  and only checks for undefined

User · Answer

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  quot Book1 chapter22 paragraph37 quot  exists with a single call  but not rise a reference error  We do it by using the most powerful JasvaScript operator  the in operator    quot  variable  property  quot  in  context  root    gt  gt  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  quot Book1 chapter22 paragraph37 quot  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

User · Answer

In ReactJS  things are a bit more complicated   This is because it is a compiled environment  which follows ESLint s no-undef rule since react-scripts 2 0 3  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  quot uninitialized quot   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      quot undefined quot            For instance     x000D   x000D  if eval  false        console log  NO       if eval  true        console log  YEAH       x000D   x000D   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

User · Answer

Check if window hasOwnProperty  quot varname quot   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  quot varname quot  has been declared globally i e  is a property of the window   x000D   x000D     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   x000D   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  Notes 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  unlike var  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 the in operator  this method does not check down the object s prototype chain

User · Answer

In many cases  using   if  elem       or  elem   will do the job for you     this will check these below cases    undefined  if the value is not defined and it s undefined null  if it s null  for example  if a DOM element not exists    empty string      0  number zero NaN  not a number false   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   amp  amp  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

User · Answer

My preference is typeof elem      undefined   amp  amp  elem    null    However you choose  consider putting the check in a function like so  function existy  x        return typeof  x      undefined   amp  amp  x    null      If you don t know the variable is declared then continue with typeof  x      undefined   amp  amp  x    null   Where you know the variable is declared but may not be existy  you could use   existy elem   amp  amp  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   amp  amp  existy o p   amp  amp  existy o p q   amp  amp  doSomething o p q

User · Answer

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

User · Answer

I prefer this method for it s accuracy and succinctness   x000D   x000D  var x if  x     void 0      console log  x is undefined     else     console log  x is defined     x000D   x000D   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   x000D   x000D  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   x000D   x000D   See void for compatibility  supported in IE5     Wow

User · Answer

You want the typeof operator  Specifically   if  typeof variable      undefined            the variable is defined

User · Answer

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

User · Answer

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

User · 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

User · Answer

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

User · Answer

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         gt   Hello unknown person

User · Answer

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  amp  amp  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      lt -- no var here   BAD

User · Answer

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    x000D   x000D  if  typeof data      undefined   amp  amp  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   x000D   x000D      could be reduced to    x000D   x000D  if  data  amp  amp   data url    x000D    var message   data error    data message     Error receiving response   x000D    alert message  x000D     x000D   x000D   x000D

User · Answer

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

User · Answer

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

[javascript] JavaScript check if variable exists (is defined/initialized)

Try-catch

if( a == b )

if( a === b )

Examples related to javascript

Examples related to variables

Examples related to initialization

Examples related to undefined