PHP
Funktionale Programmierung

Einführung

Zuordnung zu Variablen

Anonyme Funktionen können Variablen zugewiesen werden, die als Parameter verwendet werden, bei denen ein Rückruf erwartet wird:

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

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

Diese Variablen können auch als eigenständige Funktionsaufrufe verwendet werden:

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

Verwenden Sie externe Variablen

Das use wird verwendet, um Variablen in den Umfang der anonymen Funktion zu importieren:

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

echo $myfunction(81620); //Outputs 35

Variablen können auch als Referenz importiert werden:

$collection = [];

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

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

//$collection is now [1,2]

Rückruffunktion als Parameter übergeben

Es gibt mehrere PHP-Funktionen, die benutzerdefinierte Callback-Funktionen als Parameter akzeptieren, z. B. call_user_func() , usort() und array_map() .

Je nachdem, wo die benutzerdefinierte Rückruffunktion definiert wurde, gibt es verschiedene Möglichkeiten, sie zu übergeben:

Verfahrensstil:

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

Objektorientierter Stil:

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

Objektorientierter Stil mit einer statischen Methode:

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

Eingebaute Funktionen als Rückrufe verwenden

In Funktionen, die als Argument callable , können Sie auch einen String mit der integrierten PHP-Funktion einfügen. Es ist üblich, den Parameter trim als array_map zu verwenden, um führende und nachgestellte Leerzeichen aus allen Zeichenfolgen im Array zu entfernen.

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

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

Anonyme Funktion

Eine anonyme Funktion ist nur eine Funktion , die keinen Namen hat.

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

In PHP wird eine anonyme Funktion wie ein Ausdruck behandelt und sollte daher mit einem Semikolon abgeschlossen werden ; .

Eine anonyme Funktion sollte einer Variablen zugewiesen werden.

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

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

Oder es sollte als Parameter einer anderen Funktion übergeben werden.

$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']

Oder auch aus einer anderen Funktion zurückgegeben.

Anonyme Funktionen, die automatisch ausgeführt werden:

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

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

Übergeben eines Arguments an sich selbst ausführende anonyme Funktionen:

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

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

Umfang

In PHP hat eine anonyme Funktion ihren eigenen Gültigkeitsbereich wie jede andere PHP-Funktion.

In JavaScript kann eine anonyme Funktion auf eine Variable außerhalb des Gültigkeitsbereichs zugreifen. In PHP ist dies jedoch nicht zulässig.

$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

Verschlüsse

Eine Schließung ist eine anonyme Funktion, auf die außerhalb des Bereichs nicht zugegriffen werden kann.

Wenn Sie eine anonyme Funktion als solche definieren, erstellen Sie einen "Namespace" für diese Funktion. Es hat derzeit nur Zugriff auf diesen Namespace.

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

}

Es hat keinen Zugriff auf externe Variablen. Um diese Berechtigung für diesen Namespace für den Zugriff auf externe Variablen zu erteilen, müssen Sie sie über Closures ( use() ) einführen.

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

Dies ist stark auf die enge Variablendefinition von PHP zurückzuführen. Wenn eine Variable nicht innerhalb des Gültigkeitsbereichs definiert oder nicht mit global wird, existiert sie nicht.

Beachten Sie auch:

Die Übernahme von Variablen aus dem übergeordneten Bereich ist nicht mit der Verwendung globaler Variablen identisch. Globale Variablen sind im globalen Gültigkeitsbereich vorhanden, unabhängig davon, welche Funktion ausgeführt wird.

Der übergeordnete Bereich eines Abschlusses ist die Funktion, in der der Abschluss deklariert wurde (nicht notwendigerweise die Funktion, aus der er aufgerufen wurde).

^{Entnommen aus der PHP-Dokumentation für anonyme Funktionen}

In PHP verwenden Closures einen frühverbindlichen Ansatz. Das bedeutet, dass Variablen, die mit dem Schlüsselwort use Namens der Schließung übergeben werden, beim Definieren der Schließung dieselben Werte haben.

Um dieses Verhalten zu ändern, sollten Sie die Variable als Referenz übergeben .

$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

Standardargumente sind nicht unbedingt erforderlich, wenn anonyme Funktionen mit / ohne Schließungen definiert werden.

$message = 'Im yelling at you';

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

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

Reine Funktionen

Eine reine Funktion ist eine Funktion, die bei gleicher Eingabe immer dieselbe Ausgabe zurückgibt und frei von Nebeneffekten ist.

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

Einige Nebenwirkungen verändern das Dateisystem , interagieren mit Datenbanken und drucken auf den Bildschirm .

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

Objekte als Funktion

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

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

Ein Objekt mit einer __invoke Methode kann genau wie jede andere Funktion verwendet werden.

Die __invoke Methode hat Zugriff auf alle Eigenschaften des Objekts und kann beliebige Methoden aufrufen.

Häufige funktionale Methoden in PHP

Kartierung

Anwenden einer Funktion auf alle Elemente eines Arrays:

array_map('strtoupper', $array);

Beachten Sie, dass dies die einzige Methode der Liste ist, bei der der Rückruf an erster Stelle steht.

Reduzieren (oder falten)

Reduzieren eines Arrays auf einen einzelnen Wert:

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

Filterung

Gibt nur die Arrayelemente zurück, für die der Rückruf true zurückgibt:

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