PHP FUNCTIONS FIRST PART

THE FUNCTIONS IN PHP

DECLARATION OF A FUNCTION

You define a function with the keyword function and a meaningful name. It is not good to give names that do not identify the function performed by the algorithm. If we want the instructions inside a function to be executed we must, as they say, invoke it . Even if we place the call before the definition, we have no error, the code is parsed beforehand and the functions are put in memory. In PHP we can define anonymous functions . what we can do with such functions is assign it to a variable, execute it or use it as a callback. A function can receive input data and return values, in this sense it is a block in itself, through the input and the output communicates with the outside world.

DUPLICATION OF THE CODE

A function can be called any number of times, this allows us not to duplicate the code. Code duplication is something to avoid when developing an application. While we can modify a variable defined in the global scope from within a function, this is actually not good programming practice. Functions are a level of abstraction, this means that we talk to a function through its name, but we don’t have to know how it works internally, abstracting means moving away from the implementation details of a function that performs a certain task.

SAMPLE CODE

Copy to Clipboard

<?php
//VARIABLE-LENGTH ARGUMENT LIST
function test($p1,$p2,$p3 = 1){

}

test(1,2);
/*--Se la funzione è stata definita con tre parametri obbligatori
otteniamo un errore fatale se ne passiamo di meno. Assegniamo al
terzo parametro un valore di default. Ora non ci sono errori.
Alcune volte non sappiamo a priori quanti parametri passeremo alla
funzione, vogliamo avere una funzione che accetti un numero
variabile di valori. Per farlo utilizziamo l'operatore ...
Se ad esempio la funzione somma si aspetta due parametri 
li possiamo aggiungere*/

function test1(...$valori){
     //var_dump($valori);//Otteniamo un array dei valori passati in input.
     foreach($valori as $valore){
          echo $valore ."\n\r";
     }
}
test1(1,2,3);

function somma( $a, $b, ...$valori){
     var_dump($valori);
     $totale = 0; 
     foreach($valori as $valore){
          $totale += $valore;
     }
     return $totale;
}
echo 'Il risultato della somma è: ' .somma(10,26,31,10,15);

/*--I primi due argomenti non entrano a far parte dell'array perchè
sono rispettivamente i valori passati a $a e $b. I restanti valori 
entrano a far parte dell'array.*/
?>

FUNCTION PARAMETERS

The code on the side explains the parameters of the functions.

VARIABLE-LENGTH ARGUMENT LIST

function test($p1,$p2,$p3 = 1){

}

test(1,2);

If the function has been defined with three mandatory parameters we get a fatal error if we pass less. Let’s assign a default value to the third parameter. Now there are no mistakes. Some times we do not know a priori how many parameters we will pass to the function, if we want to have a function that accepts a variable number of values we use the operator … For example, if the sum function expects two mandatory parameters there we can add.

Copy to Clipboard

<?php
//VARIABLE-LENGTH ARGUMENT LIST
function test($p1,$p2,$p3 = 1){

}

function test1(...$valori){
     //var_dump($valori);//Otteniamo un array dei valori passati in input.
     foreach($valori as $valore){
          echo $valore ."\n\r";
     }
}
test1(1,2,3);

/*--I primi due argomenti non entrano a far parte dell'array perchè
sono rispettivamente i valori passati a $a e $b. I restanti valori 
entrano a far parte dell'array.*/
?>

TYPE HINTING

function calculateValue(float $p1){

var_dump($p1);

}

$value = “22”;

calculateValue($value);

When we invoke a function there is no control over the parameters, we can pass any type of data. If we want to have a minimum of control over the values passed, we put the expected type before the parameter. If we now try to pass the PHP string we will get a fatal error. If we pass an integer this value is automatically converted by PHP to float. Even if we pass a string with an integer inside it is converted by PHP to float. If we want to work even more strictly without PHP performing these automatic conversions of its own, we add this statement declare(strict_types = 1); The declare statement must be the first statement in the script. We can also do type hinting for the values that the function returns, just indicate two points : and the type after the parameter declaration.

NULLABLE AND UNION TYPES

If we want the function as parameter $p1 accept an int and a float we can do this thanks to union types introduced in PHP 8. Just add a vertical bar and the other type we want allowed. If we want a parameter to be of any type we indicate mixed. In this case we can pass any type of data including null.

FURTHER INFORMATION

Functions in PHP are blocks of code that perform a specific task. They can be called at any point in the program to perform the task assigned to them, which helps keep the code organized and reusable. Here is a detailed description of functions in PHP:

1. Definition of a Function

In PHP, a function is defined using the function keyword, followed by the function name and a list of parameters (if any) enclosed in round brackets, and the body of the function enclosed in curly brackets. For example:

function nameFunction($parameter1, $parameter2) {
// body of the function
}

2. Recall of a Function

After defining a function, you can call it anywhere in your script simply by using its name followed by brackets.
If the function accepts parameters, you must pass them inside the parentheses. Example:

nameFunction($value1, $value2);

3. Parameters and Arguments

Parameters are variables specified in the parentheses of the function definition. When you call the function, you can pass values (arguments) to these parameters. Parameters can have default values, which will be used if no arguments are passed when calling the function:

function greet($name =“User“) {
echo“Hello, ” . $name;
}

greet(); // Output: Hello, User
greet(“Marco“); // Output: Hello, Marco

4. Return Value

A function can return a value using the return keyword. Once return is executed, the execution of the function ends and control is returned to where the function was called:

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

$result = sum(5, 3); // $result now contains 8

5. Scope of Variables

Variables defined within a function have a local scope, which means that they exist only within the function. Global variables cannot be accessed directly within functions unless they are declared global:

$number = 10;

function multiply($value) {
global $number; // Makes $number accessible in the function
return $value * $number;
}

echo multiply(2); // Output: 20

7. Anonymous Functions and Lambda Functions

In PHP, it is possible to create anonymous functions (i.e., unnamed functions) that can be assigned to variables or passed as arguments to other functions. These are also known as lambda functions:

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

echo $sum(2, 3); // Output: 5

8. Functions with Typed Parameters

PHP supports parameter typing, which means that you can specify the data type that a parameter must have. If a value of the wrong type is passed, PHP will generate an error:

Function addNumbers(int $a, int $b): int {
return $a + $b;
}

echo addNumbers(5, 3); // Output: 8

11. Variadic functions

Starting with PHP 5.6, you can use variadic functions to pass a variable number of arguments to a function using the operator …:

function sumAll(…$numbers) {
return array_sum($numbers);
}

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

12. Closure

Closures are anonymous functions that can access variables outside their scope using the use keyword:

$greeting =“Hello.”

$function = function($name) use($greeting) {
echo $greeting .”, ” .$name;
};

$function(“Marco“); // Output: Hello, Marco

Features in PHP are a powerful tool for writing modular and reusable code, making it easier to maintain and organize software.

LINKS TO PREVIOUS POSTS

THE PHP LANGUAGE

LINK TO THE CODE ON GITHUB

GITHUB