If you want to determine if a variable has been defined, you can use the following code:

if(self.somevar) {
    ...
}

It's important to note, as Mister mentioned in the comments, that the self part is crucial in this check.

Alternatively, for a more explicit check, you could use the following code:

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

The method you are using to check the PHP variable is not the most elegant or best practice, as the @ error suppressor can be costly and unnecessary in this scenario. Instead, you could utilize isset like so:

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

UPDATE:
Regarding your specific issue, I believe @Ryan Watkins' solution is the way to go. However, I must question why you found yourself in such a predicament in the first place. :)

@Scott Evernden and @Andrew Hedges are currently the only ones with completely accurate responses. Merely using code snippets like

if (variable)

or

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

is not universally correct. This is because if someObj.something.foo.bar exists but is set to zero or false, the condition will be false. It will only be effective if all properties are objects (not numbers, booleans, or even strings) and if someObj is defined.

The only proper methods to check for existence in general are typeof variable !== "undefined", variable !== undefined (if it has been declared), "property" in variable, or, depending on your definition of "exists", object !== null. Using try/catch could also work, but it may appear messy.

When dealing with a long chain, it is not required to verify each 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 as 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
}

This solution is designed to be extremely reliable, but it can be cumbersome and only functions if you have the entire chain predetermined:

if ('undefined' !== typeof someObj &&
    'undefined' !== typeof someObj.something &&
    'undefined' !== typeof someObj.something.foo &&
    'undefined' !== typeof someObj.something.foo.bar) {
    // perform desired actions
}

Alternatively, you may want to consider Chetan's recommendation and utilize a try/catch block:

try {
    if ('undefined' !== typeof someObj.something.foo.bar) {
        // perform desired actions
    }
}
catch (e) {}

Easier than what's been mentioned so far..

if(variable){
      ...
}

This rule specifically pertains to variables, excluding objects.

It's important to be cautious when testing for the existence of a variable. Simply checking if the variable exists by its name can lead to errors, especially when dealing with deeply nested objects.

To avoid potential issues, consider the following approach:

// Check if someObj is defined to prevent errors
if (someObj) {
  // someObj is defined
}

Instead of directly checking against the variable, you can test against the global scope, which is often represented by the window object.

// Safe way to test for a global variable
if (window.someObj) {
  // someObj is defined
}

Another reliable method is to use the typeof operator to check if a variable is not undefined.

// Another safe method to test for a global variable
if (typeof someObj != "undefined") {
  // someObj is defined
}

When dealing with deeply nested objects, such as pseudo-namespaces in JavaScript, you can test their existence like this:

// Testing deeply nested objects
if (self.someObj && 
    someObj.something && 
    someObj.something.foo && 
    someObj.something.foo.bar) {
  // Do something...
}

For advanced coders, here are a couple of quick notes:

In some cases, performing existence tests in Internet Explorer may inadvertently trigger the method being tested.

// Example that may call the method in IE
if (document.execCommand) {
  // The result of execCommand method is used to evaluate the conditional
}

Additionally, be aware that using getter functions in conditional testing can actually trigger the getter to run.

// This code demonstrates the effect of getter in conditional testing
var foo = {
  get bar() { alert("bar getter was executed") }
};
if (foo.bar) {
  // A foo.bar property is defined
}

if (typeof anotherVar === "undefined") {
    // this means the variable is not defined

When using JavaScript, if an object does not exist, an if statement will return false.

let myObj = {};
if (myObj.someUnknown)
{
  // This block of code will not execute if 'someUnknown' property does not exist in myObj.
}

function checkIfVarExists(input) {
    try { 
        return (typeof eval(input) !== 'undefined');
    }
    catch(error) {
        return false;
    }
}

To use this function, pass the variable name as a string. For example:

checkIfVarExists('someObject.someProperty.anotherProperty')

Remember, using eval is not recommended due to security risks. Make sure to sanitize the input to only contain a variable name and not arbitrary code. This is an important step that you need to take care of!

If you find yourself needing to access nested properties frequently, you can use this function to safely retrieve a property without causing errors:

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

For example, you can use it like this:

if (getProperty(someObject, 'nested.property.value'))

which is a safer alternative to:

if (someObject.nested.property.value)