PHP
Funktionell programmering

Introduktion

Tilldelning till variabler

Anonyma funktioner kan tilldelas variabler för användning som parametrar där en återuppringning förväntas:

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

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

Dessa variabler kan också användas som fristående funktionssamtal:

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

Använda externa variabler

use används för att importera variabler till den anonyma funktionens omfattning:

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

echo $myfunction(81620); //Outputs 35

Variabler kan också importeras genom referens:

$collection = [];

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

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

//$collection is now [1,2]

Att skicka en återuppringningsfunktion som en parameter

Det finns flera PHP-funktioner som accepterar användardefinierade återuppringningsfunktioner som en parameter, till exempel: call_user_func() , usort() och array_map() .

Beroende på var den användardefinierade återuppringningsfunktionen definierades finns det olika sätt att passera dem:

Procedurstil:

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

Objektorienterad 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

Objektorienterad stil med hjälp av en statisk metod:

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

Använda inbyggda funktioner som återuppringningar

I funktioner som kan callable som ett argument kan du också sätta en sträng med PHP inbyggd funktion. Det är vanligt att använda trim som array_map parameter för att ta bort ledande och släpande mellanrum från alla strängar i arrayen.

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

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

Anonym funktion

En anonym funktion är bara en funktion som inte har ett namn.

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

I PHP behandlas en anonym funktion som ett uttryck och av denna anledning bör den avslutas med ett semikolon ; .

En anonym funktion bör tilldelas en variabel.

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

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

Eller så ska den ges som parameter för en annan funktion.

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

Eller till och med återlämnats från en annan funktion.

Självutförande av anonyma funktioner:

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

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

Vidarebefordra ett argument till självutförande av anonyma funktioner:

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

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

Omfattning

I PHP har en anonym funktion sitt eget räckvidd som alla andra PHP-funktioner.

I JavaScript kan en anonym funktion få åtkomst till en variabel utanför. Men i PHP är detta inte tillåtet.

$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

nedläggningar

En stängning är en anonym funktion som inte har åtkomst utanför tillämpningsområdet.

När du definierar en anonym funktion som sådan skapar du ett "namnområde" för den funktionen. Den har för närvarande bara åtkomst till det namnområdet.

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

}

Den har inte tillgång till några externa variabler. För att ge detta tillstånd för detta namnutrymme för att få åtkomst till externa variabler måste du introducera det via stängningar ( use() ).

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

Detta tillskrivs starkt PHP: s snäva variabla scoping - Om en variabel inte definieras inom räckvidden, eller inte har tagits med global så finns den inte.

Observera också:

Arv av variabler från överordnade omfång är inte detsamma som att använda globala variabler. Globala variabler finns i det globala omfånget, vilket är samma oavsett vilken funktion som körs.

Det överordnade omfånget för en stängning är den funktion där stängningen deklarerades (inte nödvändigtvis den funktion den kallades från).

^{Hämtad från PHP-dokumentationen för anonyma funktioner}

I PHP använder stängningar ett tidigt bindande tillvägagångssätt. Detta innebär att variabler skickas till stängningen namnområde med hjälp av use sökord kommer att ha samma värden när nedläggningen definierades.

För att ändra detta beteende bör du passera variabeln med referens .

$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

Standardargument krävs inte implicit när man definierar anonyma funktioner med / utan stängningar.

$message = 'Im yelling at you';

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

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

Rena funktioner

En ren funktion är en funktion som, med samma ingång, alltid kommer att returnera samma utgång och är från sidoeffektfri .

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

Vissa biverkningar förändrar filsystemet , interagerar med databaser , skriver ut på skärmen .

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

Objekt som funktion

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

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

Ett objekt med en __invoke metod kan användas exakt som alla andra funktioner.

Metoden __invoke har tillgång till alla egenskaper hos objektet och kommer att kunna anropa alla metoder.

Vanliga funktionella metoder i PHP

kartläggning

Tillämpa en funktion på alla element i en matris:

array_map('strtoupper', $array);

Var medveten om att detta är den enda metoden i listan där återuppringningen kommer först.

Minska (eller vikas)

Minska en matris till ett enda värde:

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

Filtrering

Returnerar endast de arrayobjekt som återuppringningen returnerar true :

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