JavaScript isset() equivalent

In PHP you can do if(isset($array['foo'])) { ... }. In JavaScript you often use if( { ... } to do the same, but this is not exactly the same statement. The condition will also evaluate to false if does exists but is false or 0 (and probably other values as well).

What is the perfect equivalent of PHP's isset in JavaScript?

In a broader sense, a general, complete guide on JavaScript's handling of variables that don't exist, variables without a value, etc. would be convenient.



I generally use the typeof operator:

if (typeof !== 'undefined') {
  // your code here

It will return "undefined" either if the property doesn't exist or its value is undefined.

(See also: Difference between undefined and not being defined.)

There are other ways to figure out if a property exists on an object, like the hasOwnProperty method:

if (obj.hasOwnProperty('foo')) {
  // your code here

And the in operator:

if ('foo' in obj) {
  // your code here

The difference between the last two is that the hasOwnProperty method will check if the property exist physically on the object (the property is not inherited).

The in operator will check on all the properties reachable up in the prototype chain, e.g.:

var obj = { foo: 'bar'};

obj.hasOwnProperty('foo'); // true
obj.hasOwnProperty('toString'); // false
'toString' in obj; // true

As you can see, hasOwnProperty returns false and the in operator returns true when checking the toString method, this method is defined up in the prototype chain, because obj inherits form Object.prototype.


Age old thread, but here's a new way to run an equivalent isset().


See below for explanation. Note I use StandardJS syntax

Example Usage

// IMPORTANT pass a function to our isset() that returns the value we're
// trying to test(ES6 arrow function)
isset(() => some) // false

// Defining objects
let some = { nested: { value: 'hello' } }

// More tests that never throw an error
isset(() => some) // true
isset(() => some.nested) // true
isset(() => some.nested.value) // true
isset(() => some.nested.deeper.value) // false

// Less compact but still viable except when trying to use `this` context
isset(function () { return some.nested.deeper.value }) // false

Answer Function

 * Checks to see if a value is set.
 * @param {Function} accessor Function that returns our value
function isset (accessor) {
  try {
    // Note we're seeing if the returned value of our function is not
    // undefined
    return typeof accessor() !== 'undefined'
  } catch (e) {
    // And we're able to catch the Error it would normally throw for
    // referencing a property of undefined
    return false



Note that in PHP you can reference any variable at any depth - even trying to access a non-array as an array will return a simple true or false:

// Referencing an undeclared variable
isset($some); // false

$some = 'hello';

// Declared but has no depth(not an array)
isset($some); // true
isset($some['nested']); // false

$some = ['nested' => 'hello'];

// Declared as an array but not with the depth we're testing for
isset($some['nested']); // true
isset($some['nested']['deeper']); // false


In JavaScript, we don't have that freedom, we'll always get an error if we do the same because JS is immediately attempting to access the value of deeper before we can wrap it in our isset() function so...

// Common pitfall answer(ES6 arrow function)
const isset = (ref) => typeof ref !== 'undefined'

// Same as above
function isset (ref) { return typeof ref !== 'undefined' }

// Referencing an undeclared variable will throw an error, so no luck here
isset(some) // Error: some is not defined

// Defining a simple object with no properties - so we aren't defining
// the property `nested`
let some = {}

// Simple checking if we have a declared variable
isset(some) // true

// Now trying to see if we have a top level property, still valid
isset(some.nested) // false

// But here is where things fall apart: trying to access a deep property
// of a complex object; it will throw an error
isset(some.nested.deeper) // Error: Cannot read property 'deeper' of undefined
//         ^^^^^^ undefined

More failing alternatives:

// Any way we attempt to access the `deeper` property of `nested` will
// throw an error
some.nested.deeper.hasOwnProperty('value') // Error
//   ^^^^^^ undefined

Object.hasOwnProperty('value', some.nested.deeper) // Error
//                                  ^^^^^^ undefined

// Same goes for typeof
typeof some.nested.deeper !== 'undefined' // Error
//          ^^^^^^ undefined

And some working alternatives that can get redundant fast:

// Wrap everything in try...catch
try { isset(some.nested.deeper) } catch (e) {}
try { typeof some.nested.deeper !== 'undefined' } catch (e) {}

// Or by chaining all of the isset which can get long
isset(some) && isset(some.nested) && isset(some.nested.deeper) // false
//                        ^^^^^^ returns false so the next isset() is never run


All of the other answers - though most are viable...

  1. Assume you're only checking to see if the variable is not undefined which is fine for some use cases but can still throw an Error
  2. Assume you're only trying to access a top level property, which again is fine for some use cases
  3. Force you to use a less than ideal approach relative to PHP's isset()
    e.g. isset(some, 'nested.deeper.value')
  4. Use eval() which works but I personally avoid

I think I covered a lot of it. There are some points I make in my answer that I don't touch upon because they - although relevant - are not part of the question. If need be, though, I can update my answer with links to some of the more technical aspects based on demand.

I spent waaay to much time on this so hopefully it helps people out.

Thank-you for reading!

if (!('foo' in obj)) {
  // not set.
//  tring to reference non-existing variable throws ReferenceError 
//  before test function is even executed
//  example, if you do:
//     if ( isset( someVar ) ) 
//        doStuff( someVar );
//  you get a ReferenceError ( if there is no someVar... ) 
//  and isset fn doesn't get executed.
//  if you pass variable name as string, ex. isset( 'novar' );, 
//  this might work:
function isset ( strVariableName ) { 

    try { 
        eval( strVariableName );
    } catch( err ) { 
        if ( err instanceof ReferenceError ) 
           return false;

    return true;


I always use this generic function to prevent errrors on primitive variables as well as arrays and objects.

isset = function(obj) {
  var i, max_i;
  if(obj === undefined) return false;
  for (i = 1, max_i = arguments.length; i < max_i; i++) {
    if (obj[arguments[i]] === undefined) {
        return false;
    obj = obj[arguments[i]];
  return true;

console.log(isset(obj));                   // returns false
var obj = 'huhu';
console.log(isset(obj));                   // returns true
obj = {hallo:{hoi:'hoi'}};
console.log(isset(obj, 'niet'));           // returns false
console.log(isset(obj, 'hallo'));          // returns true
console.log(isset(obj, 'hallo', 'hallo')); // returns false
console.log(isset(obj, 'hallo', 'hoi'));   // returns true

This is a pretty bulletproof solution for testing if a variable exists :

var setOrNot = typeof variable !== typeof undefined ? true : false;

Unfortunately, you cannot simply encapsulate it in a function.

You might think of doing something like this :

function isset(variable) {
    return typeof variable !== typeof undefined ? true : false;

However, this will produce a reference error if variable variable has not been defined, because you cannot pass along a non-existing variable to a function :

Uncaught ReferenceError: foo is not defined

On the other hand, it does allow you to test whether function parameters are undefined :

var a = '5';

var test = function(x, y) {


// ------------

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.

(typeof SOMETHING) !== 'undefined'

It's too long to write when used. But we can't package the typeof keyword into a function, because an error will thrown before the function is called, like this:

function isdef($var) {
    return (typeof $var) !== 'undefined';

isdef(SOMETHING); ///// thrown error: SOMETHING is not defined

So I figured out a way:

function isdef($type) {
    return $type !== 'undefined';

isdef(typeof SOMETHING);

It can work both with individual variables (variables that does not exist at all), or object properties (non-existent properties). And only 7 more characters than PHP isset.

window.isset = function(v_var) {
    if(typeof(v_var) == 'number'){ if(isNaN(v_var)){ return false; }}
    if(typeof(v_var) == 'undefined' || v_var === null){ return false;   } else { return true; }

plus Tests:


To check wether html block is existing or not, I'm using this code:

if (typeof($('selector').html()) != 'undefined') {
    // $('selector') is existing
    // your code here

Provide the object path as a string, then you can break this string into a path and resolve hasOwnProperty at each step while overwriting the object itself with each iteration.

If you are coding in ES6 environment, take a look at this stackoverflow Ques.

var a;

a = {
    b: {
        c: 'e'

function isset (obj, path) {
    var stone;

    path = path || '';

    if (path.indexOf('[') !== -1) {
        throw new Error('Unsupported object path notation.');

    path = path.split('.');
    do {
        if (obj === undefined) {
            return false;

        stone = path.shift();
        if (!obj.hasOwnProperty(stone)) {
            return false;
        obj = obj[stone];
    } while (path.length);

    return true;

    isset(a, 'b') == true,
    isset(a, 'b.c') == true,
    isset(a, 'b.c.d') == false,
    isset(a, 'b.c.d.e') == false,
    isset(a, 'b.c.d.e.f') == false


I use a function that can check variables and objects. very convenient to work with jQuery

    function _isset (variable) {
        if(typeof(variable) == "undefined" || variable == null)
            return false;
            if(typeof(variable) == "object" && !variable.length) 
                return false;
                return true;

It was really a problem for me when I was accessing a deeper property of an object so I made a function which will return the property value if exist otherwise it will return false. You may use it to save your time,

//Object on which we want to test
var foo = {
    bar: {
        bik: {
            baz: 'Hello world'

USE: To get value from the object using it properties supplied (Deeper),
    if found it will return the property value if not found then will return false

You can use this function in two ways
WAY - 1:
Passing an object as parameter 1 and array of the properties as parameter 2
EG: getValueFromObject(foo, ['bar', 'bik', 'baz']);
WAY - 2: (This will work only if, your object available in window object)
Passing an STRING as parameter 1(Just similarly how we retrieve value form object using it's properties - difference is only the quote)
EG: getValueFromObject('');
function getValueFromObject(object, properties) {
    if(typeof(object) == 'string') {            //Here we extract our object and it's properties from the string
        properties = object.split('.');
        object = window[properties[0]];
        if(typeof(object) == 'undefined') {
            return false;
    var property = properties[0];
    if(object != null && typeof(object[property]) != 'undefined') {
        if(typeof(object[property]) == 'object') {
            if(properties.length != 0) {
                return getValueFromObject(object[property], properties);    //Recursive call to the function
            } else {
                return object[property];
        } else {
            return object[property];
    } else {
        return false;
console.log(getValueFromObject(''));        //false
console.log(getValueFromObject(''));         //Hello world
console.log(getValueFromObject('foo'));                     //false
console.log(getValueFromObject(''));             //returns an object { baz: 'Hello World' }
console.log(getValueFromObject(foo, ['bar', 'bik']));       //returns an object { baz: 'Hello World' }
console.log(getValueFromObject(foo, ['bar', 'bik', 'baz']));//Hello world
if (var) {
  // This is the most concise equivalent of Php's isset().

PHP Manual say:

isset — Determine if a variable is set and is not NULL

And interface something like this:

bool isset ( mixed $var [, mixed $... ] )

The parameter $var is the variable to be checked. it can have any number of parameter though.

isset() returns TRUE if var exists and has value other than NULL. FALSE otherwise.

Some example:

$foo = 'bar';
var_dump(isset($foo));        -> true

$baz = null;
var_dump(isset($baz));        -> false

var_dump(isset($undefined));  -> false

As this in mind, Apparently, It's not possible to write exact equivalent of php isset() function. For example when we call like this:

if (isset(some_var)) {


function issset() {
    // function definition

Javascript trigger Uncaught ReferenceError: some_var is not defined at (file_name):line_number. The important and remarkable thing about this behavior is that when trying to pass non-existent variables to normal functions, an error is triggered.

But in PHP isset() are not actually regular functions but language constructs. That means they're part of the PHP language itself, do not play by the normal rules of functions and can hence get away with not triggering an error for non-existent variables. This is important when trying to figure out whether a variable exists or not. But in javscript, it triggers an error in the first place say function call with non-existent variables.

My point is that we can't write it as equivlent javscript function but we can do something like this

if (typeof some_var !== 'undefined') {
   // your code here

If you want exact same effect PHP also check varable is not NULL

For example

$baz = null;
var_dump(isset($baz));        -> false

So, we can incorporate this into javascript then it look like this:

if (typeof some_var !== 'undefined' && some_var !== null) {
   // your code here

Reference to SOURCE

    module.exports = function isset () {
  //  discuss at:
  // original by: Kevin van Zonneveld (
  // improved by: FremyCompany
  // improved by: Onno Marsman (
  // improved by: Rafa? Kukawski (
  //   example 1: isset( undefined, true)
  //   returns 1: false
  //   example 2: isset( 'Kevin van Zonneveld' )
  //   returns 2: true

  var a = arguments
  var l = a.length
  var i = 0
  var undef

  if (l === 0) {
    throw new Error('Empty isset')

  while (i !== l) {
    if (a[i] === undef || a[i] === null) {
      return false

  return true
} is mostly retired in favor of locutus Here is the new link


This simple solution works, but not for deep object check.

function isset(str) {
    return window[str] !== undefined;

If you are using underscorejs I always use

if (!_.isUndefined(data) && !_.isNull(data)) {
     //your stuff

This solution worked for me.

function isset(object){
    return (typeof object !=='undefined');
function isset(variable) {
    try {
        return typeof eval(variable) !== 'undefined';
    } catch (err) {
        return false;

If you want to check if an element exists, just use the following code:

if (object) {
  //if isset, return true
} else {
  //else return false

This is sample:

function switchDiv() {
    if (document.querySelector("#divId")) {
    } else {
        var newDiv = document.createElement("div"); = "divId";

document.querySelector("#btn").addEventListener("click", switchDiv);
#divId {
    background: red;
    height: 100px;
    width: 100px;
    position: relative;
  <button id="btn">Let's Diiiv!</button>


javascript isset

let test = {
  a: {
    b: [0, 1]

console.log(test.isset('a.b'))   // true
console.log(test.isset('a.b.1')) // true
console.log(test.isset('a.b.5')) // false
console.log(test.isset('a.c'))   // false
console.log('abv'.isset('0'))    // true
    isset('user.permissions.saveProject', args);

    function isset(string, context) {
        try {
            var arr = string.split('.');
            var checkObj = context || window;

            for (var i in arr) {
                if (checkObj[arr[i]] === undefined) return false;
                checkObj = checkObj[arr[i]];

            return true;
        } catch (e) {
            return false;

Be careful in ES6, all the previous solutions doesn't work if you want to check a declaration of a let variable and declare it, if it isn't


let myTest = 'text';

if(typeof myTest === "undefined") {
    var myTest = 'new text'; // can't be a let because let declare in a scope

you will see a error

Uncaught SyntaxError: Identifier 'myTest' has already been declared

The solution was to change it by a var

var myTest = 'text'; // I replace let by a var

if(typeof myTest === "undefined") {
    var myTest = 'new text';

another solution if you can change a let by a var, you need to remove your var

let myTest = 'text';

if(typeof myTest === "undefined") {
    myTest = 'new text'; // I remove the var declaration

Try to create function like empty function of PHP in Javascript. May this helps.

function empty(str){
    if(typeof str==="string"){
    return !(str !== undefined && str !== "undefined" && str !== null && str!=="" && str!==0 && str!==false);
    return true;

console.log(empty(" "))//true

var tmp=1;

var tmp="Test";

var tmp=" Test ";

var tmp={a:1,b:false,c:0};


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.