if Anweisung in PHP

Sie befinden sich: Home > Php > if Anweisung in PHP

Eine if-Anweisung ist eine sogenannte bedingte Anweisung die nur dann ausgeführt wird, wenn das Argument TRUE also wahr ist.

Die einfachste Form einer solchen Anweisung sieht folgendermaßen aus:

<?php
$var=1;
if($var==1){
/* wird nur ausgeführt wenn $var gleich 1 ist */
echo "der Ausdruck ist wahr";
}
?>

Das Sprachkonstrukt der if-Anweisung kann jedoch um zwei weitere Argumente erweitert werden, "else if(Argument oder Ausdruck )" und "else", wobei zu beachten ist das immer nur eine bedingte Anweisung pro Block ausgeführt wird.

<?php
$var=1;
if($var<0){
/* wird nicht ausgeführt da $var größer 0
 ist ein "if" darf nur einmal vorkommen */
echo "$var ist kleiner 0";
} else if($var>0){
/* dieser Ausdruck ist wahr, darum
 wird das nachfolgende "echo" ausgeführt
 "else if" Anweisungen können
 beliebig hinzugefügt werden */
echo "$var ist größer 0";
} else {
/* wird nur ausgeführt wenn alle vorangegangenen
 "else if" sowie das einleitende "if" als false
 ausgewertet wurden. "else" darf nur einmal vorkommen. */
echo "$var ist gleich 0";
}
?>

Ein Block aus if-Anweisungen muss prinzipiell mit einem "if()" eingeleitet werden, kann beliebig viele "else if()" Anweisungen beinhalten, sowie eine "else" Anweisung, welche aber ebenfalls nicht zwingend aufgeführt werden muss. Für die Argumente der "if-Anweisungen" werden in der Regel Vergleiche verwendet.

"a<b" a ist kleiner b
"a<=b" a ist kleiner gleich b
"a>b" a ist größer b
"a>=b" a ist größer gleich b
"a==b" a ist gleich b
"a===b" a ist gleich b und vom selben Typ
"a!=b" a ist ungleich b

Eine weitere wichtige Funktion innerhalb einer bedingten Abfrage sind logische Verknüpfungen zwischen den Ausdrücken. Hierzu verwendet man die logischen Operatoren && für UND sowie || für ODER.

"a<=b&&c>=b" nur wenn a kleiner gleich b ist wird der zweite Ausdruck in diesem Fall c größer gleich b überprüft und nur wenn beide Ausdrücke wahr sind wird die Anweisung ausgeführt.

"a>b||c>b" Wenn a größer b ODER c größer b ist, wird die Anweisung ausgeführt.
"a<=b||c>a&&b<c" Bei ODER genügt es, wenn einer der Ausdrücke wahr ist. Bei Kombinationen aus && und || ist auf die Priorität zu achten: && wird vor || ausgewertet.

Diese logischen Verknüpfungen machen einen Quellcode erheblich übersichtlicher, bergen aber auch ein erhöhtes Fehlerpotential. Das Gleiche gilt für ineinander geschachtelte if-Anweisungen wobei auf die schließenden Klammern zu achten ist, da fehlende oder falsch gesetzene Klammern zu schwer auffindbaren Fehlern führen können. PHP gibt in diesem Fall einen Parse Error aus.

Hier ein Beispiel einer ineinander geschachtelte if-Anweisungen:

<?php
if (Ausdruck 1){

  if (Ausdruck 2){

  } else if (Ausdruck 3 ){

  } else {

  }

} else if (Ausdruck 4 ){

  if (Ausdruck 5 ){

  } else {

  }
} else{

}

?>

Erklärung: Der PHP-Code besteht aus einer verschachtelten if-else-if-else-Anweisung, die dazu dient, verschiedene Bedingungen zu überprüfen und je nachdem, welche Bedingung erfüllt ist, unterschiedliche Aktionen auszuführen.

Zunächst wird der Ausdruck 1 überprüft. Wenn dieser Ausdruck wahr ist, also ein "true" zurückgibt, wird der darin enthaltene Codeblock ausgeführt. In diesem inneren Codeblock findet sich eine weitere if-else-if-else-Anweisung, die wiederum Ausdruck 2 und Ausdruck 3 überprüft. Sollte Ausdruck 2 wahr sein, wird der entsprechende Codeblock ausgeführt. Wenn nicht, wird geprüft, ob Ausdruck 3 wahr ist. Ist dies der Fall, wird der zugehörige Codeblock ausgeführt. Trifft keine der beiden Bedingungen zu, wird der Code im inneren else-Block ausgeführt.

