PHP
Programmation fonctionnelle

Introduction

Affectation aux variables

Les fonctions anonymes peuvent être affectées à des variables à utiliser comme paramètres pour lesquels un rappel est attendu:

$uppercase = function($data) {
    return strtoupper($data);
};

$mixedCase = ["Hello", "World"];
$uppercased = array_map($uppercase, $mixedCase);
print_r($uppercased);

Ces variables peuvent également être utilisées comme appels de fonction autonomes:

echo $uppercase("Hello world!"); // HELLO WORLD!

Utilisation de variables externes

La construction use est utilisée pour importer des variables dans la portée de la fonction anonyme:

$divisor = 2332;
$myfunction = function($number) use ($divisor) {
    return $number / $divisor;
};

echo $myfunction(81620); //Outputs 35

Les variables peuvent également être importées par référence:

$collection = [];

$additem = function($item) use (&$collection) {
    $collection[] = $item;
};

$additem(1);
$additem(2);

//$collection is now [1,2]

Passer une fonction de rappel en tant que paramètre

Plusieurs fonctions PHP acceptent des fonctions de rappel définies par l'utilisateur en tant que paramètre, telles que: call_user_func() , usort() et array_map() .

Selon l'endroit où la fonction de rappel définie par l'utilisateur a été définie, il existe différentes manières de les transmettre:

Style procédural:

function square($number)
{
    return $number * $number;
}

$initial_array = [1, 2, 3, 4, 5];
$final_array = array_map('square', $initial_array);
var_dump($final_array); // prints the new array with 1, 4, 9, 16, 25

Style orienté objet:

class SquareHolder
{
    function square($number)
    {
        return $number * $number;
    }
}

$squaredHolder = new SquareHolder();
$initial_array = [1, 2, 3, 4, 5];
$final_array = array_map([$squaredHolder, 'square'], $initial_array);

var_dump($final_array); // prints the new array with 1, 4, 9, 16, 25

Style orienté objet utilisant une méthode statique:

class StaticSquareHolder
{
    public static function square($number)
    {
        return $number * $number;
    }
}

$initial_array = [1, 2, 3, 4, 5];
$final_array = array_map(['StaticSquareHolder', 'square'], $initial_array);
// or:
$final_array = array_map('StaticSquareHolder::square', $initial_array); // for PHP >= 5.2.3

var_dump($final_array); // prints the new array with 1, 4, 9, 16, 25

Utilisation des fonctions intégrées comme rappels

Dans les fonctions callable comme argument, vous pouvez également placer une chaîne avec la fonction intégrée de PHP. Il est courant d'utiliser le paramètre trim comme array_map pour supprimer les espaces blancs de array_map et de fin de toutes les chaînes du tableau.

$arr = ['   one  ', 'two   ', '   three'];
var_dump(array_map('trim', $arr));

// array(3) {
//   [0] =>
//   string(3) "one"
//   [1] =>
//   string(3) "two"
//   [2] =>
//   string(5) "three"
// }

Fonction anonyme

Une fonction anonyme est simplement une fonction qui n'a pas de nom.

// Anonymous function
function() {
    return "Hello World!";
};

En PHP, une fonction anonyme est traitée comme une expression et doit donc se terminer par un point-virgule ; .

Une fonction anonyme doit être affectée à une variable.

// Anonymous function assigned to a variable
$sayHello = function($name) {
    return "Hello $name!";
};

print $sayHello('John'); // Hello John

Ou il devrait être passé en paramètre d'une autre fonction.

$users = [
    ['name' => 'Alice', 'age' => 20], 
    ['name' => 'Bobby', 'age' => 22], 
    ['name' => 'Carol', 'age' => 17]
];

// Map function applying anonymous function
$userName = array_map(function($user) {
    return $user['name'];
}, $users);

print_r($usersName); // ['Alice', 'Bobby', 'Carol']

Ou même été renvoyé d'une autre fonction.

Fonctions anonymes à exécuter:

// For PHP 7.x
(function () {
    echo "Hello world!";
})();

// For PHP 5.x
call_user_func(function () {
    echo "Hello world!";
});

Passer un argument dans des fonctions anonymes à exécuter automatiquement:

// For PHP 7.x
(function ($name) {
    echo "Hello $name!";
})('John');

