Default parameter values in PHP - Deep Dive

Overview - Default parameter values

What is it?

Default parameter values allow a function to have preset values for some of its inputs. When calling the function, if you don't provide a value for those inputs, the default is used automatically. This makes functions easier to use and more flexible. It helps avoid errors from missing arguments.

Why it matters

Without default parameter values, every time you call a function, you must provide all arguments, even if many calls use the same values repeatedly. This leads to repetitive code and more chances for mistakes. Default values save time, reduce errors, and make code cleaner and easier to read.

Where it fits

Before learning default parameter values, you should understand how to define and call functions in PHP. After mastering defaults, you can explore advanced function features like variable-length argument lists and type declarations.

Mental Model

Core Idea

Default parameter values are like preset options that a function uses when you don’t specify your own.

Think of it like...

Imagine ordering coffee at a cafe where the barista automatically adds sugar unless you say otherwise. The sugar is the default, but you can choose to skip it.

Function call with defaults:

  function example($a, $b = 5) {
    return $a + $b;
  }

Call 1: example(3)  → uses default 5 for $b → result 8
Call 2: example(3, 7) → uses 7 for $b → result 10

Build-Up - 7 Steps

1

Foundation

Understanding function parameters

Concept: Functions can take inputs called parameters to work with different data.

In PHP, you define a function with parameters inside parentheses. For example: function greet($name) { echo "Hello, $name!"; } You call it by passing a value: greet('Alice'); outputs Hello, Alice!

Result

The function prints a greeting using the input name.

Knowing how parameters work is essential before adding default values, because defaults only apply to parameters.

2

Foundation

Calling functions with arguments

Concept: When you use a function, you provide arguments that match its parameters.

If a function expects two parameters, you must give two arguments: function add($x, $y) { return $x + $y; } add(2, 3); // returns 5 If you forget an argument, PHP gives an error.

Result

Calling add(2, 3) returns 5; calling add(2) causes an error.

Understanding argument matching helps see why default values prevent errors when arguments are missing.

3

Intermediate

Setting default parameter values

🤔Before reading on: do you think default values can be set for any parameter position? Commit to your answer.

Concept: You can assign a default value to a parameter by using = after its name in the function definition.

Example: function multiply($a, $b = 2) { return $a * $b; } Calling multiply(5) returns 10 because $b defaults to 2. Calling multiply(5, 3) returns 15 because $b is given as 3.

Result

Functions work with or without the second argument, using the default when missing.

Knowing how to set defaults lets you write flexible functions that handle common cases automatically.

4

Intermediate

Order of parameters with defaults

🤔Before reading on: can a parameter without a default come after one with a default? Commit to yes or no.

Concept: In PHP, parameters with default values must come after parameters without defaults.

This is because PHP assigns arguments in order. For example, this works: function example($a, $b = 10) {} But this causes an error: function example($a = 10, $b) {} Because PHP cannot guess which argument matches which parameter.

Result

Correct order avoids errors and confusion when calling functions.

Understanding parameter order prevents syntax errors and helps design clear function interfaces.

5

Intermediate

Using default values with different types

🤔Before reading on: do you think default values can be any type, like strings, numbers, or arrays? Commit to your answer.

Concept: Default parameter values can be any valid PHP value: numbers, strings, arrays, or even null.

Examples: function greet($name = 'Guest') { echo "Hello, $name!"; } greet(); // Hello, Guest! function addNumbers($a, $b = null) { if ($b === null) return $a; return $a + $b; } addNumbers(5); // 5 addNumbers(5, 3); // 8

Result

Functions behave differently depending on whether arguments are given or defaults are used.

Knowing defaults can be any type expands how you design flexible functions.

6

Advanced

Default values evaluated once at definition

🤔Before reading on: do you think default values are recalculated each time the function runs? Commit to yes or no.

Concept: Default values are evaluated once when the function is defined, not each time it is called.

For example, using a function call or expression as a default is not allowed: function foo($x = time()) {} // causes error Instead, defaults must be constants or simple values. This means defaults cannot depend on changing data at runtime.

Result

Default values remain fixed and cannot be dynamic expressions.

Understanding this prevents bugs and clarifies why some defaults are invalid.

7

Expert

Interaction with type declarations and nullables

🤔Before reading on: can default values violate type declarations? Commit to yes or no.

Concept: When using type declarations, default values must match the declared type or be null if nullable.

Example: function greet(string $name = 'Guest') {} function setAge(?int $age = null) {} If you try: function greet(string $name = null) {} // error unless ?string This enforces type safety while allowing defaults.

Result

