JavaScript Undefined

undefined is a primitive data type in JavaScript representing the default state of a variable that has been declared but not yet initialized with a value. It is both a type and a singular, immutable value within the JavaScript engine.

Technical Characteristics

Type and Undeclared Safety: The typeof operator applied to an uninitialized variable or the undefined value itself returns the string "undefined". Crucially, typeof is one of the few operators (alongside the delete operator in non-strict mode) that can be applied to a completely undeclared variable without throwing a ReferenceError; it safely evaluates to "undefined".
Global Property: In the global scope, undefined is a non-configurable, non-writable property of the global object (globalThis.undefined).
Boolean Coercion: undefined is a falsy value. In a boolean context, it evaluates to false.
Numeric Coercion: When subjected to mathematical operations or coerced to a number, undefined evaluates to NaN (Not-a-Number).

Evaluation and Assignment Mechanics

The JavaScript engine yields undefined through implicit assignment during specific execution context phases, or by evaluating expressions at runtime in the following scenarios:

// 1. Uninitialized 'var' Declarations 
// The engine assigns undefined during the memory allocation (creation) phase.
console.log(hoistedVar); // undefined
var hoistedVar;

// 2. Uninitialized 'let' Declarations
// These remain uninitialized in the Temporal Dead Zone (TDZ) during creation. 
// The engine assigns undefined during the execution phase when the lexical binding is evaluated.
// Note: 'const' declarations cannot be uninitialized; doing so throws a SyntaxError.
let uninitializedVar;
console.log(uninitializedVar); // undefined

// 3. Missing Function Arguments 
// The engine assigns undefined to the missing parameter at runtime.
function evaluate(param) {
    console.log(param);
}
evaluate(); // undefined

// 4. Non-existent Object Properties 
// The internal [[Get]] operation evaluates to undefined.
const user = { id: 1 };
console.log(user.name); // undefined

// 5. Implicit Function Returns 
// Functions return undefined by default if no explicit return is provided.
function executeTask() {
    const x = 1 + 1;
}
console.log(executeTask()); // undefined

// 6. Out-of-bounds Array Indices 
// The internal [[Get]] operation evaluates to undefined.
const list = [10, 20];
console.log(list[5]); // undefined

Equality and Comparison

When evaluating undefined in comparison operations, JavaScript distinguishes between strict and loose equality, particularly in relation to null. While undefined represents an uninitialized state, null represents an intentional absence of an object value.

// Strict equality (===) checks both type and value.
// undefined and null are different types.
console.log(undefined === null); // false
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object"

// Loose equality (==) performs type coercion.
// The ECMAScript specification defines them as loosely equal.
console.log(undefined == null);  // true

The `void` Operator

The void operator evaluates a given expression and explicitly returns the primitive undefined value. Historically, this was used to guarantee a pure undefined value in older environments (pre-ECMAScript 5) where the global undefined property was writable and could be maliciously or accidentally overwritten (e.g., window.undefined = "hacked"). Furthermore, because undefined is an identifier and not a reserved word, it can still be shadowed by local variable declarations in modern JavaScript. The void operator remains a reliable method to retrieve the true primitive value regardless of scope manipulation.

// Safely retrieving the undefined primitive
console.log(void 0); // undefined

// Shadowing undefined in a local scope
function shadowTest() {
    let undefined = true; 
    console.log(undefined); // true
    console.log(void 0);    // undefined (bypasses the shadowed variable)
}

// Evaluating an expression while returning undefined
let x = 5;
console.log(void (x = 10)); // undefined
console.log(x); // 10 (expression was evaluated)

Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More

Functions

Methods

Constructors

Classes

Destructuring

Decorators

Modules

Accessors

Variables

Fields

Parameters

Error Handling

Control Flow

Statement Forms

Loops

Primitive Types

Comments

Access Operators

Spread Operators

Call Operators

Conditional Operators

Logical Operators

Equality Operators

Relational Operators

Arithmetic Operators

Assignment Operators

Update Operators

Unary Operators

Yield Operators

Bitwise Operators

Shift Operators

JavaScript Undefined

Technical Characteristics

Evaluation and Assignment Mechanics

Equality and Comparison

The `void` Operator

​Technical Characteristics

​Evaluation and Assignment Mechanics

​Equality and Comparison

​The void Operator

Technical Characteristics

Evaluation and Assignment Mechanics

Equality and Comparison

The `void` Operator