Falls jedoch Ausdruck 1 falsch ist, also ein "false" zurückgibt, wird die nächste Bedingung, nämlich Ausdruck 4, überprüft. Wenn Ausdruck 4 wahr ist, wird ein weiterer innerer Codeblock betreten, der eine if-else-Anweisung enthält. Hier wird Ausdruck 5 überprüft. Ist dieser wahr, wird der zugehörige Codeblock ausgeführt. Andernfalls wird der Code im inneren else-Block ausgeführt.

Sollte jedoch auch Ausdruck 4 falsch sein, wird der äußerste else-Block betreten und der darin enthaltene Code ausgeführt. 

Zusammenfassend lässt sich sagen, dass der PHP-Code mehrere Bedingungen in einer hierarchischen Struktur überprüft, um je nach Ergebnis der Überprüfung unterschiedliche Aktionen durchzuführen. Durch die Verschachtelung der if-else-Anweisungen ist es möglich, komplexe logische Strukturen zu erstellen und den Code übersichtlich und verständlich zu gestalten. Es ist wichtig, die Bedingungen sorgfältig zu wählen, um sicherzustellen, dass der gewünschte Codeblock unter den entsprechenden Umständen ausgeführt wird. Eventuell könen Sie Ternäre Operatoren verwenden, um die Lesbarkeit des PHP-Codes zu verbessern.

Was sind Ternäre Operatoren in PHP?

Ternäre Operatoren sind eine verkürzte Schreibweise für if-else-Anweisungen in PHP. Sie ermöglichen es, Bedingungen auf eine kompakte Art und Weise zu überprüfen und bieten eine Alternative zur herkömmlichen if-else-Struktur. Ein Ternärer Operator besteht aus drei Teilen: einer Bedingung, einem Wert für den Fall, dass die Bedingung wahr ist, und einem Wert für den Fall, dass sie falsch ist.

Ein Beispiel für einen Ternären Operator in PHP ist:

<?php
$result = ($a < $b) ? 'a ist kleiner als b' : 'a ist größer oder gleich b';
                            

In diesem Beispiel wird die Bedingung $a < $b überprüft. Ist die Bedingung wahr, also $a tatsächlich kleiner als $b, wird der Wert 'a ist kleiner als b' der Variablen $result zugewiesen. Andernfalls, wenn die Bedingung falsch ist, wird der Wert 'a ist größer oder gleich b' der Variablen $result zugewiesen.

Ternäre Operatoren können die Lesbarkeit des Codes verbessern, insbesondere bei einfachen Bedingungen. Es ist jedoch wichtig, sie mit Bedacht einzusetzen, da eine übermäßige Verwendung von Ternären Operatoren den Code schwerer verständlich machen kann, insbesondere bei komplexeren Bedingungen.

Wie erhöhe ich die Lesbarkeit von verschachtelten if-else-Anweisung in PHP?

Um die Lesbarkeit von verschachtelten if-else-Anweisungen in PHP zu erhöhen, können folgende Tipps befolgt werden:

1. Einrückungen und Formatierung:
   Achten Sie darauf, den Code konsistent und ordentlich einzurücken, um die Verschachtelungsebenen leichter erkennen zu können. Ein gut formatierter Code ist einfacher zu lesen und zu verstehen.
   
   
2. Kommentare:
   Fügen Sie aussagekräftige Kommentare hinzu, um den Zweck der jeweiligen Bedingungen oder Codeblöcke zu erklären. Kommentare helfen anderen Entwicklern, den Code besser zu verstehen und zukünftige Änderungen vorzunehmen.
   
   
3. Kurze, prägnante Bedingungen:
   Versuchen Sie, die Bedingungen in den if-else-Anweisungen so einfach und verständlich wie möglich zu gestalten. Verwenden Sie gegebenenfalls Zwischenvariablen, um komplexe Bedingungen in einfachere Teile zu zerlegen.
   
   
