Parameters and arguments in PHP - Deep Dive

Overview - Parameters and arguments

What is it?

Parameters and arguments are the way we send information to functions in PHP. Parameters are the names listed in a function's definition, like placeholders. Arguments are the actual values you give to the function when you call it. This lets functions work with different data each time you use them.

Why it matters

Without parameters and arguments, functions would only do one fixed thing, making code repetitive and boring. They let us write flexible, reusable code that can handle many situations. This saves time and reduces mistakes, making programs easier to build and maintain.

Where it fits

Before learning parameters and arguments, you should know what functions are and how to define and call them. After this, you can learn about default parameters, type declarations, and passing by reference to write more powerful functions.

Mental Model

Core Idea

Parameters are named placeholders in a function, and arguments are the real values you plug in when calling that function.

Think of it like...

Think of a function like a cookie cutter (the function definition) with empty shapes (parameters). Arguments are the dough you press into the cutter to make cookies. Different doughs (arguments) make different cookies, but the cutter shape stays the same.

Function definition: function example(param1, param2) {
  // code using param1 and param2
}

Function call: example(arg1, arg2);

┌───────────────┐       ┌───────────────┐
│ Function      │       │ Function call │
│ definition    │       │ with args     │
│ param1, param2│◄──────│ arg1, arg2    │
└───────────────┘       └───────────────┘

Build-Up - 7 Steps

1

Foundation

What are function parameters

Concept: Parameters are the names used inside a function to represent the data it will receive.

In PHP, when you define a function, you list parameters inside parentheses after the function name. These parameters act like empty boxes waiting for values. Example: function greet($name) { echo "Hello, $name!"; } Here, $name is a parameter.

Result

The function greet expects one piece of information called $name to work with.

Understanding parameters as placeholders helps you see how functions can be flexible and work with different inputs.

2

Foundation

What are function arguments

Concept: Arguments are the actual values you give to a function when you call it.

When you use a function, you provide arguments that fill the parameters. Example: greet('Alice'); Here, 'Alice' is the argument passed to the $name parameter.

Result

The function prints: Hello, Alice!

Knowing that arguments are the real data sent to functions shows how functions can behave differently each time.

3

Intermediate

Multiple parameters and arguments

🤔Before reading on: Do you think the number of arguments must always match the number of parameters? Commit to your answer.

Concept: Functions can have many parameters, and you must provide matching arguments in the same order.

Example: function add($a, $b) { return $a + $b; } Calling: $result = add(5, 3); echo $result; This sends 5 to $a and 3 to $b.

Result

The output is 8.

Matching arguments to parameters by position is key to making functions work correctly.

4

Intermediate

Default parameter values

🤔Before reading on: If a function has a parameter with a default value, do you think you must always provide an argument for it? Commit to your answer.

Concept: Parameters can have default values, so if you don't provide an argument, the default is used.

Example: function greet($name = 'Guest') { echo "Hello, $name!"; } greet(); // Uses default 'Guest' greet('Bob'); // Uses 'Bob'

Result

Outputs: Hello, Guest! Hello, Bob!

Default values make functions easier to use by providing fallback data when arguments are missing.

5

Intermediate

Passing arguments by value vs reference

🤔Before reading on: Do you think changing a parameter inside a function changes the original argument variable outside? Commit to your answer.

Concept: By default, PHP passes arguments by value, meaning the function gets a copy. Passing by reference lets the function change the original variable.

By value example: function double($num) { $num = $num * 2; } $a = 5; double($a); echo $a; // still 5 By reference example: function doubleRef(&$num) { $num = $num * 2; } $b = 5; doubleRef($b); echo $b; // now 10

Result

Output: 5 10

Knowing how arguments are passed helps avoid bugs and lets you control if functions can change your data.

6

Advanced

Type declarations for parameters

🤔Before reading on: Do you think PHP forces the type of arguments passed to parameters by default? Commit to your answer.

Concept: PHP lets you specify the expected type of parameters to catch errors early and make code clearer.

Example: function multiply(int $a, int $b): int { return $a * $b; } Calling: multiply(3, 4); // works // multiply('3', '4'); // causes error in strict mode

Result

Output is 12 when called with integers.

Type declarations improve code safety and readability by ensuring functions get the right kind of data.

7

Expert

Variadic parameters and argument unpacking

🤔Before reading on: Can a function accept any number of arguments without listing them all as parameters? Commit to your answer.

Concept: Variadic parameters let functions accept many arguments as an array, and argument unpacking lets you pass arrays as separate arguments.

Variadic example: function sum(...$numbers) { return array_sum($numbers); } Calling: sum(1, 2, 3, 4); // 10 Argument unpacking example: $nums = [1, 2, 3]; sum(...$nums); // 6

Result

Outputs 10 and 6 respectively.

Variadic parameters and unpacking add powerful flexibility for functions handling unknown numbers of inputs.

Under the Hood

When a function is called, PHP creates a new space in memory for that call. It assigns the arguments you pass to the parameters defined in the function. If passed by value, PHP copies the argument's value; if by reference, it links the parameter to the original variable. Default values are used if no argument is given. Type declarations are checked at runtime to ensure the argument matches the expected type. Variadic parameters collect extra arguments into an array automatically.

