PHP Functions

PHP offers a wide range of functions that can be used for various tasks. A function is defined using the function keyword, followed by the name of the function, a list of parameters inside parentheses, and the function body enclosed in curly braces. Functions enable code reusability, which makes the program clearer and easier to maintain.

EXAMPLE

[file:Basic Function Usage]
<?php
 // Simple example of a function that accepts two parameters and returns their sum.
 
 function addNumbers($a, $b) {
 return $a + $b;
 }

$num1 = 5;
  $num2 = 7;
  $result = addNumbers($num1, $num2);

echo "The sum of numbers $num1 and $num2 is: " . $result . " ";
 
 // A function can also be called directly inside an echo output
 echo "Direct call (10 + 20): " . addNumbers(10, 20);
?>

[file:Default Parameter Values]
<?php
 // Parameters can be assigned default values beforehand.
 
 function greet($name = "visitor", $tutorial = "PHP") {
 return "Hello $name, welcome to the $tutorial tutorial!";
 }

// Using default values
 echo greet() . " ";

// Passing only the first argument
 echo greet("Borut") . " ";

// Passing both arguments
  echo greet("Borut", "JavaScript");
?>

[file:Variable Number of Arguments]
<?php
 // Using the splat operator (...) to accept an arbitrary amount of arguments.
 
 function sumAll(...$numbers) {
 $sum = array_sum($numbers);
 return "The sum of all numbers is: " . $sum;
 }

echo sumAll(1, 2, 3, 4, 5) . " ";
 echo sumAll(10, 20);
?>

[file:Passing Arguments by Reference]
<?php
 // A reference (&) allows a function to modify the value of the original variable.
 
 function incrementByOne(&$num) {
 $num++;
 }

$value = 10;
  incrementByOne($value);
  
  echo "Value after the function call: " . $value; // Outputs 11
?>

[file:Recursive Functions]
<?php
 // A function that calls itself (e.g., calculating a factorial).
 
 function factorial($n) {
 if ($n <= 1) {
 return 1;
 }
 return $n * factorial($n - 1);
 }

$number = 5;
  echo "The factorial of $number is: " . factorial($number);
?>

[file:Anonymous Functions]
<?php
 // Functions without a name, stored inside a variable.
 
 $greeting = function($name) {
 return "Hello, $name!";
 };

echo $greeting("Borut") . " ";

// Example of using an anonymous function inside array processing
  $numbers = [1, 2, 3, 4, 5];
  $squares = array_map(function($n) {
    return $n * $n;
  }, $numbers);

echo "Squares of numbers: " . implode(", ", $squares);
?>

RESULT

The result will be displayed here...

The Power of Built-in Functions

The true power of PHP comes from its functions. PHP has more than 1000 built-in functions that are ready for immediate use, while also giving us complete freedom to create our own custom solutions.

A function is a block of code that can be called anywhere and anytime.
They help us organize code cleanly (DRY - Don't Repeat Yourself).
A function is executed only when it is officially called by its name.
They can return values (return) or simply execute a specific action.

Creating and Calling User-Defined Functions

In addition to the rich library of built-in functions, PHP allows us to write our own custom functions. A user-defined function name must start with a letter or an underscore (not a number) and is **not** case-sensitive, although it is best practice to write them consistently. The code inside curly braces will not execute when the page loads, but only when the function is officially called in the script using its name and parentheses.

Function Arguments and Returning Values (Return)

Information can be passed to functions upon calling via **arguments** (variables inside the parentheses). Arguments act just like local variables within the function itself. A function can accept any number of arguments separated by commas. Crucially, the return statement stops the execution of the function and "hands" its final result back to the spot where it was originally called. This allows us to store the calculated value in a variable or output it later.

System Functions for Function Management (Cheat Sheet)

PHP provides several built-in functions that allow us to check the existence of functions, analyze their arguments, or retrieve a list of all defined functions within the system:

Function Name	Description	Example (Code for Simulator)
`function_exists()`	Checks if a function with a specific name is already defined and ready to be called (returns true/false).	`var_dump(function_exists("is_numeric"));`
`is_callable()`	Verifies if the contents of a variable can be called as a function (highly useful for callback functions).	`$f = "strlen"; var_dump(is_callable($f));`
`get_defined_functions()`	Returns a multidimensional associative array of all built-in (internal) and user-defined (user) functions.	`print_r(get_defined_functions()["user"]); // Outputs only your custom functions`
`func_num_args()`	Returns the number of arguments actually passed to the function (used inside the function body).	`function test() { echo func_num_args(); } test("a", "b", "c"); // Outputs 3`
`func_get_arg()`	Returns a specific argument from the list of passed arguments based on its index offset (counting from 0).	`function test() { echo func_get_arg(1); } test("First", "Second"); // Outputs Second`
`func_get_args()`	Returns an indexed array containing all arguments passed to the function.	`function test() { print_r(func_get_args()); } test(10, "PHP", true);`
`call_user_func()`	Calls a custom or built-in function specified by the first parameter and passes the remaining arguments to it.	`echo call_user_func("strtoupper", "hello");`