PHP Variablen: Deklaration, Scope, global und static

Eine PHP-Variable ist ein Name, der mit $ beginnt, und du erzeugst sie, indem du einen Wert zuweist: $name = "Ada";. Es gibt kein Schlüsselwort zur Deklaration und keinen Typ, den du angeben musst, denn der Wert bestimmt den Typ. Später kannst du einen Wert eines anderen Typs zuweisen.

<?php
$name = "Ada";
$age = 36;
$height = 1.65;
$isAdmin = true;

echo "$name is $age years old\n";

$age = $age + 1;           // update the value
$age++;                    // add one more
echo "Two birthdays later: $age\n";

$age = "thirty-eight";     // the type can change too
echo "Now a string: $age\n";

Regeln für Variablennamen

Ein Variablenname beginnt mit $, dann folgt ein Buchstabe oder Unterstrich, danach beliebige Buchstaben, Ziffern oder Unterstriche. Nicht-ASCII-Buchstaben zählen als Buchstaben, also ist $名前 gültig, auch wenn ASCII-Namen üblich sind. Namen unterscheiden Groß- und Kleinschreibung.

$city, $City und $CITY sind also drei verschiedene Variablen. Verwende snake_case ($first_name) oder camelCase ($firstName) und bleib pro Projekt bei einem Stil. Die PSR-Coding-Standards lassen die Benennung von Variablen absichtlich offen; Code in Laravel und Symfony verwendet meist camelCase.

Variablen in Strings verwenden

In doppelten Anführungszeichen ersetzt PHP Variablen durch ihre Werte, in einfachen nicht. Setze die Variable in geschweifte Klammern, wenn direkt Buchstaben folgen oder wenn du ein Array-Element über einen String-Schlüssel ansprichst:

<?php
$fruit = "apple";
$basket = ["count" => 4];

echo "I like $fruit pie\n";
echo 'I like $fruit pie' . "\n";              // single quotes: printed as written
echo "Two {$fruit}s please\n";                // braces separate the name
echo "There are {$basket['count']} left\n";   // array key inside a string
echo "Joined: " . $fruit . " and pear\n";     // concatenation with .

Die Seite zu Strings behandelt Anführungszeichen, Verkettung und Interpolation im Detail.

Undefinierte Variablen und Standardwerte

Eine Variable zu lesen, der nie etwas zugewiesen wurde, ergibt null, und dein PHP gibt eine Warnung aus:

Warning: Undefined variable $discount in /home/index.php on line 3

Prüfe vorher mit isset oder verwende den Null-Coalescing-Operator ??, um einen Standardwert zu liefern. Beides läuft ohne Warnung:

<?php
$price = 50;

$discount = $discount ?? 0;    // use 0 when $discount is not set
echo "Price: " . ($price - $discount) . "\n";

if (isset($coupon)) {
    echo "Coupon: $coupon\n";
} else {
    echo "No coupon given\n";
}

$coupon = null;
var_dump(isset($coupon));      // a variable holding null counts as not set

$x ??= 0; ist die Kurzform von $x = $x ?? 0;. Werte aus Formularen und URLs sind der typische Fall: $page = $_GET['page'] ?? 1;.

Scope von Variablen in Funktionen

Variablen, die außerhalb einer Funktion definiert sind, sind darin nicht sichtbar, und Variablen, die in einer Funktion entstehen, verschwinden, wenn sie zurückkehrt. Das überrascht Umsteiger aus JavaScript am häufigsten:

<?php
$taxRate = 0.2;

function priceWithTax($price)
{
    // $taxRate does not exist here, so ?? falls back to 0
    return $price * (1 + ($taxRate ?? 0));
}

function priceWithTaxFixed($price, $rate)
{
    return $price * (1 + $rate);   // pass what the function needs
}

echo priceWithTax(100), "\n";
echo priceWithTaxFixed(100, $taxRate), "\n";

