Why You Should Never Assign undefined in JavaScript Code

You should never assign undefined manually in JavaScript, because undefined is the engine's own signal that a value was never assigned. When a variable is declared but not initialized, when a function argument is omitted, or when an object property does not exist, the engine returns undefined. It is a diagnostic signal.

When you manually assign undefined to a variable, you destroy that signal. You make it impossible to tell whether a value was never set or was intentionally cleared. This section explains why that causes real problems and what you should do instead.

The Problem with Assigning undefined

Consider a function that receives a configuration object with a name property. The developer set the name to undefined, intending to clear it. But the function cannot tell the difference between a missing property and one deliberately set to undefined:

javascript

function createUser(config) {
  let name = config.name || "Anonymous";
  console.log("Creating user:", name);
}
 
let settings = { name: undefined };
createUser(settings);

The output is "Creating user: Anonymous". But the developer who wrote settings clearly intended to provide a name. They just used the wrong empty value.

Because config.name is undefined, the function treats it the same as a missing property and falls back to the default. If they had used null instead, the intent would be unambiguous.

The same problem appears with default function parameters. JavaScript only uses the default when the argument is undefined, not when it is null:

javascript

function greet(name = "Guest") {
  console.log("Hello, " + name);
}
 
greet(undefined); // "Hello, Guest" (default used)
greet(null);      // "Hello, null"  (null is intentional)

When you pass undefined, JavaScript assumes you forgot to provide a value and uses the default. When you pass null, JavaScript respects your explicit choice to pass an empty value. This is by design: undefined means missing, null means intentionally empty.

What to Use Instead

For intentional emptiness, use null. It clearly signals that you deliberately set this value to nothing:

javascript

let currentUser = null;     // no user logged in yet
let errorMessage = null;    // no error to display
let fetchedData = null;     // API call has not completed

For object properties you want to remove, use the delete operator instead of setting them to undefined. Setting a property to undefined leaves the key in the object, which can cause subtle bugs in loops and when serializing to JSON:

javascript

let user = { name: "Alex", age: 30 };
user.age = undefined;
console.log(Object.keys(user)); // ["name", "age"]

The age key still exists. It was not removed, just emptied. This matters when you iterate over keys or send the object to an API.

Deleting the property removes the key entirely. After deletion, the property is gone as if it was never there:

javascript

delete user.age;
console.log(Object.keys(user)); // ["name"]

For function results that have no meaningful value, return null instead of undefined. A function that returns null clearly signals the caller to handle the empty case:

javascript

function findUser(id) {
  // User not found
  return null;
}

When Checking undefined Is Correct

Reading undefined and checking for its presence is perfectly fine. The problem is only with writing it. These patterns read the signal correctly:

javascript

if (typeof someVar === "undefined") {
  console.log("Variable does not exist");
}

This typeof check is safe even when someVar was never declared. Default parameters also read this signal correctly, since they only kick in when the argument is undefined:

javascript

function connect(host = "localhost") {
  // host defaults to "localhost" only when undefined
}

In each case, you are reading the undefined signal that JavaScript generated automatically. You are not creating it yourself. This is the correct use of undefined: as a condition to check, never as a value to assign.

A Simple Rule to Remember

Read undefined. Check for undefined. Never assign undefined.

When you need to empty a variable, use null. When you need to remove a property, use delete. When you need a default value, use the logical OR operator or the nullish coalescing operator with a meaningful fallback.

Let undefined remain the signal that JavaScript intended: no value was ever put here.

For more on the distinction between these two empty values, see the undefined vs null comparison. For best practices on variable declarations, read the let vs const guide.