PHP Variablen und ihre Verwendung

Sie befinden sich: Home > Php > PHP Variablen und ihre Verwendung

Variablen sind in PHP der Zwischenspeicher für alles, was sich im Lauf eines Skripts ändern kann: ein Name aus dem Formular, eine Zahl aus der Datenbank, eine Liste mit Einträgen. Wer Variablen wirklich versteht, hat ein gutes Drittel der Sprache schon im Griff. Auf dieser Seite gehen wir die Spielregeln durch, die Sie für den Alltag brauchen, schauen uns die Datentypen an, sehen wo eine Variable gültig ist und welche modernen Werkzeuge sich PHP heute an die Hand gibt.

Wie eine PHP-Variable aussieht

Jede Variable beginnt in PHP mit einem Dollarzeichen. Danach folgt ein Buchstabe oder ein Unterstrich, daran dürfen sich beliebig viele Buchstaben, Ziffern und Unterstriche anschließen. Eine Ziffer am Anfang funktioniert nicht und Groß- und Kleinschreibung wird unterschieden, also $name und $Name sind zwei verschiedene Variablen.

<?php
declare(strict_types=1);

$vorname = 'Tim';
$Vorname = 'Hans';

echo $vorname . ' ' . $Vorname; /* Ausgabe: Tim Hans */

/* $4you = 23; -> Fehler: darf nicht mit Ziffer beginnen */
$_4you = 23;     /* funktioniert */
$huschen = 23;   /* funktioniert */

PHP gehört zu den dynamisch typisierten Sprachen. Eine Variable kann zuerst eine Zahl enthalten, dann eine Zeichenkette, dann ein Array. Das ist bequem, kann aber auch zu schwer auffindbaren Fehlern führen. Mit declare(strict_types=1) am Dateianfang und Type Hints in Funktionen können Sie sich aber auch in PHP einen sehr genauen Typ-Vertrag bauen.

Die Datentypen im Überblick

PHP kennt eine Handvoll grundlegender Datentypen. Für den Alltag müssen Sie nur die ersten fünf wirklich kennen, alles andere kommt im Lauf der Zeit.

graph TD
    A[PHP-Datentypen] --> B[Skalar]
    A --> C[Zusammengesetzt]
    A --> D[Sonderfall]
    B --> B1[bool]
    B --> B2[int]
    B --> B3[float]
    B --> B4[string]
    C --> C1[array]
    C --> C2[object]
    D --> D1[null]
    D --> D2[resource]

bool trifft eine Wahr-oder-Falsch-Aussage. Werte: true oder false.
int ist eine Ganzzahl mit Vorzeichen, etwa 42 oder -7.
float ist eine Gleitkommazahl, also 3.14 oder -0.5.
string ist eine Zeichenkette, etwa 'PHP-Space'.
array ist eine geordnete Sammlung von Werten. Auf Arrays haben wir eine eigene Seite.
object ist eine Instanz einer Klasse, das Thema deckt unser Tutorial zu abstrakten Klassen ab.
null ist der spezielle „hat noch keinen Wert“-Zustand.
resource ist eine Referenz auf etwas Externes wie eine Datei. Seit PHP 8 verschwindet dieser Typ nach und nach, weil viele Funktionen jetzt eigene Klassen wie GdImage oder OpenSSLAsymmetricKey liefern.

Typumwandlung in der Praxis

Manchmal möchtest Sie den Typ eines Werts ausdrücklich umwandeln. PHP nennt das „Casting“ und lässt sich mit einer Klammer vor dem Wert erledigen. Mit var_dump() sehen Sie, was tatsächlich rauskommt.

<?php
$alsString = '42';

$alsInt   = (int) $alsString;       /* 42 */
$alsFloat = (float) '3.14abc';      /* 3.14, der Rest wird abgeschnitten */
$alsBool  = (bool) $alsString;      /* true, da nicht leer */
$alsArray = (array) 'wort';         /* ['wort'] */

