Parameters Of PHP Functions: Formal Parameters + Actual Parameters

In PHP, as in many other programming languages, a function's parameters are the variables listed as part of a function definition. These parameters represent the values that need to be provided when calling the function. There are two types of parameters in PHP: formal parameters and actual parameters.

1. Formal Parameters

Formal parameters are the variables defined in the function declaration. They act as placeholders for the values that will be passed to the function when it is called.

For example, in the following function, a and b are the formal parameters:

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

2. Actual Parameters

Actual parameters, also known as arguments, are the specific values that are supplied when you call a function. These values are used to replace the formal parameters defined in the function declaration.

For example, in the following function call, 5 and 10 are the actual parameters:

echo addNumbers(5, 10); // Outputs: 15

In this example, the addNumbers function is called with the values 5 and 10. These values are the actual parameters that are passed into the function. Inside the function, a becomes 5 and b becomes 10, and these values are used to perform the addition.

Passing by Value vs. Passing by Reference

By default, PHP functions' arguments are passed by value, meaning that if the value of the argument within the function is changed, it does not get changed outside of the function.

However, PHP also allows for the passing of arguments by reference, meaning that a reference to the variable is passed to the function and any changes made to the argument within the function do reflect outside of the function. To pass an argument by reference, you add an ampersand (&) before the formal parameter in the function declaration.

Here is an example:

function addFive(&$number) {
    $number += 5;
}

$value = 10;
addFive($value);
echo $value; // Outputs: 15

In this example, $value is passed by reference to the addFive function. When $number is changed inside the function, $value is also changed because $number is a reference to $value.

How to define parameters in PHP functions:

Basic syntax of defining parameters in a PHP function:

<?php
function greet($name) {
    echo "Hello, $name!";
}

// Call the function with an argument
greet('John');

PHP function actual parameters usage:

Actual parameters are the values passed to a function when it is called:

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

// Call the function with actual parameters
$result = add(3, 5);
echo $result; // Output: 8

Passing values to PHP function parameters:

Values are passed to function parameters during the function call:

<?php
function greet($name) {
    echo "Hello, $name!";
}

// Call the function with a value
greet('Alice');

Default values for PHP function parameters:

Assign default values to parameters to make them optional:

<?php
function greet($name = 'Guest') {
    echo "Hello, $name!";
}

// Call the function without providing a value
greet(); // Output: Hello, Guest!

Variable-length parameter lists in PHP functions:

Use the ... operator to create variable-length parameter lists:

<?php
function sum(...$numbers) {
    return array_sum($numbers);
}

// Call the function with variable arguments
echo sum(1, 2, 3, 4); // Output: 10

Type hinting in PHP function parameters:

Type hinting restricts the type of value a parameter can accept:

<?php
function add(int $a, int $b) {
    return $a + $b;
}

// Call the function with integers
echo add(3, 5); // Output: 8

Passing arrays as parameters in PHP functions:

Arrays can be passed as parameters, providing flexibility:

<?php
function processArray(array $numbers) {
    // Process the array
    print_r($numbers);
}

// Call the function with an array
processArray([1, 2, 3]);

Examples of using formal and actual parameters in PHP functions:
- Formal parameters are the placeholders in the function definition, and actual parameters are the values passed during the function call:
```
<?php
function multiply($a, $b) {
    return $a * $b;
}

// Formal parameters: $a, $b
// Actual parameters: 2, 4
$result = multiply(2, 4);
echo $result; // Output: 8
```