PHP Academy · Lektion

Anonyma funktioner och closures

Skriv inline-funktioner och fånga variabler med use.

Lektion 4 av 413 steg

Anonyma funktioner och closures är en gratis lektion i PHP Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för PHP Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i PHP Academy innehåller totalt 4 lektioner.

Vad är anonyma funktioner?

En anonym funktion (lambda) är en funktion utan namn. I PHP är den en instans av den inbyggda klassen Closure och kan lagras i en variabel, skickas som argument eller returneras från en annan funktion.

Grundläggande anonym funktion

Tilldela en funktion till en variabel och anropa den:

<?php
$double = function(int $n): int {
    return $n * 2;
};

echo $double(5);   // 10
echo $double(21);  // 42

Skicka anonyma funktioner

Skicka en closure som argument till funktioner som array_map, usort eller egna callback-funktioner:

<?php
$nums = [3, 1, 4, 1, 5, 9];

$squared = array_map(function(int $n): int {
    return $n ** 2;
}, $nums);

print_r($squared); // [9, 1, 16, 1, 25, 81]

Returnera funktioner

En funktion kan skapa och returnera en closure — detta är ett factory-mönster:

<?php
function makeMultiplier(int $factor): Closure {
    return function(int $n) use ($factor): int {
        return $n * $factor;
    };
}

$triple  = makeMultiplier(3);
$tenX    = makeMultiplier(10);

echo $triple(5);   // 15
echo $tenX(5);     // 50

Closures och use

Closures kan fånga variabler från det yttre omfånget med use. Fångsten sker genom värde (kopia) om inte & läggs till:

<?php
$taxRate = 0.18;

$addTax = function(float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

$taxRate = 0.20;  // change outer variable
echo $addTax(100); // 118 — captured value at creation time

Fånga med referens med use(&)

För att closure-funktionen ska se uppdaterade värden i det yttre omfånget fångas variabeln med referens:

<?php
$count = 0;

$increment = function() use (&$count): void {
    $count++;
};

$increment();
$increment();
echo $count;  // 2

Pilfunktioner (PHP 7.4)

Pilfunktioner är kompakta closures med ett enda uttryck som automatiskt fångar det yttre omfånget genom värde:

<?php
$rate = 1.18;
$prices = [10, 20, 30];

// Arrow function — no 'use' needed
$withTax = array_map(fn($p) => $p * $rate, $prices);

print_r($withTax); // [11.8, 23.6, 35.4]

Pilfunktioner kan inte ändra det yttre omfånget

Pilfunktioner fångar endast genom värde — de kan inte ändra variabler i det yttre omfånget:

<?php
$total = 0;
$nums  = [1, 2, 3];

// This does NOT modify $total!
array_walk($nums, fn($n) => $total += $n);

echo $total;  // 0

// Use a reference closure for mutation:
array_walk($nums, function($n) use (&$total) { $total += $n; });
echo $total;  // 6

Closures som callbacks

Många PHP-funktioner tar emot en callable — en closure, en array som [$obj, 'method'] eller ett funktionsnamn som sträng kan skickas:

<?php
$words = ['banana', 'apple', 'cherry'];

usort($words, fn($a, $b) => strcmp($a, $b));

print_r($words); // ['apple', 'banana', 'cherry']

Omedelbart anropad closure

Det går att definiera och anropa en closure på samma rad — användbart för att skapa ett isolerat omfång:

<?php
$result = (function(): int {
    $x = 10;
    $y = 20;
    return $x + $y;
})();

echo $result; // 30
// $x and $y are not in outer scope

Closure::bind och bindTo

En closure kan bindas om till kontexten för ett annat objekt med Closure::bind():

<?php
class Counter {
    private int $value = 0;
}

$increment = Closure::bind(function(int $by): void {
    $this->value += $by;
}, new Counter(), Counter::class);

// Now $increment has access to private $value

Snabb kontroll

Vilken är den viktigaste skillnaden mellan en vanlig closure med use och en pilfunktion i PHP?

Besvara frågan i den interaktiva lektionen

Sammanfattning: anonyma funktioner och closures

Sammanfattning:

Anonyma funktioner lagras i variabler och kan skickas vidare
Closures fångar variabler från det yttre omfånget med use($var) (genom värde) eller use(&$var) (genom referens)
Pilfunktioner (PHP 7.4) fångar automatiskt det yttre omfånget genom värde
Användbara för callbacks: array_map, usort, array_filter…
Kan returneras från factory-funktioner

Gratis att börja

Lär dig PHP med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 49
Lektioner: 195

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Anonyma funktioner och closures” gratis?

Ja – hela texten till ”Anonyma funktioner och closures” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i PHP Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i PHP Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Anonyma funktioner och closures”?

Skriv inline-funktioner och fånga variabler med use. Ni övar på PHP Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig PHP Academy?

Du behöver inga förkunskaper. Utbildningen i PHP Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Anonyma funktioner och closures”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här PHP Academy-lektionen?

Ja. Varje PHP Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till PHP Academy