4. Frühzeitige Rückkehr:
   Anstatt tief verschachtelte if-else-Anweisungen zu verwenden, können Sie in einigen Fällen die Lesbarkeit erhöhen, indem Sie eine frühzeitige Rückkehr verwenden. Wenn eine Bedingung erfüllt ist, geben Sie das Ergebnis sofort zurück und beenden Sie die Funktion. Dies reduziert die Anzahl der Verschachtelungsebenen.
   
   
5. Verwenden von switch-case:
   In einigen Situationen, in denen mehrere Bedingungen auf den gleichen Ausdruck geprüft werden, kann eine switch-case-Anweisung anstelle einer if-else-Anweisung verwendet werden. Dies kann die Lesbarkeit erhöhen, indem der Code besser strukturiert wird.
   
   
6. Funktionen und Methoden:
   Zerlegen Sie den Code in kleinere, wiederverwendbare Funktionen oder Methoden, um die Komplexität zu reduzieren. Jede Funktion oder Methode sollte eine klar definierte Aufgabe erfüllen. Dies erleichtert das Verständnis des Codes und ermöglicht eine bessere Wartung. Sie können mehr über das Erstellen einer eigenen Funktion in PHP erfahren.
   
   
7. Ternäre Operatoren: In einigen Fällen können ternäre Operatoren (auch bedingte Operatoren genannt) die Lesbarkeit erhöhen, indem sie kurze if-else-Anweisungen in einer einzigen Zeile zusammenfassen. Achten Sie jedoch darauf, dass dies bei komplexeren Bedingungen die Lesbarkeit verschlechtern kann.

Durch die Anwendung dieser Tipps und Techniken lässt sich die Lesbarkeit von verschachtelten if-else-Anweisungen in PHP verbessern und die Code-Wartung erleichtern.

Strict-Vergleich: === statt ==

Wenn Sie in PHP zwei Werte vergleichen, haben Sie grundsätzlich zwei Operatoren zur Auswahl. Der lockere Vergleich mit == wandelt die Datentypen vorher um, der strikte Vergleich mit === prüft Wert und Typ gleichzeitig. Genau diese kleine Unterscheidung sorgt bei Anfängern häufig für Stunden voller Fehlersuche, weil PHP sich mit Type Coercion gerne mal in die Irre führt.

Beispiel: derselbe Vergleich, zwei Ergebnisse

Stell sich vor, Sie lesen einen Wert aus einem Formular oder aus der Datenbank ein. Strings wie "0" werden bei einem lockeren Vergleich plötzlich zu false umgedeutet. Das folgende Snippet zeigt das Problem deutlich.

<?php
declare(strict_types=1);

$eingabe = '0';

if ($eingabe == false) {
    /* Bedingung trifft zu, weil "0" zu false wird */
    echo "lockerer Vergleich: leer
";
}

if ($eingabe === false) {
    /* Bedingung trifft NICHT zu, der String ist nicht false */
    echo "strikter Vergleich: leer
";
} else {
    echo "strikter Vergleich: Wert vorhanden
";
}
?>

Mein Tipp: Gewöhne sich an, fast immer mit === zu vergleichen. Den lockeren Operator brauchen Sie nur in seltenen Fällen, etwa bei numerischen Strings, von denen Sie genau weißt, was sie enthalten.

Truthy und Falsy: was wertet PHP als false?

Bevor Sie eine Bedingung schreiben, solltest Sie wissen, welche Werte PHP automatisch als unwahr betrachtet. In einer if-Anweisung wird nämlich nicht nur false selbst als unwahr gewertet, sondern eine ganze Reihe weiterer Werte. Genau hier passieren viele Bugs, die schwer zu finden sind.

Die Liste der falsy-Werte

Folgende Werte gelten in PHP als unwahr und führen dazu, dass der if-Block uebersprungen wird.

<?php
declare(strict_types=1);

$werte = [false, 0, 0.0, '', '0', null, []];

foreach ($werte as $wert) {
    if ($wert) {
        echo "wahr
";
    } else {
        /* Alle Werte oben landen hier */
        echo "unwahr
";
    }
}
?>

Besonders fies: Der String '0' wird als unwahr gewertet, der String 'false' dagegen als wahr. Wenn Sie also nur prüfen wollen, ob ein Wert wirklich gesetzen ist, nutze besser isset() oder einen strikten Vergleich.

Type-Coercion-Fallen vermeiden

