# Functions In PHP

## What is Function & why do we need function?

The function is a block of code that can be executed repeatedly in your program. Functions help you to modularize your code, making it more organized, reusable, and easier to maintain. A function can take one or more input parameters and can also return a value.

To define a function in PHP, you use the `function` keyword followed by the name of the function and its parameters in parentheses, like this:

```php
function myFunction($param1, $param2) {
  // function body
}   
```

In this example, `myFunction` is the name of the function, and `$param1` and `$param2` are the input parameters. The code within the curly braces `{}` is the function body, which contains the code that will be executed whenever the function is called.

To call a function in PHP, you simply use its name followed by parentheses, like this:

```php
myFunction($value1, $value2);
```

In this example, `$value1` and `$value2` are the values that will be passed to the function as input parameters.

### Functions can also return values using the `return` statement. For example:

```php
function sum($num1, $num2) {
  $result = $num1 + $num2;
  return $result;
}

$total = sum(5, 10); // $total will be 15
```

In this example, the `sum()` function takes two input parameters and returns their sum using the `return` statement. The value returned by the function can be assigned to a variable, as shown in the second line of code.

PHP has many built-in functions that you can use, such as `strlen()` to get the length of a string, `date()` to get the current date and time, `array_push()` to add elements to an array, and more. You can also define your own custom functions to suit your specific needs.

---

## Passing a Reference Variable in PHP Function:-

In PHP, you can pass variables by reference to a function using the ampersand (`&`) symbol. When a variable is passed by reference, any changes made to the variable within the function will also affect the original variable outside the function.

Here is an example of passing a variable by reference to a function:

```php
function addOne(&$num) {
  $num += 1;
}

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

In this example, the `addOne()` function takes a parameter `$num` by reference using the ampersand symbol. Inside the function, the value of `$num` is incremented by 1 using the `+=` operator.

The variable `$value` is then assigned the value of 5, and the `addOne()` function is called with `$value` as the input parameter. Since `$value` is passed by reference, its value is incremented by 1 inside the function and the resulting value of `$value` outside the function is 6.

### Why? (why we do need to pass a variable as a reference?)

Passing variables by reference can be useful in situations where you need to modify the value of a variable inside a function and have those changes reflected outside the function.

### How? (How do you use this concept in real-world scenario? )

A real-world example where passing variables by reference can be useful is when you are working with large arrays or objects in PHP.

Consider a scenario where you have a large array of data that needs to be sorted multiple times in your code. If you create a separate function to perform the sorting, you can pass the array by reference to the function to avoid creating a copy of the array, which can save memory and improve performance.

```php
function sortArray(&$arr) {
  sort($arr);
}

$data = array(3, 2, 1, 5, 4);
sortArray($data);
print_r($data);
```

In this example, the `sortArray()` function takes an array parameter `$arr` by reference using the ampersand symbol. Inside the function, the `sort()` function is called on the array to sort its elements in ascending order.

The `$data` variable is then assigned an array of integers, and the `sortArray()` function is called with `$data` as the input parameter. Since `$data` is passed by reference, the array is sorted in place and the resulting array is printed using the `print_r()` function.

By passing the array by reference, we avoid creating a copy of the array, which can save memory and improve performance when working with large datasets.