Ohne das ?? 0 würde die erste Funktion vor einem undefinierten $taxRate warnen. Werte als Parameter zu übergeben hält Funktionen vorhersehbar und leicht testbar, und das solltest du zuerst tun. Die Seite zu Funktionen behandelt Parameter und Rückgabewerte.

Das Schlüsselwort global und $GLOBALS

Wenn eine Funktion wirklich eine globale Variable verwenden muss, deklarierst du sie mit global oder gehst über das Array $GLOBALS, das jede globale Variable unter ihrem Namen enthält:

<?php
$visits = 0;
$siteName = "Bakery";

function countVisit()
{
    global $visits;      // now $visits refers to the global variable
    $visits++;
}

function title()
{
    return "Welcome to " . $GLOBALS['siteName'];
}

countVisit();
countVisit();
echo "Visits: $visits\n";
echo title(), "\n";

Globale Variablen machen Code schwerer nachvollziehbar, weil jede Funktion sie ändern kann. Sie tauchen in älterem Code und in WordPress-Plugins auf (global $wpdb;); in neuem Code übergibst du Werte oder verwendest eine Klasse.

static-Variablen behalten ihren Wert

Eine static-Variable in einer Funktion wird einmal erzeugt und behält ihren Wert zwischen den Aufrufen. Sie bleibt trotzdem lokal: Code außerhalb der Funktion sieht sie nicht.

<?php
function nextTicket(): int
{
    static $number = 100;   // runs only on the first call
    $number++;
    return $number;
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

function expensiveLookup(string $key): string
{
    static $cache = [];
    if (!isset($cache[$key])) {
        echo "(computing $key) ";
        $cache[$key] = strtoupper($key);
    }
    return $cache[$key];
}

echo expensiveLookup("php"), "\n";
echo expensiveLookup("php"), "\n";   // second call uses the cache

Variable Variablen ($$name)

$$name verwendet den Wert von $name als Namen einer anderen Variable. Das funktioniert, aber Arrays erledigen dieselbe Aufgabe fast immer klarer:

<?php
$field = "color";
$$field = "blue";        // creates $color
echo $color, "\n";

// The clearer way to have names chosen at runtime:
$settings = [];
$settings[$field] = "blue";
echo $settings["color"], "\n";

Kopie oder Referenz

Wenn du eine Variable einer anderen zuweist, wird der Wert kopiert, auch bei Arrays. Setze ein & davor, damit beide Namen stattdessen auf denselben Wert zeigen:

<?php
$a = [1, 2, 3];
$b = $a;          // copy
$b[] = 4;
echo "a has " . count($a) . ", b has " . count($b) . "\n";

$c = &$a;         // reference: $c and $a are the same array
$c[] = 99;
echo "a has " . count($a) . " after changing c\n";

function addBonus(int &$points)
{
    $points += 10;
}
$score = 5;
addBonus($score);
echo "Score: $score\n";

unset($b);
var_dump(isset($b));

Objekte verhalten sich anders: Eine Zuweisung kopiert einen Verweis auf dasselbe Objekt, also sind Änderungen über die eine Variable auch über die andere sichtbar. Für eine echte Kopie verwendest du clone.

Typischer Fehler: eine Variable, die in einem if oder einer Schleife gesetzt wird

PHP hat keinen Block-Scope, also existiert eine Variable, die in if, for oder foreach entsteht, auch danach noch. Das ist praktisch, versteckt aber einen Bug: Wenn der Block nicht läuft, wurde die Variable nie erzeugt.

<?php
$orders = [];   // try [120, 80] here

$message = "No orders yet";   // set a default before the loop
foreach ($orders as $amount) {
    $message = "Last order: $amount";
}
echo $message, "\n";

foreach ([1, 2, 3] as $n) {
    $last = $n;
}
echo "Still visible after the loop: $last\n";

Ohne die Zeile mit dem Standardwert würde ein leeres $orders die Variable $message undefiniert lassen und eine Warnung ausgeben. Gib jeder Variable einen Wert vor dem Block, der sie setzen könnte.