PHP
Functionele programmering

Invoering

Toewijzing aan variabelen

Anonieme functies kunnen worden toegewezen aan variabelen voor gebruik als parameters waarbij een callback wordt verwacht:

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

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

Deze variabelen kunnen ook worden gebruikt als zelfstandige functieoproepen:

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

Externe variabelen gebruiken

De use wordt gebruikt om variabelen in het bereik van de anonieme functie te importeren:

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

echo $myfunction(81620); //Outputs 35

Variabelen kunnen ook worden geïmporteerd door middel van referentie:

$collection = [];

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

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

//$collection is now [1,2]

Een callback-functie doorgeven als parameter

Er zijn verschillende PHP-functies die door de gebruiker gedefinieerde callback-functies als parameter accepteren, zoals: call_user_func() , usort() en array_map() .

Afhankelijk van waar de door de gebruiker gedefinieerde callback-functie is gedefinieerd, zijn er verschillende manieren om ze door te geven:

Procedurele stijl:

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

Object georiënteerde stijl:

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

Object georiënteerde stijl met behulp van een statische 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

Ingebouwde functies gebruiken als callbacks

In functies die callable als argument, kunt u ook een string plaatsen met de ingebouwde PHP-functie. Het is gebruikelijk om trim als parameter array_map te gebruiken om witruimte aan het array_map en het einde van alle reeksen in de array te verwijderen.

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

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

Anonieme functie

Een anonieme functie is gewoon een functie zonder naam.

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

In PHP wordt een anonieme functie behandeld als een uitdrukking en om deze reden moet deze worden afgesloten met een puntkomma ; .

Een anonieme functie moet worden toegewezen aan een variabele.

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

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

Of het moet worden doorgegeven als parameter van een andere functie.

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

Of zelfs teruggekeerd van een andere functie.

Anonieme functies uitvoeren:

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

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

Een argument doorgeven aan anonieme functies die zichzelf uitvoeren:

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

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

strekking

In PHP heeft een anonieme functie zijn eigen bereik zoals elke andere PHP-functie.

In JavaScript heeft een anonieme functie toegang tot een variabele die buiten het bereik valt. Maar in PHP is dit niet toegestaan.

$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

sluitingen

Een sluiting is een anonieme functie die geen toegang heeft buiten het bereik.

Wanneer u een anonieme functie als zodanig definieert, maakt u een "naamruimte" voor die functie. Het heeft momenteel alleen toegang tot die naamruimte.

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

}

Het heeft geen toegang tot externe variabelen. Als u deze toestemming voor deze naamruimte wilt verlenen voor toegang tot externe variabelen, moet u deze introduceren via sluitingen ( use() ).

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

Dit wordt sterk toegeschreven aan de strakke variabelencope van PHP - Als een variabele niet binnen het bereik wordt gedefinieerd, of niet met global wordt ingebracht, bestaat deze niet.

Let ook op:

Het overnemen van variabelen uit het bovenliggende bereik is niet hetzelfde als het gebruik van globale variabelen. Globale variabelen bestaan in het globale bereik, wat hetzelfde is, ongeacht welke functie wordt uitgevoerd.

Het bovenliggende bereik van een sluiting is de functie waarin de sluiting is gedeclareerd (niet noodzakelijkerwijs de functie waarvan deze werd genoemd).

^{Genomen uit de PHP-documentatie voor anonieme functies}

In PHP gebruiken sluitingen een vroege bindende aanpak. Dit betekent dat variabelen die worden doorgegeven aan de naamruimte van de sluiting met use trefwoord use dezelfde waarden hebben toen de sluiting werd gedefinieerd.

Als u dit gedrag wilt wijzigen, moet u de variabele by-reference doorgeven.

$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

Standaardargumenten zijn niet impliciet vereist bij het definiëren van anonieme functies met / zonder sluitingen.

$message = 'Im yelling at you';

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

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

Pure functies

Een pure functie is een functie die, bij dezelfde ingang, altijd dezelfde uitgang retourneert en geen bijwerkingen heeft .

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

Sommige bijwerkingen zijn het wijzigen van het bestandssysteem , interactie met databases , afdrukken naar het scherm .

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

Objecten als functie

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

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

Een object met een __invoke methode kan precies als elke andere functie worden gebruikt.

De __invoke methode heeft toegang tot alle eigenschappen van het object en kan alle methoden aanroepen.

Algemene functionele methoden in PHP

In kaart brengen

Een functie toepassen op alle elementen van een array:

array_map('strtoupper', $array);

Houd er rekening mee dat dit de enige methode in de lijst is waarbij het terugbellen eerst komt.

Verkleinen (of vouwen)

Een array verkleinen tot een enkele waarde:

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

filtering

Retourneert alleen de matrixitems waarvoor de callback true retourneert:

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