JavaScript is a dynamic language with unique ways of representing the absence of a value. Understanding the nuances between null, undefined, and empty strings ("") is essential for writing robust code. Let’s delve into these concepts and how they differ.

Difference between null, undefined and empty


null is a special keyword in JavaScript that represents the intentional absence of any object value. It is often used to explicitly indicate that a variable should have no value or no reference to any object. Although null is considered a primitive value, due to a historical bug in JavaScript, the typeof operator incorrectly returns "object" instead of "null".

Here’s an example of assigning null:

const myVariable = null;
console.log(myVariable); // Output: null


undefined occurs when a variable has been declared but has not yet been assigned a value. Unlike null, which is an assignment value, undefined arises naturally in the language without explicit assignment. A function without a return statement implicitly returns undefined if no other return value is provided.

const myVariable;
console.log(myVariable); // Output: undefined

Empty String ("")

An empty string is a string with zero characters. While it might seem similar to null or undefined, it is a valid value and can be explicitly assigned to a variable. It is considered truthy when evaluated in a boolean context.

Here’s an example of an empty string:

const myString = "";
console.log(myString); // Output: ""

Comparison and Arithmetic Operations

Interestingly, null and undefined are loosely equal (null == undefined), which means they are considered equal in comparisons using the loose equality operator (==). However, they are strictly unequal (null !== undefined), meaning they are not considered equal in comparisons using the strict equality operator (===). This is because null and undefined are different types—null is an object, and undefined is a primitive type.

Arithmetic operations behave differently with null and undefined. When null is involved in an arithmetic operation, it is coerced to 0, whereas undefined results in NaN (Not a Number)

console.log(null +  1); // Output:  1
console.log(undefined +  1); // Output: NaN


Understanding the subtle differences between null, undefined, and empty strings in JavaScript is crucial for avoiding bugs and writing clear, predictable code. Each serves a specific purpose in the language: null for intentional absence of an object value, undefined for uninitialized variables, and empty strings for cases where a string value is required but empty.