Type declarations and defaults work together to make functions safer and clearer.

Knowing this helps avoid subtle bugs and write robust, modern PHP code.

Under the Hood

When PHP loads a function with default parameters, it stores the default values in the function's metadata. At each call, PHP checks how many arguments were passed. For missing arguments, PHP inserts the stored default values before running the function body. This happens at runtime but the defaults themselves are fixed at compile time.

Why designed this way?

This design keeps function calls fast and predictable. Evaluating defaults once avoids overhead and side effects on each call. It also simplifies the parser and runtime, ensuring consistent behavior. Alternatives like dynamic defaults would complicate the language and slow execution.

Function definition
┌─────────────────────────────┐
│ function foo($a, $b = 5)    │
│ Default values stored here ─┼─> $b = 5
└─────────────────────────────┘

Function call
┌─────────────────────────────┐
│ foo(3)                      │
│ Arguments passed: $a=3      │
│ Missing $b → use default 5  │
└─────────────────────────────┘

Execution
┌─────────────────────────────┐
│ Run function body with $a=3 │
│ and $b=5                    │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can you put a parameter without a default after one with a default? Commit to yes or no.

Common Belief: You can put parameters with defaults anywhere in the list.

Reality: Parameters with defaults must come after all parameters without defaults in PHP.

Why it matters: Placing them incorrectly causes syntax errors and stops your code from running.

Quick: Are default values recalculated each time the function runs? Commit to yes or no.

Common Belief: Default values are recalculated every time the function is called.

Reality: Default values are evaluated once when the function is defined, not on each call.

Why it matters: Expecting dynamic behavior from defaults leads to bugs and confusion.

Quick: Can default values be any expression, like function calls? Commit to yes or no.

Common Belief: You can use any expression, including function calls, as default values.

Reality: Default values must be constant expressions; function calls are not allowed.

Why it matters: Trying to use dynamic expressions causes syntax errors and blocks code execution.

Quick: Can default values violate type declarations? Commit to yes or no.

Common Belief: Default values can be any type regardless of declared parameter types.

Reality: Default values must match the declared type or be null if the type is nullable.

Why it matters: Violating type rules causes type errors and breaks code safety.

Expert Zone

1

Default values are stored in the function's opcode array, making them immutable during runtime, which means you cannot change defaults dynamically after definition.

2

When using references as default values, PHP does not allow it because references require actual variables, not constants.

3

In PHP 8.0+, union types combined with default values require careful matching to avoid type errors, especially with nullables.

When NOT to use

Avoid default parameters when the default value depends on runtime data or external state. Instead, use function overloading patterns or check for missing arguments inside the function body. Also, avoid defaults if parameter order would become confusing; consider named arguments instead.

Production Patterns

In real-world PHP applications, default parameters are used to simplify APIs, provide backward compatibility, and reduce boilerplate. For example, optional configuration arrays often have defaults to allow flexible function calls. Combined with type declarations and named arguments (PHP 8+), they create clear and robust interfaces.

Connections

Named arguments

Builds-on

Named arguments let you skip parameters without defaults by naming them explicitly, complementing default values for clearer function calls.

Function overloading (in other languages)

Alternative approach

Languages without default parameters often use function overloading to achieve similar flexibility, showing different ways to handle optional inputs.

Human decision making

Similar pattern

Just like people have default habits but can choose differently when needed, functions use default values unless overridden by explicit input.

Common Pitfalls

#1 Placing a parameter without a default after one with a default.

Wrong approach:

function example($a = 5, $b) {
return $a + $b;
}

Correct approach:

function example($a, $b = 5) {
return $a + $b;
}

Root cause:

Misunderstanding PHP's rule that parameters with defaults must come last.

#2 Using a function call as a default value.

Wrong approach:

function foo($time = time()) {
return $time;
}

Correct approach:

function foo($time = null) {
if ($time === null) {
$time = time();
}
return $time;
}

Root cause:

Not knowing that default values must be constant expressions.

#3 Default value type does not match declared parameter type.

Wrong approach:

function greet(string $name = null) {
echo $name;
}

Correct approach:

function greet(?string $name = null) {
echo $name;
}

Root cause:

Ignoring type declaration rules for default values.

Key Takeaways

Default parameter values let functions have optional inputs with preset values, making calls simpler and safer.

Parameters with defaults must be placed after all required parameters to avoid syntax errors.

Default values are fixed when the function is defined and cannot be dynamic expressions like function calls.

When using type declarations, default values must respect the declared types or be null if allowed.

Understanding these rules helps write flexible, clear, and bug-free PHP functions.