Why designed this way?

PHP's parameter and argument system was designed to balance flexibility and safety. Early PHP allowed loosely typed parameters for ease of use, but as applications grew complex, type declarations were added to catch errors early. Passing by value prevents accidental changes to data, while passing by reference allows intentional modifications. Variadic parameters were introduced to handle functions needing flexible argument counts without complex array handling.

Function call flow:

Caller code
   │
   ▼
┌─────────────────────┐
│ Function call stack  │
│ - Allocate memory    │
│ - Assign arguments   │
│   to parameters     │
│ - Check types       │
│ - Use defaults if   │
│   needed            │
└─────────────────────┘
   │
   ▼
Function body executes
   │
   ▼
Return value back to caller

Myth Busters - 4 Common Misconceptions

Quick: Does changing a parameter inside a function always change the original variable passed as argument? Commit to yes or no.

Common Belief: Changing a parameter inside a function will always change the original variable passed in.

Reality: By default, PHP passes arguments by value, so changing a parameter inside a function does NOT affect the original variable unless passed by reference.

Why it matters: Assuming parameters always change original variables can cause bugs where data unexpectedly stays the same or changes unintentionally.

Quick: If a function has default parameter values, do you have to provide arguments for those parameters every time? Commit to yes or no.

Common Belief: You must always provide arguments for all parameters, even if they have default values.

Reality: Parameters with default values can be skipped when calling the function; the default is used automatically.

Why it matters: Not knowing this leads to unnecessarily long function calls and missed opportunities for simpler code.

Quick: Does PHP automatically convert argument types to match parameter types in all cases? Commit to yes or no.

Common Belief: PHP always converts argument types to match parameter types, so you don't need to worry about types.

Reality: PHP only converts types in weak typing mode; with strict typing enabled, type mismatches cause errors.

Why it matters: Ignoring type rules can cause runtime errors or unexpected behavior, especially in strict mode.

Quick: Can a function accept any number of arguments without special syntax? Commit to yes or no.

Common Belief: Functions can accept any number of arguments without declaring variadic parameters.

Reality: Without variadic parameters, PHP functions expect the exact number of arguments as parameters; extra arguments cause errors.

Why it matters: Assuming functions accept any number of arguments can cause bugs and crashes when unexpected arguments are passed.

Expert Zone

1

Parameters with default values must come after parameters without defaults; otherwise, PHP throws a syntax error.

2

Passing objects as arguments behaves like passing by reference because objects are handled via references internally, unlike scalar types.

3

Variadic parameters must be the last in the parameter list and can be combined with type declarations for strict control.

When NOT to use

Avoid passing large data structures by value to prevent performance issues; instead, pass by reference or use objects. For very dynamic argument lists, consider using variadic parameters or arrays instead of fixed parameters. When strict type safety is critical, enable strict typing and use type declarations; otherwise, loose typing may cause subtle bugs.

Production Patterns

In real-world PHP applications, parameters and arguments are used with type declarations and default values to create clear APIs. Passing by reference is used sparingly for performance or when functions must modify inputs. Variadic parameters simplify functions like logging or formatting that accept many inputs. Strict typing is increasingly common in modern PHP codebases for reliability.

Connections

Function overloading (other languages)

Parameters and arguments relate as the foundation for function overloading, where functions have multiple versions with different parameter lists.

Understanding parameters and arguments helps grasp how languages decide which function version to call based on argument types and counts.

Command-line arguments

Both involve passing data to a program or function to control behavior.

Knowing how parameters and arguments work in functions helps understand how command-line tools receive and use input arguments.

Mathematical functions

Parameters in programming functions correspond to variables in math functions, and arguments correspond to input values.

Seeing this connection clarifies that programming functions model mathematical functions by taking inputs and producing outputs.

Common Pitfalls

#1 Forgetting to match the number of arguments to parameters

Wrong approach:

function add($a, $b) {
return $a + $b;
}

add(5); // Missing second argument

Correct approach:

add(5, 3);

Root cause:

Not understanding that functions expect the exact number of arguments unless defaults or variadic parameters are used.

#2 Changing a parameter expecting to modify original variable but passing by value

Wrong approach:

function increment($num) {
$num++;
}
$a = 10;
increment($a);
echo $a; // Still 10

Correct approach:

function increment(&$num) {
$num++;
}
$a = 10;
increment($a);
echo $a; // Now 11

Root cause:

Misunderstanding how passing by value vs reference works in PHP.

#3 Placing parameters with default values before those without

Wrong approach:

function example($x = 5, $y) {
return $x + $y;
}

Correct approach:

function example($y, $x = 5) {
return $x + $y;
}

Root cause:

Not knowing PHP requires parameters with defaults to be last in the list.

Key Takeaways

Parameters are named placeholders in function definitions; arguments are the actual values passed when calling functions.

The order and number of arguments must match the parameters unless defaults or variadic parameters are used.

Passing arguments by value means functions get copies; passing by reference lets functions modify original variables.

Type declarations improve code safety by enforcing expected argument types at runtime.

Variadic parameters allow functions to accept any number of arguments, increasing flexibility.