PHP | Functions

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

// Creating a function that adds two numbers
function addNumbers($a, $b) {
    
    // code to be executed
    $result = $a + $b; 
    
    // returning the sum
    return $result;     
}

// Calling the function
echo addNumbers(5, 10);   

?>

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
   function sum($a, $b) {
    return $a + $b;
}
echo sum(5, 3);  // Outputs: 8
?>

8

In this example:

• The function sum() is defined to take two parameters, $a and $b, 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
 function addNumbers($a, $b) {
    return $a + $b;
}
echo addNumbers(5, 3); // Output: 8
?>

8

In this example:

• The function addNumbers is defined by the user to take two parameters, $a and $b, 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
  $str = "Hello, World!";
echo strlen($str); // Output: 13
?>

13

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
 function add($x, $y) {
    $x = $x + $y;
    return $x;
}

echo add(2, 3);  // Outputs: 5
?>

5

In this example:

• The function add() is defined with parameters $x and $y.
• The function adds $x and $y 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
function addByRef(&$x, $y) {
    $x = $x + $y;
}
$a = 5;
addByRef($a, 3);
echo $a;  // Outputs: 8
?>

8

In this example:

• The function addByRef() is defined with $x passed by reference.
• The function modifies $x directly, adding $y to it.
• After calling the function with $a = 5 and 3, the value of $a 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
   function multiply($a, $b) {
    return $a * $b;
}
$result = multiply(4, 5); // $result will be 20
echo $result; // Output: 20
?>

20

In this example:

• The function multiply() is defined to return the product of $a and $b.
• 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($name) {
    echo "Hello, " . $name . "!";
};
$greet("GFG"); 
?>

Hello, 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
function factorial($n) {
    if ($n == 0) {
        return 1;
    } else {
        return $n * factorial($n - 1);
    }
}
echo factorial(5); 
?>

120

In this example:

• The function factorial() is defined to calculate the factorial of a number $n using recursion.
• If $n is 0, the function returns 1 (base case); otherwise, it calls itself with $n - 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.