Default Parameters

Default Parameters

What it is

Default parameters allow function parameters to have default values when no argument is provided or undefined is passed. Introduced in ES6 (2015).

Before this feature

Had to manually check for undefined values:

function greet(name, greeting) {
  name = name || "Guest";
  greeting = greeting || "Hello";
  return greeting + ", " + name + "!";
}

// Problem: falsy values trigger default
function setValue(value, active) {
  active = active || true; // Bad! false becomes true
  return { value, active };
}
setValue(10, false); // { value: 10, active: true } - wrong!

After this feature

Clean, declarative default values:

function greet(name = "Guest", greeting = "Hello") {
  return `${greeting}, ${name}!`;
}

greet();                    // "Hello, Guest!"
greet("Alice");             // "Hello, Alice!"
greet("Bob", "Hi");         // "Hi, Bob!"
greet(undefined, "Hey");    // "Hey, Guest!"

// Default can be any expression
function createId(prefix = "ID", timestamp = Date.now()) {
  return `${prefix}-${timestamp}`;
}

// Defaults can reference earlier parameters
function calculateArea(width, height = width) {
  return width * height;
}
calculateArea(5);    // 25 (square)
calculateArea(5, 3); // 15 (rectangle)

// Default with destructuring
function createUser({
  name = "Guest",
  age = 0,
  premium = false
} = {}) {
  return { name, age, premium };
}

createUser();                           // { name: "Guest", age: 0, premium: false }
createUser({ name: "Alice", age: 25 }); // { name: "Alice", age: 25, premium: false }

Why this is better

• Declarative: Intent is clear from signature
• Safe: Proper handling of falsy values
• Flexible: Defaults can be expressions or reference other parameters
• Readable: No manual undefined checks
• DRY: Avoid repetitive validation code

Key notes / edge cases

• Only undefined triggers default (not null)
• Defaults evaluated at call time, not definition time
• Can reference earlier parameters but not later ones
• Works with destructuring in parameters
• Rest parameters can’t have defaults

// null doesn't trigger default
function test(x = 5) {
  return x;
}
test(undefined); // 5
test(null);      // null (not 5!)

// Evaluated at call time
let counter = 0;
function increment(value = counter++) {
  return value;
}
increment(); // 0
increment(); // 1
increment(); // 2

// Can't reference later parameters
function bad(a = b, b = 1) {  // ReferenceError
  return a + b;
}

// Rest parameters can't have defaults
function invalid(...args = []) {} // SyntaxError

Quick practice

1. Create a function multiply with default multiplier of 2

   Answer

   function multiply(x, multiplier = 2) {
     return x * multiplier;
   }

2. What does f(x = 10, y = x * 2) do?

   Answer

   Sets `x` default to 10, and `y` default to `x * 2`. If called as `f()`, returns `x=10, y=20`.

3. Does null trigger default parameters?

   Answer

   No. Only `undefined` (or omitted argument) triggers defaults. `null` is passed as-is.