// For PHP 5.x
call_user_func(function ($name) {
    echo "Hello $name!";
}, 'John');

Portée

En PHP, une fonction anonyme a sa propre portée comme toute autre fonction PHP.

En JavaScript, une fonction anonyme peut accéder à une variable en dehors de la portée. Mais en PHP, cela n'est pas autorisé.

$name = 'John';

// Anonymous function trying access outside scope
$sayHello = function() {
    return "Hello $name!";
}

print $sayHello('John'); // Hello !
// With notices active, there is also an Undefined variable $name notice

Fermetures

Une fermeture est une fonction anonyme qui ne peut pas accéder à une portée externe.

Lorsque vous définissez une fonction anonyme en tant que telle, vous créez un "espace de noms" pour cette fonction. Il n'a actuellement accès qu'à cet espace de noms.

$externalVariable = "Hello";
$secondExternalVariable = "Foo"; 
$myFunction = function() { 
  
  var_dump($externalVariable, $secondExternalVariable); // returns two error notice, since the variables aren´t defined 

}

Il n'a accès à aucune variable externe. Pour accorder cette autorisation d'accès à cet espace de noms aux variables externes, vous devez l'introduire via des fermetures ( use() ).

$myFunction = function() use($externalVariable, $secondExternalVariable) {
   var_dump($externalVariable, $secondExternalVariable); // Hello Foo
}

Ceci est largement attribué à la portée variable de PHP - Si une variable n'est pas définie dans la portée, ou n'est pas intégrée à la variable global elle n'existe pas.

Notez également:

Hériter des variables de la portée parent n'est pas la même chose que d'utiliser des variables globales. Les variables globales existent dans la portée globale, qui est la même quelle que soit la fonction en cours d'exécution.

La portée parent d'une fermeture est la fonction dans laquelle la fermeture a été déclarée (pas nécessairement la fonction à partir de laquelle elle a été appelée).

^{Tiré de la documentation PHP pour les fonctions anonymes}

En PHP, les fermetures utilisent une approche de liaison anticipée . Cela signifie que les variables transmises à l'espace de noms de la fermeture à l'aide du mot clé use auront les mêmes valeurs lors de la définition de la fermeture.

Pour modifier ce comportement, vous devez passer la variable par référence .

$rate = .05;

// Exports variable to closure's scope
$calculateTax = function ($value) use ($rate) {
    return $value * $rate;
};

$rate = .1; 

print $calculateTax(100); // 5

$rate = .05;

// Exports variable to closure's scope
$calculateTax = function ($value) use (&$rate) { // notice the & before $rate
    return $value * $rate;
};

$rate = .1;

print $calculateTax(100); // 10

Les arguments par défaut ne sont pas implicitement requis lors de la définition de fonctions anonymes avec / sans fermeture.

$message = 'Im yelling at you';

$yell = function() use($message) {
    echo strtoupper($message);
};

$yell(); // returns: IM YELLING AT YOU

Fonctions pures

Une fonction pure est une fonction qui, étant donné la même entrée, renverra toujours la même sortie et sera sans effet secondaire .

// This is a pure function
function add($a, $b) {
    return $a + $b;
}

Certains effets secondaires modifient le système de fichiers , interagissent avec les bases de données et impriment à l’écran .

// This is an impure function
function add($a, $b) {
    echo "Adding...";
    return $a + $b;
}

Objets en tant que fonction

class SomeClass {
    public function __invoke($param1, $param2) {
        // put your code here
    }
}

$instance = new SomeClass();
$instance('First', 'Second'); // call the __invoke() method

Un objet avec une méthode __invoke peut être utilisé exactement comme toute autre fonction.

La méthode __invoke aura accès à toutes les propriétés de l'objet et pourra appeler toutes les méthodes.

Méthodes fonctionnelles communes en PHP

Cartographie

Application d'une fonction à tous les éléments d'un tableau:

array_map('strtoupper', $array);

Sachez que c'est la seule méthode de la liste où le rappel vient en premier.

Réduire (ou plier)

Réduire un tableau à une valeur unique:

$sum = array_reduce($numbers, function ($carry, $number) {
   return $carry + $number;
});

Filtration

Renvoie uniquement les éléments de tableau pour lesquels le rappel renvoie true :

$onlyEven = array_filter($numbers, function ($number) {
    return ($number % 2) === 0;
});