Javascript if undefined define

How to Check if a JavaScript Variable is Undefined

In JavaScript, checking if a variable is undefined can be a bit tricky since a null variable can pass a check for undefined if not written properly. As a result, this allows for undefined values to slip through and vice versa. Make sure you use strict equality === to check if a value is equal to undefined .

let x; const y = null; x == null && y == undefined; // true x === null || y === undefined; // false x == null && typeof x == 'object'; // false x === undefined && typeof x == 'undefined'; // true

Another alternative is checking if typeof x === ‘undefined’ . The biggest difference between these two approaches is that, if x has not been declared, x === undefined throws a ReferenceError , but typeof does not.

When using x === undefined , JavaScript checks if x is a declared variable that is strictly equal to undefined . If you want to check if x is strictly equal to undefined regardless of whether is has been declared or not, you should use typeof x === ‘undefined’ .

 x === undefined; // Throws a ReferenceError typeof x == 'undefined'; // true

However, typeof x may still throw an error if you later declare x using let or const :

typeof x; // Throws "ReferenceError: Cannot access 'x' before initialization" because of `let` let x = 42;

Checking Whether Object Properties are Undefined

Checking whether an object property is undefined is subtle, because if you access a property that doesn’t exist in the object, JavaScript will report the property’s value as undefined rather than throw a ReferenceError .

const obj = < answer: 42, question: undefined >; obj.answer; // 42 obj.question; // undefined obj.notInObject; // undefined

In JavaScript obj.propName === undefined is true if either obj has a property ‘propName’ and the property’s value is trictly equal undefined, or if obj does not have a property ‘propName’. If you want to check whether obj has a property and that property is strictly equal to undefined , you should use the in operator.

const obj = < answer: 42, question: undefined >; ('question' in obj && obj.question === undefined); // true ('notInObject' in obj && obj.notInObj === undefined); // false

More Fundamentals Tutorials

Источник

undefined

The undefined global property represents the primitive value undefined . It is one of JavaScript’s primitive types.

Try it

Value

Property attributes of undefined
Writable	no
Enumerable	no
Configurable	no

Description

undefined is a property of the global object. That is, it is a variable in global scope.

In all non-legacy browsers, undefined is a non-configurable, non-writable property. Even when this is not the case, avoid overriding it.

A variable that has not been assigned a value is of type undefined . A method or statement also returns undefined if the variable that is being evaluated does not have an assigned value. A function returns undefined if a value was not returned .

Note: While you can use undefined as an identifier (variable name) in any scope other than the global scope (because undefined is not a reserved word), doing so is a very bad idea that will make your code difficult to maintain and debug.

// DON'T DO THIS (() =>  const undefined = "foo"; console.log(undefined, typeof undefined); // foo string >)(); ((undefined) =>  console.log(undefined, typeof undefined); // foo string >)("foo"); 

Examples

Strict equality and undefined

You can use undefined and the strict equality and inequality operators to determine whether a variable has a value. In the following code, the variable x is not initialized, and the if statement evaluates to true.

let x; if (x === undefined)  // these statements execute > else  // these statements do not execute > 

Note: The strict equality operator (as opposed to the standard equality operator) must be used here, because x == undefined also checks whether x is null , while strict equality doesn’t. This is because null is not equivalent to undefined .

typeof operator and undefined

Alternatively, typeof can be used:

let x; if (typeof x === "undefined")  // these statements execute > 

One reason to use typeof is that it does not throw an error if the variable has not been declared.

// x has not been declared before // evaluates to true without errors if (typeof x === "undefined")  // these statements execute > // Throws a ReferenceError if (x === undefined)  > 

However, there is another alternative. JavaScript is a statically scoped language, so knowing if a variable is declared can be read by seeing whether it is declared in an enclosing context.

The global scope is bound to the global object, so checking the existence of a variable in the global context can be done by checking the existence of a property on the global object, using the in operator, for instance:

if ("x" in window)  // These statements execute only if x is defined globally > 

void operator and undefined

The void operator is a third alternative.

let x; if (x === void 0)  // these statements execute > // y has not been declared before if (y === void 0)  // throws Uncaught ReferenceError: y is not defined > 

Specifications

Browser compatibility

BCD tables only load in the browser

See also

Found a content problem with this page?

This page was last modified on Apr 28, 2023 by MDN contributors.

Your blueprint for a better internet.

MDN

Support

Our communities

Developers

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.

Источник

JavaScript Check if Undefined – How to Test for Undefined in JS

Joel Olawanle

An undefined variable or anything without a value will always return «undefined» in JavaScript. This is not the same as null, despite the fact that both imply an empty state.

You’ll typically assign a value to a variable after you declare it, but this is not always the case.

When a variable is declared or initialized but no value is assigned to it, JavaScript automatically displays «undefined». It looks like this:

let myStr; console.log(myStr); // undefined 

Also, when you try accessing values in, for example, an array or object that doesn’t exist, it will throw undefined .

let user = < name: "John Doe", age: 14 >; console.log(user.hobby); // undefined 

let myArr = [12, 33, 44]; console.log(myArr[7]); // undefined 

In this article, you will learn the various methods and approaches you can use to know if a variable is undefined in JavaScript. This is necessary if you want to avoid your code throwing errors when performing an operation with an undefined variable.

In case you are in a rush, here are the three standard methods that can help you check if a variable is undefined in JavaScript:

if(myStr === undefined)<> if(typeof myArr[7] === "undefined")<> if(user.hobby === void 0)<> 

Let’s now explain each of these methods in more detail.

How to Check if a Variable is Undefined in JavaScript with Direct Comparison

One of the first methods that comes to mind is direct comparison. This is where you compare the output to see if it returns undefined . You can easily do this in the following way:

let user = < name: "John Doe", age: 14 >; if (user.hobby === undefined)

This also works for arrays as you can see below:

let scores = [12, 34, 66, 78]; if (scores[10] === undefined)

And it definitely also works for other variables:

let name; if (name === undefined)

How to Check if a Variable is Undefined in JavaScript with typeof

We can also use the type of the variable to check if it’s undefined . Luckily for us undefined is a datatype for an undefined value as you can see below: ‌

let name; console.log(typeof name); // "undefined" 

With this we can now use the datatype to check undefined for all types of data as we saw above. Here is what the check will look like for all three scenarios we have considered:

if(typeof user.hobby === "undefined")<> if(typeof scores[10] === "undefined")<> if(typeof name === "undefined")<> 

How to Check if a Variable is Undefined in JavaScript with the Void Operator

The void operator is often used to obtain the undefined primitive value. You can do this using » void(0) » which is similar to » void 0 » as you can see below:

console.log(void 0); // undefined console.log(void(0)); // undefined 

In the actual sense, this works like direct comparison (which we saw before). But we would replace undefined with void(0) or void 0 as seen below:

if(typeof user.hobby === void 0)<> if(typeof scores[10] === void 0)<> if(typeof name === void 0)<> 

if(typeof user.hobby === void(0))<> if(typeof scores[10] === void(0))<> if(typeof name === void(0))<> 

Conclusion

In this article, we learned how to check if a variable is undefined and what causes a variable to be undefined.

We also learned three methods we can use to check if a variable is undefined. All methods work perfectly. Choosing your preferred method is totally up to you.

Источник