How to do a "soft" if condition check in Javascript

Question

Like you would do in php:

if (@$some_var_exists)
    // do stuff

How would you do something like this in Javascript without getting an error?

Thanks

EDIT: Thanks for the answers. However, the problem I'm trying to solve is how to check if a variable exists when it's deep in a object, for example:

if (someObj.something.foo.bar)
  // This gives an error in the browser if "someObj.something.foo" is not defined.

Answer 1

To check if a variable is defined, you could do:

if(self.somevar) {
    ...
}

As pointed out by Mister in the comments, the self part is important here.

Or, if you wish to be more explicit, you could do:

if(typeof somevar != "undefined") {
    ...
}

The way you are checking the PHP var is also not very neat or really the best practice as the @ error suppressor is expensive and not necessary in this case. You could use isset like this:

if(isset($some_var_here)) {
    ...
}

EDIT:
For your more specific problem, I think @Ryan Watkins answer is the way to do it, although I'd have to wonder why you put yourself in such a position anyways. :)

Answer 2

Simpler than that..

if(varname){ ... }

This applies to variables, not objects.

Answer 3

Javascript will return false in an if statement if the object doesn't exist

var myObj = {};
if (myObj.someUnknown)
{
  // will not get here if someUnknown doesn't exist.
}

Answer 4

Check each part of the chain:

if (someObj && someObj.something && someObj.something.foo && someObj.something.foo.bar) {
   // stuff
}

Because the expression is evaluated from left to right, and returns as soon as it finds false, it will not cause an error. So if "someObj" exists, but "sometObj.something" does not, it will return false and never execute the test for someObj.something.foo that would throw an error.

Answer 5

When testing for the existence of a variable you should never blindly test with that variables name. The same rings true when finding properties and methods of deeply nested objects.

With that in mind:

// error will occur if someObj has not ever been defined in your code.
if (someObj) {
  // someObj has been defined
}

You can workaround that and use minimal code by testing against the global scope, which in browsers it is the window level.

// safe way to test for global variable.
if (window.someObj) {
  // someObj has been defined
}

Another fine test for global variable would be using the builtin typeof method, however it gets a bit tedious to type out if you have to do it often enough.

// another safe method for testing a global variable
if (typeof someObj != "undefined") {
  // someObj has been defined
}

Now for the testing of deep nested objects (often used as pseudo-namespaces in JS).

// testing deep nested object
if (self.someObj && 
    someObj.something && 
    someObj.something.foo && 
    someObj.something.foo.bar) {
  // do something ...
}

Just two final quick notes for advanced coders:

Sometimes in IE I've noticed that doing that type of lookup / existence test has actually called the method if I was testing for it. eg:

// this is an example, I can't recall which actual methods did this off-hand
if (document.execCommand) {
  // resultant value of execCommand method gets used to pass/fail the conditional
}

And, finally a very mild side-effect of these type of existence lookups is that when you have a getter applied to that property, it will actually run the getter during the conditional testing.

// this code only runs in Firefox 2+
// and is provided for instructional purposes only
var foo = {
  get bar() { alert("bar getter was executed") }
};
if (foo.bar) {
  // a foo.bar property is defined
}

Answer 6

function isVarDefined(str) {
    try { 
        return (typeof eval(str) !== 'undefined');
    }
    catch(e) {
        return false;
    }
}

Pass the variable name as string. For example:

isVarDefined('someObj.something.foo.bar')

PS: Eval is evil. You should sanitize the value of str to contain only a variable name rather than some arbitrary executable code. Left as an exercise to you!

Answer 7

if (typeof somevar === "undefined") {
    // then the variable doesnt' exist

Answer 8

The following should be pretty much bullet-proof, but is a hassle and only works if you know the whole chain in advance:

if ('undefined' !== typeof someObj &&
    'undefined' !== typeof someObj.something &&
    'undefined' !== typeof someObj.something.foo &&
    'undefined' !== typeof someObj.something.foo.bar) {
    // do some stuff
}

You might be better off to do as Chetan suggests and use a try/catch block instead:

try {
    if ('undefined' !== typeof someObj.something.foo.bar) {
        // do some stuff
    }
}
catch (e) {}

Answer 9

@Scott Evernden and @Andrew Hedges have the only completely correct answers so far. Just doing something like

if (variable)

or

if (someObj && someObj.something && ... && someObj.something.foo.bar)

is not correct in general, because if someObj.something.foo.bar exists, but is zero or false, the condition will be false. It will only work if all of the properties are objects (not numbers, booleans, or even strings) and someObj exists.

The only correct ways to check for existence in general, are typeof variable !== "undefined", variable !== undefined (if you know it's been declared), "property" in variable, or, depending on what you mean by "exists", object !== null. try/catch could also work, but that seems messy.

When you have a long chain, it's not necessary to check every step for the correct type/null/undefined/etc.; as long as every intermediate value is an object (not a number, string, or boolean that happens to have extra properties), they will evaluate to true.

if (typeof someObj !== "undefined" && someObj &&
    someObj.something &&
    someObj.something.foo &&
    typeof someObj.something.foo.bar !== "undefined") {
    // someObj.something.foo.bar exists, but you may need to check for null
}

Answer 10

If you need to do it a lot, a function version to get the property if it exists and return undefined otherwise is:

function propertyChain(root, chain) {
    var properties = chain.split(".");
    var obj = root;
    while (properties.length) {
        if (typeof obj === "undefined" || obj === null)
            return undefined;
        obj = obj[properties.shift()];
    }
    return obj;
}

so that:

if (propertyChain(someObj, 'something.foo.bar'))

is essentially a non-throwing version (assuming you've declared someObj) of:

if (someObj.something.foo.bar)