7 questions foundHow do you define and call a basic function in PHP, and what are function parameters and return values?
Beginner You define a function in PHP using the function keyword followed by a name, a list of parameters the function accepts inside parentheses, and a body of code enclosed in curly braces, optionally using the return keyword to send a value back to whatever code called the function, letting you package up a reusable piece of logic that can be called by name whenever it is needed throughout your code.
function greet($name) {
return "Hello, $name!";
}
echo greet('Ali');
Real-world example A pricing calculator defines a single reusable function that calculates tax on a given price, calling that same function consistently everywhere a tax calculation is needed rather than duplicating the calculation logic in multiple places.
Common follow-ups: What is the difference between a function that returns a value and one that does not?;Can a PHP function have multiple return statements?
Closures & Anonymous Functions;Type Declarations & Strict Types
What is variable scope in PHP, and why can't a function normally access a variable defined outside of it?
Beginner Variable scope determines where in your code a particular variable can be accessed, and in PHP, a variable defined inside a function is local to that function by default and cannot be accessed from outside it, while a variable defined outside any function exists in the global scope but is also not automatically accessible from within a function unless explicitly imported using the global keyword, a design intended to prevent functions from accidentally interfering with unrelated parts of a program.
$total = 100;
function showTotal() {
echo $total ?? 'not accessible here';
}
showTotal();
Real-world example A developer troubleshooting an undefined variable warning realizes their function was trying to directly use a variable defined outside of it, and fixes the issue by properly passing that value into the function as a parameter instead.
Common follow-ups: Why does PHP intentionally isolate function scope from the global scope by default?;What is the difference between using the global keyword and simply passing a variable as a parameter?
Basics & Types;Closures & Anonymous Functions
What are default parameter values and variadic functions in PHP, and how do they add flexibility to how a function can be called?
Intermediate A default parameter value lets you specify a fallback value that is used if the caller does not explicitly provide that argument, making certain parameters effectively optional, while a variadic function, defined using an ellipsis before the parameter name, lets a function accept any number of arguments, which are collected into a single array inside the function, giving your functions flexible, convenient calling patterns without requiring the caller to always supply every single possible argument.
function greet($name, $greeting = 'Hello') {
return "$greeting, $name!";
}
function sum(...$numbers) {
return array_sum($numbers);
}
echo sum(1, 2, 3, 4);
Real-world example A logging function accepts a variadic list of context values, letting calling code pass anywhere from zero to many additional pieces of context information without the function's signature needing to change to accommodate different call patterns.
Common follow-ups: What happens if you try to call a function without providing a required parameter that has no default value?;Can a function have both regular parameters and a variadic parameter together?
Basics & Types;Arrays in PHP
What are named arguments introduced in PHP 8, and how do they improve the readability of function calls with many parameters?
Intermediate Named arguments let you specify function arguments by explicitly stating the parameter name they correspond to, rather than relying purely on their position in the function's parameter list, which is especially useful for functions with many parameters or several optional parameters, since you can skip parameters you want to leave at their default value and clearly communicate exactly what each provided value represents directly at the call site.
function createUser($name, $email, $isAdmin = false, $isActive = true) {
}
createUser(name: 'Ali', email: 'ali@example.com', isAdmin: true);
Real-world example A developer calling a function with several boolean parameters uses named arguments to make the call site immediately clear about what each true or false value actually represents, rather than leaving future readers to count parameter positions and check the function definition.
Common follow-ups: Can you mix positional and named arguments in the same function call?;What happens if you use a named argument that does not match any parameter name in the function?
PHP 8 Features (Attributes Enums Match Nullsafe Operator);Basics & Types
How does the static keyword affect a variable declared inside a function, and how does this differ from a regular local variable?
Intermediate A regular local variable inside a function is reset to its initial value every single time the function is called, while a variable declared as static retains its value between separate calls to that same function, meaning the function remembers the variable's value from the previous call rather than starting fresh each time, which can be useful for scenarios like tracking how many times a specific function has been called.
function trackCalls() {
static $count = 0;
$count++;
return $count;
}
echo trackCalls();
echo trackCalls();
Real-world example A rate limiting function uses a static variable to keep track of how many times it has been called within the current script execution, without needing an external variable or class property to maintain that count between calls.
Common follow-ups: How does a static variable inside a function differ from a static property on a class?;Is a static variable's value shared across different requests in a typical web application?
OOP;Caching Strategies in PHP
How does recursion work in PHP functions, and what are the practical considerations, such as stack depth limits, when writing a recursive function?
Advanced A recursive function is a function that calls itself, typically to solve a problem that can naturally be broken down into smaller instances of the same problem, such as traversing a nested directory structure or calculating a factorial, and while recursion can produce elegant, readable solutions, PHP has a practical limit on how deeply functions can call themselves before running out of available memory for the call stack, meaning very deep recursion on large datasets should generally be converted to an iterative loop based approach instead.
function factorial($n) {
if ($n <= 1) return 1;
return $n * factorial($n - 1);
}
echo factorial(5);
Real-world example A file system scanning tool uses a recursive function to traverse deeply nested folder structures, but the team adds a maximum depth safeguard after discovering that an unusually deep folder structure could otherwise risk exhausting the available call stack.
Common follow-ups: What is a base case in a recursive function and why is it essential?;How do you convert a recursive function into an equivalent iterative version?
Arrays in PHP;File Handling & File System Functions
How do function type declarations and return type declarations improve code reliability, and how does PHP handle nullable and union types in function signatures?
Advanced Type declarations on function parameters and return values let PHP automatically validate that the correct types of data are being passed in and returned, catching many bugs early with a clear TypeError rather than allowing an unexpected type to silently cause problems later, and PHP supports nullable types by prefixing a type with a question mark to indicate a parameter can also accept null, along with union types that let a parameter or return value accept one of several specified types.
function findUser(int $id): ?User {
return $this->users[$id] ?? null;
}
function process(int|string $value): void {
}
Real-world example A user lookup function declares its return type as a nullable User object, clearly communicating to anyone calling the function that it might return null if no matching user is found, rather than that possibility only being discoverable by reading the function's internal implementation.
Common follow-ups: What is the difference between a nullable type and a union type that includes null explicitly?;How do type declarations interact with the strict_types directive discussed elsewhere?
Type Declarations & Strict Types;PHP 8 Features (Attributes Enums Match Nullsafe Operator)