PHP wandelt Datentypen bei == oft so um, wie Sie es nicht erwartest. Das gilt besonders, wenn Sie Strings mit Zahlen mischst oder Eingaben aus Formularen verarbeiten. Ein paar typische Stolperfallen solltest Sie im Hinterkopf haben.

<?php
declare(strict_types=1);

/* Klassiker: Leerstring ist gleich Null */
var_dump('' == 0);          /* bool(false) seit PHP 8, frueher true */

/* Numerische Strings werden gecastet */
var_dump('42abc' == 42);    /* bool(false) seit PHP 8, frueher true */

/* String "0" ist falsy, aber nicht leer */
var_dump('0' == false);     /* bool(true) */
var_dump('0' === false);    /* bool(false) */
?>

Seit PHP 8 sind viele dieser Vergleiche entschärft worden, doch älterer Code aus Tutorials oder Foren funktioniert oft anders. Wenn Sie sauber prüfen wollen, ob etwas leer ist, kombiniere empty() mit einer strikten Prüfung oder vergleiche sichekt mit einem konkreten Wert.

Null-Coalescing Operator ?? und ??=

Manchmal wollen Sie nur prüfen, ob eine Variable existiert oder einen Default-Wert setzen, falls sie null ist. Statt eine ganze if-Kaskade zu schreiben, gibt sich PHP dafür den Null-Coalescing Operator. Der Null-Coalescing Operator macht Ihren Code deutlich kompakter.

<?php
declare(strict_types=1);

/* Statt if-isset-else nur eine Zeile */
$name = $_GET['name'] ?? 'Gast';

/* Auch verkettbar */
$theme = $_COOKIE['theme'] ?? $_SESSION['theme'] ?? 'light';

/* Zuweisungs-Variante: setzt nur, wenn null oder nicht gesetzt */
$config = [];
$config['lang'] ??= 'de';
$config['lang'] ??= 'en'; /* hat keinen Effekt mehr */

echo $config['lang']; /* de */
?>

Wichtig zu wissen: ?? reagiert nur auf null oder nicht definierte Schlüssel, nicht auf leere Strings oder Nullen. Wenn Sie auch leere Werte abfangen wollen, brauchen Sie weiterhin eine klassische Bedingung oder den Ternary-Operator.

Ternary und Short-Ternary: kompakte Bedingungen

Für kurze, einzeilige Entscheidungen ist der Ternary-Operator perfekt. Sie sparen sich damit eine vollständige if-Anweisung und können sichekt einen Wert zuweisen oder zurückgeben. Sobald die Logik komplexer wird, solltest Sie jedoch wieder zur klassischen Form zurückkehren, sonst leidet die Lesbarkeit.

<?php
declare(strict_types=1);

$alter = 18;

/* Klassischer Ternary: Bedingung ? wennWahr : wennUnwahr */
$status = ($alter >= 18) ? 'volljaehrig' : 'minderjaehrig';

/* Short-Ternary: gibt linken Wert zurueck, wenn truthy */
$titel = $titel ?? '';
$angezeigt = $titel ?: 'Ohne Titel';

echo $status . "
";
echo $angezeigt . "
";
?>

Der Short-Ternary ?: ist eine nützliche Abkürzung, wenn Sie einen Default setzen wollen und der erste Wert nicht null, sondern auch ein Leerstring sein darf. Verschachtle Ternaries aber bitte nicht. Drei verschachtelte Operatoren sind das Maximum, danach bist Sie mit match oder mehreren if-Blöcken besser bedient.

Match-Ausdruck: die moderne Alternative

Wenn Sie eine if/elseif-Kaskade hast, die immer dieselbe Variable prüft, gibt es seit PHP 8 eine elegante Alternative. Der match-Ausdruck ist nicht nur kürzer, sondern arbeitet automatisch mit striktem Vergleich und liefert sichekt einen Wert zurück.

<?php
declare(strict_types=1);

$status = 'active';

/* Klassisch mit if/elseif */
if ($status === 'active') {
    $label = 'Aktiv';
} elseif ($status === 'inactive') {
    $label = 'Inaktiv';
} elseif ($status === 'pending') {
    $label = 'Wartend';
} else {
    $label = 'Unbekannt';
}

/* Modern mit match: kompakter und typsicher */
$label = match ($status) {
    'active'   => 'Aktiv',
    'inactive' => 'Inaktiv',
    'pending'  => 'Wartend',
    default    => 'Unbekannt',
};

