Pass Parameters to PHP Function

In PHP, you can pass parameters to a function by including them in the parentheses after the function name when you define the function. Here's a basic example:

function sayHello($name) {
    echo "Hello, $name!";
}

sayHello("Alice"); // Outputs: Hello, Alice!

In this example, $name is a parameter for the sayHello function. When you call the function, you pass the argument "Alice" to the function, and it gets assigned to the $name parameter.

You can pass as many parameters as you want to a function, just separate them with commas:

function addNumbers($num1, $num2) {
    $sum = $num1 + $num2;
    echo "The sum is $sum";
}

addNumbers(5, 10); // Outputs: The sum is 15

In this example, the addNumbers function has two parameters: $num1 and $num2. When you call the function, you pass two arguments to it (5 and 10), which get assigned to $num1 and $num2 respectively.

By default, function arguments in PHP are passed by value, which means that if you change the value of an argument inside a function, it does not get changed outside of the function. However, you can pass arguments by reference if you want changes to the argument to persist outside of the function. To do this, you prefix the argument with an ampersand (&) in the function definition:

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

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

In this example, because $number is passed by reference to the addFive function, when we add 5 to $number inside the function, the change persists outside of the function, so $num is 15 after the function call.

Positional vs. named parameters in PHP functions:

Positional parameters are passed in the order they appear.
Named parameters allow passing values using parameter names.

// Positional parameters
function greet($name, $age) {
    echo "Hello $name, you are $age years old.";
}

greet("John", 25);

// Named parameters
function greetNamed($name, $age) {
    echo "Hello $name, you are $age years old.";
}

greetNamed(age: 25, name: "John");

Default values for function parameters in PHP:

Parameters can have default values, allowing optional arguments.

function greetDefault($name, $greeting = "Hello") {
    echo "$greeting, $name!";
}

greetDefault("John");        // Output: Hello, John!
greetDefault("John", "Hi");  // Output: Hi, John!

Variable-length argument lists in PHP functions:

func_get_args() allows variable-length argument lists.

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

echo sum(1, 2, 3, 4);  // Output: 10

Using references to modify parameters in PHP:

Pass parameters by reference using &.

function increment(&$number) {
    $number++;
}

$value = 5;
increment($value);
echo $value;  // Output: 6

Passing arrays and associative arrays to PHP functions:

Arrays can be passed to functions.

function processArray($arr) {
    foreach ($arr as $item) {
        echo "$item ";
    }
}

$numbers = [1, 2, 3];
processArray($numbers);  // Output: 1 2 3

Associative arrays can also be used.

function processAssocArray($assoc) {
    foreach ($assoc as $key => $value) {
        echo "$key: $value ";
    }
}

$person = ["name" => "John", "age" => 30];
processAssocArray($person);  // Output: name: John age: 30

Object parameters in PHP functions:

Pass objects as parameters to functions.

class User {
    public $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

function displayUser(User $user) {
    echo "User: " . $user->name;
}

$john = new User("John");
displayUser($john);  // Output: User: John