PHP Operatoren Übersicht

Thema in Kurzform

• Operatoren werden in der Programmierung genutzt, um einzelne Operanden miteinander zu verrechnen oder zu vergleichen.
• Außerdem gibt es logische Operatoren, die auf kombinierte boolesche Ausdrücke angewandt werden und prüfen, ob der Gesamtausdruck true oder false ist.

Inhaltsverzeichnis

1. Zuweisungsoperator
2. Operatoren für die Grundrechenarten
3. Modulo und Potenz
4. Der Verkettungsoperator
5. Kombinierte Operatoren
6. Inkrement und Dekrement-Operatoren
7. Vergleichsoperatoren
8. Logische Operatoren

Zuweisungsoperator

Den ersten Operator, nämlich den einfachen Zuweisungsoperator ( = ) haben wir bereits kennengelernt.

Das = Zeichen muss hier von demjenigen aus der Mathematik unterschieden werden. Denn in der Mathematik drückt das Zeichen = ein „ist gleich“-Verhältnis aus. So bedeutet etwa 7+3 = 10, dass die linke und rechte Seite den gleichen Wert haben.

In der Programmierung ist das grundlegend anders. Hier nämlich ist das = Zeichen der Zuweisungsoperator, das heißt, dass dem Operand links vom = Zeichen der Wert der rechten Seite zugewiesen wird. Zum Beispiel:

$variable1 = 100;
$variable2 = 200;
$variable1 = $variable2; // 200

Wir haben in jeder Zeile eine Zuweisung: Zunächst werden in Zeile 1 und 2 den Variablen $variable1 und $variable2 die Werte 100 bzw. 200 zugewiesen. Anschließend erfolgt in Zeile 3 abermals eine Zuweisung, indem $variable2 $variable1 zugewiesen wird. Damit erhält $variable1 denselben Wert wie $variable2 (beide 200).

Operatoren für die vier Grundrechenarten

Wir kennen diese (hoffentlich!) bereits seit der Grundschule und sie sollten uns keine größeren Schwierigkeiten bereiten:

• Addition +
• Subtraktion -
• Multiplikation *
• Division /

Wir verechnen im folgenden Beispiel die Werte zweier Variablen gemäß den vier Grundrechenarten miteinander und speichern die Ergebnisse in jeweils neuen Variablen:

$zahl1 = 13;
$zahl2 = 4;

$addition = $zahl1 + $zahl2; // 17
$subtr = $zahl1 - $zahl2; // 9
$multi = $zahl1 * $zahl2; // 52
$div = $zahl1 / $zahl2; // 3.25

Modulo und Potenz

Daneben gibt es zwei weitere Operatoren, die wir nicht ganz so häufig benötigen, die aber dennoch sehr wichtig sind:

• Modulo: %
• Potenz: **

Der Modulo-Operator wird verwendet, um den Rest einer Division zu ermitteln. So ist das Ergebnis von 10 % 6 (gelesen: "10 Modulo 6") 4, denn 10 geteilt durch 6 ist 1, Rest: 4. Der Potenz-Operator funktioniert, indem wir zwei Sternchen zwischen die Basis und die Potenzzahl setzen. 5 hoch 2 wird in PHP also mit 5 ** 2 ausgedrückt.

Sehen wir uns zu den beiden Operatoren jeweils ein weiteres Beispiel an:

$zahl1 = 13;
$zahl2 = 4;

// Modulo:
$mod = $zahl1 % $zahl2; // 1

// Potenz:
$pot = $zahl1 ** $zahl2; // 28561

Der Verkettungsoperator

Um zwei Strings miteinander zu verbinden, können wir als Verkettungsoperator den Punkt ( . ) einsetzen. So verbinden wir beispielsweise den String "Hallo" mit "Welt!" zu "HalloWelt!". Wenn wir beide Wörter auch noch, wie es sich gehört, mit einem Leerzeichen trennen wollen, also "Hallo Welt!", verketten wir dazwischen einfach nochmal mit einem Leerzeichen " ":

$wort1 = "Hallo";
$wort2 = "Welt";
$verkettung = $wort1 . " " . $wort2;
echo $verkettung; //Bildschirmausgabe "Hallo Welt!"

Kombinierte Operatoren

Wir denken uns folgende Situation: Wir möchten den Wert einer Variable vom Datentyp Integer um, sagen wir... 5 erhöhen. Wir können dann standardmäßig so vorgehen:

$zahl = 3;
$zahl = $zahl + 5;

Wir haben hier der Variablen $zahl einen neuen Wert zugewiesen und zwar 8. Dies ergibt sich aus der Addition des alten Werts von $zahl (also 3) mit dem Wert 5. Anschließend folgt die Zuweisung von 8 an die Variable.

Kann man so machen. Es geht aber auch eleganter und kürzer, nämlich so:

$zahl = 3;
$zahl += 5; // 8

Wir erledigen exakt dasselbe wie mit $zahl = $zahl + 5, nur dass wir uns Schreibarbeit sparen. Wir lassen die zu verändernde Variable auf der rechten Seite einfach weg und schreiben stattdessen den gewünschten Operator (in diesem Fall +) vor den Zuweisungsoperator. Das läuft mit den anderen Operatoren genauso:

$subtraktion = 10;
$multiplikation = 2;
$division = 21;
$modulo = 13;
$potenz = 3;
$verkettung = "Hallo ";

//kombinierte Operatoren:
$subtraktion -= 4; // 6
$multiplikation *= 10; // 40
$division /= 3; // 7
$modulo %= 10; // 3
$potenz **= 2; // 9
$verkettung .= "Welt!"; // "Hallo Welt!"

Inkrement und Dekrement-Operatoren

Zwei noch, dann sind wir durch! Angenommen, wir möchten den Wert einer Variablen vom Typ Integer (Ganzzahl) um exakt den Wert von 1 erhöhen oder verringern. Wir könnten dies, das wissen Sie, so lösen:

$zahl = 1;
$zahl = $zahl + 1; // 2
$zahl = $zahl - 1; // 1

Oder kürzer, indem wir den kombinierten Operator für Addition bzw. Subtraktion verwenden:

$zahl = 1;
$zahl += 1; // 2
$zahl -= 1; // 1

"Noch kürzer geht nicht", sagen Sie? Dann sollten Sie schnellstens Bekanntschaft mit den Inkrement- und Dekrement-Operatoren machen:

$zahl = 1;
$zahl++ ; // 2
$zahl-- ; // 1

Da das Hoch- bzw. Runterzählen um jeweils den Wert von 1 in der Programmierung so häufig vorkommt, wurden die beiden Operatoren ++ bzw. -- geschaffen. Sie werden uns in vielen Programmierprojekten äußerst hilfreich sein und die Arbeit erleichtern. Sie sollten sich die beiden merken!

Vergleichsoperatoren

Die Vergleichsoperatoren vergleichen zwei Operanden miteinander und liefern als Ergebnis einen booleschen Wert (true oder false) zurück. Diese Operatoren werden sehr häufig in if-else-Kontrollstrukturen und Schleifen eingesetzt.

Die Operatoren in ein paar Beispielen:

$a = 5;
$b = 10;

echo $a > $b;
echo $a < $b;  // 1 (true)
echo $a >= $b;
echo $a <= $b; // 1 (true)
echo $a == $b;
echo $a != $b; // 1 (true)

In diesen Beispielen haben wir arithmetische Werte miteinander vergleichen. Häufig werden aber auch booleschen Werte gegenübergestellt. Ein Vergleich zweier Booleans läuft natürlich nur mit den beiden Operatoren == und !=. Ein kleines Beispiel:

$a = true;
$b = false;

echo $a == $b;
echo $a != $b; // 1 (true)

Logische Operatoren

Die logischen Operatoren, wie wir sie in der Tabelle sehen, werden auf boolesche Ausdrücke angewandt.

Wir erzeugen zum Testen zunächst einige Variablen mit booleschen Werten und benutzen dann nacheinander die Operatoren &&, || und !. Dabei platzieren wir die Operatoren, wie gewohnt, zwischen jeweils zwei Variablen (die Operanden). Hier der Code:

$b1 = true;
$b2 = false;

echo $b1 && $b2;
echo $b1 || $b2; // 1 (true)
echo !$b2;

Wie wir sehen ergibt $b1 && $b2 false, da nicht beide Operanden true sind.

$b1 || $b2 dagegen ergibt true (und damit wird 1 am Bildschirm angezeigt), denn einer der beiden Operanden ist true.

!$b1 ergibt true (also 1 auf dem Bildschirm), da der ursprüngliche Wert von $b2 (false) zu true umgekehrt wird.