var_dump($alsString); /* string(2) "42" */
var_dump($alsInt);    /* int(42) */
var_dump($alsFloat);  /* float(3.14) */
var_dump($alsBool);   /* bool(true) */
var_dump($alsArray);  /* array(1) { [0]=> string(4) "wort" } */

Für ein noch saubereres Casting bei Strings hilft intval(), das eine Basis (zehn, sechzehn) berücksichtigt.

Mathematische Operationen mit Variablen

Variablen sind natürlich nicht nur zum Speichern da, sondern auch zum Rechnen. PHP unterstützt alle gewohnten Operatoren plus die kompakten Kurzformen.

<?php
$a = 10;
$b = 11;

$a = $a * $b;   /* 110 */
echo $a, PHP_EOL;

$a++;            /* 111 */
echo $a, PHP_EOL;

$a--;            /* 110 */
echo $a, PHP_EOL;

/* Kurzformen */
$a += 5;         /* identisch zu $a = $a + 5 */
$a -= 2;         /* identisch zu $a = $a - 2 */
$a *= 2;         /* identisch zu $a = $a * 2 */
$a /= 4;         /* identisch zu $a = $a / 4 */
$a **= 2;        /* Potenz, seit PHP 5.6 */

Beim Mischen von Strings und Zahlen ist Vorsicht geboten: Mit declare(strict_types=1) und Type Hints in Funktionen vermeiden Sie, dass aus einer Zeichenkette stillschweigend eine Zahl wird und ein Bug erst Wochen später auffällt.

Variablentyp prüfen

Wenn Sie nicht sicher bist, was in einer Variable steckt, fragen Sie PHP einfach. Es gibt eine ganze Familie von is_*-Funktionen, jede prüft auf einen bestimmten Typ und gibt true oder false zurück.

is_array() – Variable ist ein Array.
is_bool() – Variable ist ein Wahrheitswert.
is_float() – Variable ist eine Gleitkommazahl.
is_int() – Variable ist eine Ganzzahl.
is_null() – Variable ist null.
is_numeric() – Variable ist eine Zahl oder ein numerischer String.
is_object() – Variable ist ein Objekt.
is_string() – Variable ist eine Zeichenkette.

Was Sie nicht mehr verwenden solltest

Drei alte Aliasse hängen aus historischen Gründen noch in der Sprache, sind aber als deprecated markiert oder bereits entfernt. Halten Sie sich von ihnen fern und nutze die Hauptnamen:

is_double() — Alias von is_float(). Verwenden Sie is_float().
is_real() — Alias von is_float(), mit PHP 8.0 entfernt.
is_long() — Alias von is_int(). Verwenden Sie is_int().
is_integer() — Alias von is_int(). Funktioniert noch, aber bleib bei is_int().

Gültigkeitsbereiche von Variablen

Wo eine Variable lebt, hängt davon ab, wo Sie sie definieren. PHP unterscheidet vier wichtige Bereiche:

graph TD
    A[Skript-Scope] --> B[Funktions-Scope]
    A --> C[Klassen-Scope]
    B --> D[Static-Variable]
    A --> E[Superglobals]
    E --> F[$_GET]
    E --> G[$_POST]
    E --> H[$_SESSION]
    E --> I[$GLOBALS]

Lokale Variablen leben nur innerhalb der Funktion oder Methode, in der sie definiert wurden.
Globale Variablen sind im Hauptskript verfügbar, aber nicht automatisch in Funktionen sichtbar.
Statische Variablen behalten ihren Wert über mehrere Funktionsaufrufe hinweg.
Superglobals wie $_GET, $_POST oder $GLOBALS sind überall sichtbar, brauchen kein global-Schlüsselwort.

<?php
declare(strict_types=1);

$global_var = 'Ich bin global';

