PHP Anfänger 25 min

Funktionen & Arrow Functions

Funktionen in modernem PHP: Typen, Default-Werte, Named Arguments, Arrow Functions mit fn und Closures mit use.

Aktualisiert:
Inhaltsverzeichnis

Funktionen & Arrow Functions

Funktionen sind das Rueckgrat jedes PHP-Programms. Mit PHP 8+ kannst du sehr sauber mit Typen, Default-Werten und Named Arguments arbeiten.

Grundform

<?php
declare(strict_types=1);

function gruessen(string $name): void
{
    echo "Hallo, {$name}!\n";
}

gruessen('Anna');
  • function name(params): Rueckgabe { }
  • Parametertypen vor dem Namen
  • Rueckgabetyp nach :
  • void fuer “gibt nichts zurueck”

Rueckgabewert

function addieren(int $a, int $b): int
{
    return $a + $b;
}

$summe = addieren(3, 4);  // 7

Default-Werte

function gruessen(string $name = 'Welt', string $gruss = 'Hallo'): string
{
    return "{$gruss}, {$name}!";
}

echo gruessen();             // "Hallo, Welt!"
echo gruessen('Anna');       // "Hallo, Anna!"
echo gruessen('Leo', 'Hi');  // "Hi, Leo!"

Named Arguments (PHP 8+)

Eine der besten Neuerungen von PHP 8:

echo gruessen(gruss: 'Moin', name: 'Tim');

Besonders hilfreich bei Funktionen mit vielen optionalen Parametern:

formatiere(
    wert: 42.5,
    nachkomma: 2,
    separator: '.',
    waehrung: 'EUR',
);

Variadic Parameters

Beliebig viele Argumente:

function summe(int ...$zahlen): int
{
    return array_sum($zahlen);
}

summe(1, 2, 3);            // 6
summe(1, 2, 3, 4, 5);      // 15

// Array entpacken
$liste = [10, 20, 30];
summe(...$liste);          // 60

Nullable Types

function finde(int $id): ?Person
{
    // gibt Person oder null zurueck
}

$p = finde(1);
if ($p === null) {
    echo 'Nicht gefunden';
} else {
    echo $p->name;
}

Union Types

function id(int|string $wert): string
{
    return (string) $wert;
}

id(42);        // "42"
id('abc123');  // "abc123"

Mehrere Rueckgabewerte

PHP hat kein Multi-Return, aber Arrays / Tupel-Simulation loesen das:

function minMax(array $zahlen): array
{
    return [min($zahlen), max($zahlen)];
}

[$min, $max] = minMax([3, 1, 4, 1, 5, 9, 2]);
echo "min: {$min}, max: {$max}";

Oder mit einer Readonly-Klasse:

readonly class MinMax
{
    public function __construct(
        public int $min,
        public int $max,
    ) {}
}

function minMax(array $zahlen): MinMax
{
    return new MinMax(min($zahlen), max($zahlen));
}

Typhinweis fuer Arrays

PHP kann Array-Inhalte nicht nativ typen - die Community hilft sich mit PHPDoc:

/**
 * @param array<int, string> $namen
 * @return array<int, string>
 */
function gross(array $namen): array
{
    return array_map('strtoupper', $namen);
}

IDEs und statische Analyse-Tools (PHPStan, Psalm) lesen diese Kommentare.

Anonyme Funktionen / Closures

$verdoppeln = function (int $n): int {
    return $n * 2;
};

echo $verdoppeln(5);  // 10

Du kannst sie direkt an Funktionen uebergeben:

$zahlen = [1, 2, 3];

$v = array_map(function ($n) { return $n * 2; }, $zahlen);
// [2, 4, 6]

use - Variablen einfangen

Closures sehen Variablen nicht automatisch - du musst sie mit use importieren:

$faktor = 3;

$multiplizieren = function (int $n) use ($faktor): int {
    return $n * $faktor;
};

echo $multiplizieren(5);  // 15

use mit Referenz

Wenn du die ausseren Variablen aendern willst:

$zaehler = 0;

$inc = function () use (&$zaehler) {
    $zaehler++;
};

$inc();
$inc();
echo $zaehler;  // 2

Arrow Functions (PHP 7.4+)

Kurze Syntax fuer Einzeiler - Variablen aus dem Scope werden automatisch eingefangen:

$faktor = 3;

$multiplizieren = fn(int $n): int => $n * $faktor;
echo $multiplizieren(5);  // 15

Perfekt mit Collection-Funktionen:

$zahlen = [1, 2, 3, 4, 5];

$verdoppelt = array_map(fn($n) => $n * 2, $zahlen);
$gerade = array_filter($zahlen, fn($n) => $n % 2 === 0);
$summe = array_reduce($zahlen, fn($a, $b) => $a + $b, 0);

Einschraenkung: Arrow Functions koennen nur einen Ausdruck haben. Fuer mehrzeiligen Code nutzt du die klassische function () use (...) { ... }-Form.

Funktionen als First-Class Values (PHP 8.1+)

$f = strtoupper(...);      // First-Class Callable Syntax
echo $f('anna');            // "ANNA"

// Methoden-Referenzen
$g = $obj->methode(...);

Und Funktionsnamen als Strings gehen auch:

array_map('strtoupper', ['anna', 'max']);

Praktisches Beispiel

<?php

declare(strict_types=1);

readonly class Produkt
{
    public function __construct(
        public string $name,
        public float $preis,
        public int $lager,
    ) {}
}

function verfuegbar(array $produkte): array
{
    return array_filter($produkte, fn(Produkt $p) => $p->lager > 0);
}

function gesamtwert(array $produkte): float
{
    return array_sum(
        array_map(fn(Produkt $p) => $p->preis * $p->lager, $produkte)
    );
}

$sortiment = [
    new Produkt('Buch',   19.99, 5),
    new Produkt('Kaffee',  3.50, 0),
    new Produkt('Tasse',   8.00, 10),
];

$lieferbar = verfuegbar($sortiment);
foreach ($lieferbar as $p) {
    echo "{$p->name}\n";
}

echo 'Gesamtwert: ' . gesamtwert($sortiment);

Zusammenfassung

  • Funktionen mit function name(params): Rueckgabe { }
  • void, Nullable (?Typ), Union Types (A|B)
  • Default-Werte und Named Arguments fuer lesbare Aufrufe
  • ...$rest fuer Variadic, ...$array zum Entpacken
  • Closures mit function () use (...) { } - explizite Variable-Capture
  • Arrow Functions (fn($x) => $x * 2) mit automatischem Capture
  • First-Class Callables (strtoupper(...)) in PHP 8.1+

Im naechsten Kapitel: Arrays - das Schweizer Messer von PHP.

Zurück zum PHP Kurs