How to check if variable exists (is defined/initialized) in JavaScript?

To check if a variable exists (is defined/initialized) in JavaScript, use the typeof operator or error handling. Here’s how to do it safely and effectively:

1. Check if a Variable Exists (Basic Method)

Use typeof to avoid ReferenceError for undeclared variables:

if (typeof variable !== 'undefined') {
  // Variable exists (declared and possibly initialized)
} else {
  // Variable is undeclared or explicitly set to undefined
}

2. Check if a Variable is Declared and Initialized

To ensure the variable is declared and has a non-undefined value:

if (typeof variable !== 'undefined' && variable !== undefined) {
  // Variable exists and has a defined value
}

3. Check for Global Variables (e.g., in Browser/Node.js)

For variables explicitly attached to the global scope (e.g., window in browsers, global in Node.js):

// Browser
if ('myVar' in window) {
  // Global variable exists (works for `var` declarations)
}

// Node.js
if ('myVar' in global) {
  // Global variable exists
}

Note: let and const variables in the global scope do not become properties of window/global, so this method is unreliable for them.

4. Check Local Variables with try/catch

For cases where you need to check existence without assuming scope:

try {
  // Reference the variable
  if (variable !== undefined) {
    // Variable exists and is not `undefined`
  }
} catch (e) {
  // Variable is undeclared
}

Examples

Example 1: Basic Check

let name = "Alice";

if (typeof name !== 'undefined') {
  console.log(name); // Output: "Alice"
}

Example 2: Undeclared Variable

if (typeof nonExistentVar === 'undefined') {
  console.log("Variable does not exist"); // Triggers
}

Example 3: Global Variable Check (Browser)

var globalVar = 42;
console.log('globalVar' in window); // true

let scopedVar = 100;
console.log('scopedVar' in window); // false (doesn’t work for `let`/`const`)

Key Notes

• typeof Safety: typeof is safe for undeclared variables (no ReferenceError).
• Scope Awareness: let/const variables in block/global scope are not attached to window/global.
• Initialization: A variable declared with let/var but not initialized returns undefined.

Common Pitfalls

• Assuming undefined means undeclared:
  A variable declared with let x; (no value) is undefined, but it still exists.
• Using if (variable):
  Fails for falsy values (0, "", null, false).
• Global Checks: Avoid relying on window/global for modern let/const variables.

Summary

• General Use: typeof variable !== 'undefined' (safe for all cases).
• Global Variables: 'variable' in window (only for var or explicit globals).
• Initialized Values: Combine typeof with a direct check (e.g., variable !== undefined).
• Edge Cases: Use try/catch sparingly (not recommended for most scenarios).

This ensures you handle both declared and undeclared variables without runtime errors.