function test(): void
{
    $local_var = 'Ich bin lokal';

    /* Globale Variable bekannt machen */
    global $global_var;
    echo $global_var, PHP_EOL;
    echo $local_var, PHP_EOL;

    /* Statische Variable: bleibt bei jedem Aufruf erhalten */
    static $count = 0;
    $count++;
    echo "Aufruf Nummer: $count", PHP_EOL;
}

test();
test();
/* echo $local_var; -> Fehler: $local_var existiert hier nicht */

/* Alternativer Zugriff auf Globals */
echo $GLOBALS['global_var'];

Im modernen Code wird das global-Schlüsselwort meist vermieden. Gebraucht wird es eigentlich nur in Legacy-Projekten. In neuem Code übergibt man Werte als Funktionsparameter oder kapselt sie in Klassen.

Mehrere Werte: das Array

Sobald mehr als ein Wert zusammengehört, kommt das Array ins Spiel. PHP-Arrays sind ein Schweizer Taschenmesser, weil sie sowohl numerisch als auch assoziativ funktionieren. Auf unserer Array-Seite finden Sie alle Details.

<?php
declare(strict_types=1);

/* Modern, kurze Schreibweise (seit PHP 5.4) */
$fruechte = [
    'fruechte' => ['a' => 'orange', 'b' => 'banane', 'c' => 'apfel'],
    'nummern'  => [1, 2, 3, 4, 5, 6],
    'var'      => ['erstes', 5 => 'zweites', 'drittes'],
];

echo $fruechte['fruechte']['b'];   /* banane */
echo $fruechte['nummern'][0];      /* 1, da Index bei 0 startet */
echo $fruechte['var'][6];          /* drittes */

Wichtig zu wissen: Numerische Indizes starten in PHP standardmäßig bei 0. Ein Array mit zehn Einträgen geht also von Index 0 bis 9. Wer das vergisst, sucht im Bug-Hunting oft lange nach dem Off-by-one-Fehler.

Modern arbeiten: Type Declarations

PHP ist seit Version 7 schrittweise typsicherer geworden. Wer heute neuen Code schreibt, sollte das nutzen. Mit Type Hints bei Parametern und Rückgabewerten und Typed Properties in Klassen verschiebt sich ein großer Teil möglicher Bugs vom Laufzeit-Verhalten in die statische Analyse.

<?php
declare(strict_types=1);

class Benutzer
{
    public function __construct(
        public readonly string $name,
        public readonly int $alter,
        public readonly ?string $email = null,
    ) {
    }

    public function istVolljaehrig(): bool
    {
        return $this->alter >= 18;
    }
}

$u = new Benutzer(name: 'Mira', alter: 19, email: 'mira@example.com');
echo $u->name;            /* Mira */
echo $u->istVolljaehrig() ? 'ja' : 'nein';

Vier Dinge passieren hier auf einmal: Constructor Promotion spart Boilerplate, readonly verhindert nachträgliche Änderungen, der Nullable-Parameter ?string erlaubt explizit null, und Named Arguments machen den Aufruf lesbar.

Welche Themen jetzt sinnvoll sind

Variablen sind das Fundament. Damit Sie daraus echte Programme bauen, fehlen noch ein paar Bausteine. Diese Reihenfolge bietet sich als Lernpfad an:

Mit echo und print Inhalte ausgeben.
Mit der if-Anweisung auf Werte reagieren.
Mit Schleifen wie for, while und foreach wiederkehrende Aufgaben automatisieren.
Eigene Funktionen schreiben.
Mit Arrays mehrere Werte verwalten.
Daten aus Formularen entgegennehmen.
Sich an PDO und Prepared Statements wagen.

Für Spezialthemen lohnt sich auch ein Blick auf das Tutorial zu dynamischen Variablen oder zu serialize() und unserialize(), wenn Sie Variablen-Inhalte persistent speichern wollen.

weiter zum nächsten Kapitel: PHP echo und print: Text und Variablen ausgeben