echo $label;
?>

Beachte: match wirft eine UnhandledMatchError-Exception, wenn kein Zweig zutrifft und Sie keinen default definiert hast. Das ist ein Feature, kein Bug. Sie werden gezwungen, alle Fälle bewusst abzudecken. Genau das macht Ihren Code robuster.

Guard Clauses und Early Return

Tief verschachtelte if-Blöcke sind ein klassischer Code-Smell. Sobald Sie drei oder vier Ebenen tief in Einrückungen stecken, wird der Code unlesbar. Die Lösung heißt Guard Clauses: Sie prüfst zuerst alle Abbruch-Bedingungen, verlässt die Funktion früh und konzentrierst sich danach auf den eigentlichen Hauptpfad.

Vergleich: verschachtelt versus flach

Schauen Sie sich die beiden Varianten sichekt nebeneinander an. Die zweite Version lesen sich fast wie ein Roman von oben nach unten.

<?php
declare(strict_types=1);

/* Verschachtelt: schwer zu lesen */
function verarbeiteUserAlt(?array $user): string
{
    if ($user !== null) {
        if (isset($user['email'])) {
            if ($user['active'] === true) {
                return 'Mail an ' . $user['email'];
            } else {
                return 'User inaktiv';
            }
        } else {
            return 'Keine Mail';
        }
    } else {
        return 'Kein User';
    }
}

/* Mit Guard Clauses: linear und klar */
function verarbeiteUserNeu(?array $user): string
{
    if ($user === null) {
        return 'Kein User';
    }
    if (!isset($user['email'])) {
        return 'Keine Mail';
    }
    if ($user['active'] !== true) {
        return 'User inaktiv';
    }

    return 'Mail an ' . $user['email'];
}
?>

Die zweite Variante ist nicht nur kürzer, sondern macht auch klarer, welcher Fall der Happy Path ist. Genau das ist der Sinn von Guard Clauses: Fehler und Sonderfälle raus, danach in Ruhe die Hauptlogik.

Entscheidungsbaum als Diagramm

Damit Sie den Ablauf einer typischen if/elseif/else-Struktur visuell vor Augen hast, hier ein kleiner Entscheidungsbaum. Er zeigt, wie eine Bedingung Schritt für Schritt geprüft wird, bis ein Zweig greift.

flowchart TD
    A[Start: Alter pruefen] --> B{Alter >= 18?}
    B -->|ja| C[volljaehrig]
    B -->|nein| D{Alter >= 14?}
    D -->|ja| E[Jugendlicher]
    D -->|nein| F[Kind]
    C --> G[Ende]
    E --> G
    F --> G

Genau dieser Baum wird zu folgendem PHP-Code, der die drei Fälle der Reihe nach prüft. Sobald eine Bedingung zutrifft, werden die anderen Zweige automatisch übersprungen.

<?php
declare(strict_types=1);

$alter = 16;

if ($alter >= 18) {
    echo 'volljaehrig';
} elseif ($alter >= 14) {
    echo 'Jugendlicher';
} else {
    echo 'Kind';
}
?>

Spaceship-Operator <=> für Vergleichsfunktionen

Eine kleine Spezialität am Rand: Wenn Sie Vergleichsfunktionen für usort() schreiben, brauchen Sie als Rückgabewert eine negative Zahl, Null oder eine positive Zahl. Genau das liefert sich der Spaceship-Operator <=> in einem Schritt, ohne dass Sie selbst if-Verzweigungen schreiben müssen.

<?php
declare(strict_types=1);

$leute = [
    ['name' => 'Anna', 'alter' => 32],
    ['name' => 'Ben',  'alter' => 25],
    ['name' => 'Clea', 'alter' => 41],
];

/* Statt if-Kaskade einfach Spaceship-Operator */
usort($leute, function (array $a, array $b): int {
    return $a['alter'] <=> $b['alter'];
});

foreach ($leute as $person) {
    echo $person['name'] . ': ' . $person['alter'] . "
";
}
?>

Der Operator funktioniert mit Zahlen, Strings, Arrays und Objekten, die Stringable umsetzen. Sie sparen sich damit lästige if-Konstrukte und bekommen zugleich einen sauberen, vorhersagbaren Rückgabewert. Das ist ein guter Reflex: Wenn Sie in einer Vergleichsfunktion bist, denke zuerst an <=>.