PHP | Functions (original) (raw)
Last Updated : 28 Nov, 2025
A function in PHP is a self-contained block of code that performs a specific task. It can accept inputs (parameters), execute a set of statements, and optionally return a value.
- PHP functions allow code reusability by encapsulating a block of code to perform specific tasks.
- Functions can accept parameters and return values, enabling dynamic behavior based on inputs.
- PHP supports both built-in functions and user-defined functions, enhancing flexibility and modularity in code. PHP `
`
**Syntax
function functionName($param1, $param2) {
// Code to be executed
return $result; // optional
}
Calling a Function in PHP
Once a function is declared, it can be invoked (called) by simply using the function name followed by parentheses.
PHP `
a+a + a+b; } echo sum(5, 3); // Outputs: 8 ?>`
**In this example:
- The **function sum() is defined to take two parameters, aanda and aandb, and return their sum.
- The function is called with 5 and 3 as arguments, and it returns the result, which is 8.
Types of Functions in PHP
PHP has two types of functions:
1. User-Defined Functions
A user-defined function is created to perform a specific task as per the developer's need. These functions can accept parameters, perform computations, and return results.
PHP `
a+a + a+b; } echo addNumbers(5, 3); // Output: 8 ?>`
**In this example:
- The function addNumbers is defined by the user to take two parameters, aanda and aandb, and returns their sum ($a + $b).
- The function is called with 5 and 3 as arguments, so it adds these numbers together.
2. Built-in Functions
PHP comes with many built-in functions that can be directly used in your code. For example, strlen(), substr(), array_merge(), date() and etc are built-in PHP functions. These functions provide useful functionalities, such as string manipulation, date handling, and array operations, without the need to write complex logic from scratch.
PHP `
`
**In this example:
- A string variable $str is defined with the value "Hello, World!".
- The strlen() function is the built-in function in PHP that is used to calculate the length of the string $str.
PHP Function Parameters and Arguments
Functions can accept input values, known as parameters or arguments.
- Parameters are variables defined in the function declaration that accept values.
- Arguments are the actual values passed to the function when it is called.
These values can be passed to the function in two ways:
1. Passing by Value
When you pass a value by value, the function works with a copy of the argument, so the original value remains unchanged.
PHP `
x=x = x=x + $y; return $x; } echo add(2, 3); // Outputs: 5 ?>`
**In this example:
- The function add() is defined with parameters xandx and xandy.
- The function adds xandx and xandy and returns the sum.
- The function is called with values 2 and 3, and the result 5 is printed.
2. Passing by Reference
By passing an argument by reference, any changes made inside the function will affect the original variable outside the function.
PHP `
x=x = x=x + $y; } $a = 5; addByRef($a, 3); echo $a; // Outputs: 8 ?>`
**In this example:
- The function addByRef() is defined with $x passed by reference.
- The function modifies xdirectly,addingx directly, adding xdirectly,addingy to it.
- After calling the function with a=5and3,thevalueofa = 5 and 3, the value of a=5and3,thevalueofa becomes 8.
Returning Values in PHP Functions
Functions in PHP can return a value using the return statement. The return value can be any data type such as a string, integer, array, or object. If no return statement is provided, the function returns null by default.
PHP `
a∗a * a∗b; } result=multiply(4,5);//result = multiply(4, 5); // result=multiply(4,5);//result will be 20 echo $result; // Output: 20 ?>`
**In this example:
- The function multiply() is defined to return the product of aanda and aandb.
- The function is called with 4 and 5 as arguments.
- The result 20 is returned and printed using echo.
Anonymous Functions (Closures)
PHP supports anonymous functions, also known as closures. These functions do not have a name and are often used for passing functions as arguments to other functions.
PHP `
greet=function(greet = function(greet=function(name) { echo "Hello, " . $name . "!"; }; $greet("GFG"); ?>`
**In this example:
- An anonymous function is defined and assigned to the variable $greet.
- The function takes $name as a parameter and prints a greeting message.
- The function is called with the argument "GFG", and the greeting "Hello, GFG" is printed.
Recursion in PHP
Recursion is a process in which a function calls itself. It is often used in situations where a task can be broken down into smaller, similar tasks.
PHP `
n∗factorial(n * factorial(n∗factorial(n - 1); } } echo factorial(5); ?>`
**In this example:
- The function factorial() is defined to calculate the factorial of a number $n using recursion.
- If nis0,thefunctionreturns1(basecase);otherwise,itcallsitselfwithn is 0, the function returns 1 (base case); otherwise, it calls itself with nis0,thefunctionreturns1(basecase);otherwise,itcallsitselfwithn - 1.
- When factorial(5) is called, the function recursively multiplies 5 * 4 * 3 * 2 * 1, returning 120.
Common PHP Functions
Here are some common PHP functions you should know:
1. String Functions
- **strlen(): Returns the length of a string.
- **strtoupper(): Converts a string to uppercase.
- **strtolower(): Converts a string to lowercase.
- **substr(): Returns a part of a string.
To read about PHP String Functions refer this article - PHP String Functions
2. Array Functions
- **array_push(): Adds elements to the end of an array.
- **array_pop(): Removes the last element of an array.
- **array_merge(): Merges two or more arrays.
To read about PHP Array Functions refer this article - PHP Array Functions
3. Date and Time Functions
- **date(): Returns the current date or time.
- **strtotime(): Converts a string into a Unix timestamp.
- **time(): Returns the current Unix timestamp.
To read about PHP Date and Time Functions refer this article - PHP Date and Time Functions
Best Practices for Writing PHP Functions
- **Use Descriptive Names: Function names should be descriptive and indicate what the function does. This improves the readability of your code.
- **Limit the Number of Parameters: Try to keep the number of parameters to a minimum. If a function takes too many parameters, it may indicate that the function is doing too much.
- **Keep Functions Focused: A function should perform one specific task. If a function is too large, break it down into smaller helper functions.
- **Use Return Statements: Always use return statements when necessary, and avoid directly outputting values from functions, especially when dealing with data manipulation.
- **Use Default Parameters less: Default parameters are useful, but avoid overuse. Too many default parameters can lead to confusion.