Skip to main content

How to Check if a Parameter was Provided to a Function in JavaScript

When you define a function in JavaScript, you can specify parameters that you expect it to receive. However, JavaScript does not enforce that a value must be passed for every parameter. If a function is called without an argument for a specific parameter, that parameter's value inside the function will be undefined.

This guide will explain this core concept and teach you the modern and classic methods for handling missing arguments. You will learn to use default parameters (the recommended best practice) and how to perform manual checks for undefined when more complex logic is required.

The Core Concept: Missing Arguments are undefined​

If you define a function with a parameter and then call that function without passing an argument for it, the parameter's value will be undefined inside the function's scope.

function greet(name) {
  // `name` is undefined, so this will fail or produce strange output.
  console.log(`Hello, ${name.toUpperCase()}!`);
}

// We call the function without an argument.
greet();
// ⛔️ Uncaught TypeError: Cannot read properties of undefined (reading 'toUpperCase')
note

To prevent this error, you must handle the case where name might be undefined.

Modern JavaScript (ES6 and newer) provides a clean and direct syntax to solve this problem: default parameters. This allows you to assign a default value to a parameter directly in the function's definition. This default value is used only if an argument is not provided for that parameter, or if the argument is explicitly undefined.

// We assign a default value of "Guest" to the `name` parameter.
function greet(name = 'Guest') {
  console.log(`Hello, ${name}!`);
}

// ✅ Call with an argument
greet('Alice');   // Output: Hello, Alice!

// ✅ Call without an argument
greet();          // Output: Hello, Guest!

// ✅ Call with `undefined`
greet(undefined); // Output: Hello, Guest!

Output:

Hello, Alice!
Hello, Guest!
Hello, Guest!
note

This is the best practice for handling optional parameters. It is concise, readable, and clearly states the function's expected behavior.

The Classic Solution: Checking for undefined​

Before default parameters were introduced, the standard way to handle this was to manually check if the parameter's value is undefined inside the function.

The logic:

  • Use an if statement to compare the parameter to undefined.

Solution:

function greet(name) {
  // Check if the `name` parameter is undefined
  if (name === undefined) {
    name = 'Guest'; // Assign a default value
  }
  
  console.log(`Hello, ${name}!`);
}

greet('Bob'); // Output: Hello, Bob!
greet();      // Output: Hello, Guest!
note

You can also use the typeof operator for this check, which is equally reliable: if (typeof name === 'undefined') { ... }

How the Methods Work​

  • Default Parameters (name = 'Guest'): This is syntactic sugar built directly into the JavaScript language. The engine itself checks if the incoming argument is undefined and, if so, applies your default value before the code inside your function even begins to execute.
  • Manual Check (name === undefined): This is a standard strict equality check. It compares the value of the name parameter to the primitive undefined type. It's a fundamental part of the language and is completely reliable.

Common Pitfalls and How to Solve Them​

A common mistake is to use a "truthiness" check to see if an argument was provided.

Example of code with problems:

function processValue(value) {
  // ⛔️ This is a BAD check for a missing argument
  if (!value) {
    console.log('No value was provided.');
    return;
  }
  console.log(`Processing value: ${value}`);
}

This is a problem because it will incorrectly reject "falsy" values that are otherwise valid arguments, such as 0, false, or an empty string ("").

processValue(5);      // Output: Processing value: 5
processValue(0);      // Output: No value was provided. (Wrong!)
processValue(false);  // Output: No value was provided. (Wrong!)
processValue("");     // Output: No value was provided. (Wrong!)

Solution:

  • Do not use a truthiness check (if (param)) to check for a missing argument.
  • Always use a direct comparison to undefined (if (param === undefined)) or, preferably, use default parameters.

Conclusion​

Handling missing function parameters is a crucial part of writing robust and predictable JavaScript.

The key takeaways are:

  1. If an argument is not passed to a function, its corresponding parameter will be undefined.
  2. The best practice for handling optional parameters is to use default parameter syntax (e.g., function myFunc(param = 'default')). It is the most concise and readable solution.
  3. If you need to manually check for a missing argument, use a strict comparison to undefined (param === undefined or typeof param === 'undefined'). Avoid simple truthiness checks.

Table of Contents