How to check variable exists or not in JavaScript ? 
 

       Check if the type of the variable is equal to undefined it means that variable does not exist so we need to create variable. The typeof operator doesn't throw an error so we can use it before variable declaration.
 

if (typeof someVar === 'undefined')) {
  var someVar = 5;
}

console.log(someVar); // ?️ 5;

How check if variable is array in JavaScript ?

Array.isArray(someVar) returns  true if variable is array so using this method you can check weather variable exists or not using typeof  keyword to avoid getting an error.

if (!Array.isArray(someVar)) {
  someVar = [1,2,3];
}

console.log(someVar);

When working with JavaScript, it's crucial to ensure that your code is robust and can handle different scenarios gracefully. One common task is checking whether a variable exists before attempting to use or manipulate it. This guide will walk you through various methods to determine the existence of a variable in JavaScript, helping you write more resilient and error-free code.

1. Using the typeof Operator

The typeof operator in JavaScript allows you to determine the type of a variable. By checking if the result is not equal to "undefined," you can verify whether a variable exists. Here's an example:

if (typeof yourVariable !== 'undefined') {
    // Your variable exists, proceed with your code
} else {
    // Handle the case where the variable is undefined
}

2. Leveraging Truthy and Falsy Values

JavaScript has the concept of truthy and falsy values. Utilizing this, you can check if a variable is truthy, indicating its existence:

if (yourVariable) {
    // Your variable is truthy, meaning it exists
} else {
    // Handle the case where the variable is falsy or undefined
}

Keep in mind that this method might not be suitable if your variable can legitimately hold falsy values like 0, false, null, NaN, or an empty string.

3. Using the in Operator

The in operator in JavaScript checks if a property exists in an object. While it is generally used for object properties, it can also be applied to check if a variable exists in the global scope:

if ('yourVariable' in window) {
    // Your variable exists in the global scope
} else {
    // Handle the case where the variable is not found
}

4. Employing Null Coalescing Operator (??)

Introduced in ECMAScript 2020, the nullish coalescing operator (??) provides a concise way to check if a variable is not null or undefined:
 

const result = yourVariable ?? 'default';
// If yourVariable is not null or undefined, result will be yourVariable; otherwise, it will be 'default'

This method is particularly useful when you want to assign a default value when the variable is not present.

5. Using a Try-Catch Block

If you anticipate that a variable might not exist due to asynchronous operations or dynamic code, you can use a try-catch block:

try {
    // Attempt to use the variable
    const value = yourVariable;
    // Your variable exists, proceed with your code
} catch (error) {
    // Handle the case where the variable is not defined
}

This method is effective for scenarios where you want to catch runtime errors related to variable existence.

Conclusion

Ensuring the existence of variables is a fundamental aspect of writing robust JavaScript code. By understanding and applying these techniques, you can enhance the reliability and maintainability of your scripts. Choose the method that best fits your use case, keeping in mind the context and specific requirements of your project. Writing code that gracefully handles variable existence contributes to a more seamless and error-resistant application.