Default Parameters in JavaScript Functions

In JavaScript, functions are an essential building block of code. One of the powerful features of functions is the ability to define default parameters. These parameters provide a fallback value for function arguments when none are provided by the caller. Default parameters simplify the function's usage and improve code readability, as you don’t have to check for undefined or other values within the function body. This feature was introduced in ECMAScript 6 (ES6) and has since become a vital part of modern JavaScript programming.

In this section, we’ll cover the following topics:

What Are Default Parameters in JavaScript?

Default parameters in JavaScript allow you to specify default values for function parameters. When a function is called and an argument is not passed for a parameter that has a default value, the function uses the default instead. This can reduce errors and make code cleaner by eliminating the need to manually check if an argument was passed.

Here’s a simple example:

function greet(name = "Guest") {
  console.log(`Hello, ${name}!`);
}

greet(); // Output: Hello, Guest!
greet("Alice"); // Output: Hello, Alice!

In this example, the name parameter has a default value of 'Guest'. When no argument is passed, it uses this default value.

Why Do We Use Default Parameters?

Default parameters are helpful in many scenarios. First, they reduce the need for explicit checks within the function body to determine whether an argument was passed. This can make code more concise and readable. Second, they help in creating more flexible functions that can work with a variety of input types, without requiring the caller to always provide every argument.

For instance, consider a function that calculates the area of a rectangle:

function calculateArea(length, width = 5) {
  return length * width;
}

console.log(calculateArea(10)); // Output: 50
console.log(calculateArea(10, 3)); // Output: 30

In this case, the default value for width is 5. If the caller doesn’t provide a width, it defaults to 5.

Overriding Default Values with Arguments

While default parameters provide a fallback value, they can be overridden by passing an argument when calling the function. This flexibility allows the caller to specify values only when needed, while still providing reasonable defaults in other cases.

For example:

function createProfile(name = "Unknown", age = 25) {
  return { name, age };
}

console.log(createProfile()); // Output: { name: 'Unknown', age: 25 }
console.log(createProfile("John", 30)); // Output: { name: 'John', age: 30 }

In the second call, the arguments passed override the default values, providing a custom profile. This demonstrates how default parameters can be both useful and flexible when building JavaScript functions.

Default parameters in JavaScript offer a convenient way to handle optional function arguments, enhancing code readability and reducing the need for additional checks. By providing fallback values, they allow functions to behave predictably, even when certain arguments are not passed.

Reference links:
Default Parameters on MDN