Websiteentwicklung: PHP: Operatoren

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Websiteentwicklung PHP Operatoren

Übersicht[Bearbeiten]

Die folgende Tabelle zeigt die Rangfolge der Operatoren und die Richtung in der sie ausgewertet werden. Oben steht der Operator mit dem höchsten Rang.

von Operator
keine Richtung new
rechts [
rechts ! ~ ++ -- (int) (float) (string) (array) (object) @
links * / %
links + - .
links << >>
keine Richtung < <= > >=
keine Richtung == != === !==
links &
links ^
links |
links &&
links ||
links ? :
rechts = ^= <<= >>=
rechts print
links and
links xor
links or
links ,

Arithmetische Operatoren[Bearbeiten]

Arithmetische Operatoren sind Rechenoperatoren. Rechenzeichen sind Pluszeichen (+) für die Addition, Minuszeichen (-) für die Subtraktion, ein Stern (*) für die Multiplikation, ein Schrägstrich (/) für die Division und ein Prozentzeichen (%) für die Modulo-Operation (Rest einer Division).

Beispiele: Variablen[Bearbeiten]

Zuerst das Rechnen mit zwei Variablen:

<?php
$zahl1 = 20;
$zahl2 = 5;
$summe     = $zahl1 + $zahl2; // Ergebnis: 25
$differenz = $zahl1 - $zahl2; // Ergebnis: 15
$produkt   = $zahl1 * $zahl2; // Ergebnis: 100
$quotient  = $zahl1 / $zahl2; // Ergebnis: 4
$rest      = $zahl1 % $zahl2; // Ergebnis: 0
?>

Beispiele: Variablen und Zahlen[Bearbeiten]

Jetzt das Rechnen mit einer Variable und einer Zahl

<?php
$zahl1 = 20;
$summe     = $zahl1 + 2; // Ergebnis: 22
$differenz = $zahl1 - 2; // Ergebnis: 18
$produkt   = $zahl1 * 2; // Ergebnis: 40
$quotient  = $zahl1 / 2; // Ergebnis: 10
$rest      = $zahl1 % 2; // Ergebnis: 0
?>

Beispiele: Zahlen[Bearbeiten]

Und schließlich das Rechnen nur mit Zahlen:

<?php
$summe     = 20 + 8; // Ergebnis: 28
$differenz = 20 - 8; // Ergebnis: 12
$produkt   = 20 * 8; // Ergebnis: 160
$quotient  = 20 / 8; // Ergebnis: 2.5
$rest      = 20 % 8; // Ergebnis: 4
?>

Zuweisungsoperatoren[Bearbeiten]

Der einfachste Zuweisungsoperator ist "=". Er weist der Variablen auf seiner linken Seite den Ausdruck auf seiner rechten Seite zu.

<?php
$a = 5;
$b = $a;
echo $b; // Ausgabe: 5
?>

Zu beachten ist, dass auf der linken Seite eine Variable stehen muss. Eine Zuweisung wie

$b = $a = 5;

ist absolut gültig, sie wird von rechts nach links ausgewertet. $a erhält also den Wert 5 und dann erst $b. Eine Zuweisung wie

$b = 1 + $a = 5;

ist dagegen ungültig. Eine korrekte Schreibweise wäre hingegen:

$b = 1 + ($a = 5);

Nach dieser Anweisung enthält $a den Wert 5 und $b den Wert 6.

Neben dem einfachen Zuweisungsoperator gibt es einige "kombinierte Operatoren":

<?php
$a = 5;
$b = 20;

$b += $a;  // Gleichbedeutend mit $b = $b + $a;  Ergebnis: 25
$b -= $a;  // Gleichbedeutend mit $b = $b - $a;  Ergebnis: 15
$b *= $a;  // Gleichbedeutend mit $b = $b * $a;  Ergebnis: 100
$b /= $a;  // Gleichbedeutend mit $b = $b / $a;  Ergebnis: 4
$b %= $a;  // Gleichbedeutend mit $b = $b % $a;  Ergebnis: 0
$b .= $a;  // Gleichbedeutend mit $b = $b . $a;  Ergebnis: 205
$b &= $a;  // Gleichbedeutend mit $b = $b & $a;  Ergebnis: 4
$b |= $a;  // Gleichbedeutend mit $b = $b | $a;  Ergebnis: 21
$b ^= $a;  // Gleichbedeutend mit $b = $b ^ $a;  Ergebnis: 17
$b <<= $a; // Gleichbedeutend mit $b = $b << $a; Ergebnis: 640
$b >>= $a; // Gleichbedeutend mit $b = $b >> $a; Ergebnis: 0
?>

Inkrement- und Dekrementoperatoren[Bearbeiten]

Beispiel Name Auswirkung
++$a Prä-Inkrement Erhöht den Wert von $a um eins (inkrementiert $a) und gibt anschließend den neuen Wert von $a zurück.
$a++ Post-Inkrement Gibt zuerst den aktuellen Wert von $a zurück und erhöht dann den Wert von $a um eins.
--$a Prä-Dekrement Vermindert den Wert von $a um eins (dekrementiert $a) und gibt anschließend den neuen Wert von $a zurück.
$a-- Post-Dekrement Gibt zuerst den aktuellen Wert von $a zurück und erniedrigt dann den Wert von $a um eins.
Beispiel
$a = 25;
echo ++$a; // Ausgabe: 26, $a == 26
echo $a++; // Ausgabe: 26, $a == 27
echo $a--; // Ausgabe: 27, $a == 26
echo --$a; // Ausgabe: 25, $a == 25

Bit-Operatoren[Bearbeiten]

Bit-Operatoren verändern die einzelnen Bits einer Variablen. Sie lassen sich wie arithmetische Operatoren auf jeden Ausdruck anwenden. Man kann also auch 34 >> 3 schreiben, anstatt die Werte vorher einer Variable zuzuweisen. Jede Ganzzahl stellt sich für den Rechner als Binärzahl dar. So wird beispielsweise 66 durch 1000010 repräsentiert.

Der Bit-Operator & (und) setzt alle Bits, die in $a und $b gesetzt sind.

<?php
$a = 45;      //               00101101
$b = 205;     //               11001101
$c = $a & $b; // Ergebnis: 13; 00001101
?>

Der Bit-Operator | (oder) setzt alle Bits, die in $a oder $b gesetzt sind.

<?php
$a = 45;      //                00101101
$b = 205;     //                11001101
$c = $a | $b; // Ergebnis: 237; 11101101
?>

Der Bit-Operator ^ (exklusiv oder) setzt alle Bits, die in $a oder $b, aber nicht in beiden gesetzt sind.

<?php
$a = 45;      //                00101101
$b = 205;     //                11001101
$c = $a ^ $b; // Ergebnis: 224; 11100000
?>

Der Bit-Operator ~ (nicht) setzt alle Bits, die nicht gesetzt sind, und löscht alle Bits, die gesetzt sind.

<?php
$a = 205; //               11001101
$b = ~$a; // Ergebnis: 50; 00110010
?>

Der Bit-Operator << (nach links verschieben) verschiebt alle Bits seines linken Operanden um die im rechten angegebene Zahl nach links.

<?php
$a = 13;      //               00001101
$b = $a << 2; // Ergebnis: 52; 00110100
?>

Der Bit-Operator >> (nach rechts verschieben) verschiebt alle Bits seines linken Operanden um die im rechten angegebene Zahl nach rechts.

<?php
$a = 13;      //              00001101
$b = $a >> 2; // Ergebnis: 3; 00000011
?>

Bit-Operatoren als Flags[Bearbeiten]

Eine praktische Anwendung von Bit-Operatoren ist die Verwendung als Flags, etwa in einem Rechtesystem:

Beispiel
<?php

$verfassen    = 1; // 00000001
$editieren    = 2; // 00000010
$freischalten = 4; // 00000100
$loeschen     = 8; // 00001000

$gast_rechte = $verfassen; // 00000001
$benutzer_rechte = $gast_rechte | $editieren; // 00000011
$moderator_rechte = $benutzer_rechte | $freischalten; // 00000111
$admin_rechte = $moderator_rechte | $loeschen; // 00001111

echo 'Ein Gast darf Beiträge verfassen: ';
echo $gast_rechte & $verfassen;

echo '<br />';

echo 'Ein Moderator darf Beiträge löschen: ';
echo $moderator_rechte & $loeschen;
?>
Ausgabe
Ein Gast darf Beiträge verfassen: 1
Ein Moderator darf Beiträge löschen: 0

Zu Beachten ist, dass Flags der gleichen Gruppe (hier: die einzelnen Rechte), bedingt durch das Binärsystem, voneinander verschiedene Potenzen der Zahl 2 sein müssen.

Vergleichs-Operatoren[Bearbeiten]

Die Vergleichs-Operatoren geben eine Booleanschen Ausdruck (true oder false) zurück. Sie lassen sich auf jeden Ausdruck anwenden.

Operator Bedeutung Ergebniss
$a == $b Gleich Gibt true zurück, wenn $a gleich $b ist.
echo (325.0 == 325); // wahr - Anzeige ist "1"
$a === $b Identisch Gibt true zurück, wenn $a gleich $b ist und beide vom gleichen Typ sind (nur ab PHP 4).
echo (325.0 === 325); // falsch - Anzeige ist leer
$a != $b Ungleich Gibt true zurück, wenn $a nicht gleich $b ist.
$a <> $b Ungleich Gibt true zurück, wenn $a nicht gleich $b ist.
$a !== $b Nicht identisch Gibt true zurück, wenn $a nicht gleich $b ist, oder wenn beide nicht vom gleichen Typ sind (nur ab PHP 4).
$a < $b Kleiner Als Gibt true zurück, wenn $a kleiner als $b ist.
$a > $b Größer Als Gibt true zurück, wenn $a größer als $b ist.
$a <= $b Kleiner Gleich Gibt true zurück, wenn $a kleiner oder gleich $b ist.
$a >= $b Größer Gleich Gibt true zurück, wenn $a größer oder gleich $b ist.

Logische Operatoren[Bearbeiten]

Beispiel Name Auswirkung
$a and $b Log. UND TRUE wenn sowohl $a als auch $b TRUE ist.
$a or $b Log. ODER TRUE wenn $a oder $b TRUE ist.
$a xor $b Exklusives Log. ODER TRUE wenn entweder $a oder $b TRUE ist, aber nicht beide.
! $a Log. NICHT TRUE wenn $a nicht TRUE ist.
$a && $b Speziell TRUE wenn sowohl $a als auch $b TRUE ist. $b wird nur überprüft falls $a true war.
$a || $b Speziell TRUE wenn $a oder $b TRUE ist. $b wird nur überprüft falls $a false war.

Array-Operatoren[Bearbeiten]

Das Pluszeichen (+) reduziert zwei oder mehrere Arrays auf ein einziges. Dabei erhält das neue Array alle Werte mit entsprechender Zugehörigkeit zum jeweiligen Schlüssel/Index. Falls die ursprünglichen Arrays unterschiedliche Werte zu einem Schlüssel aufweisen, so erhält dieser Schlüssel des neuen Arrays den Wert des zuerst angegebenen Arrays.

Beispiele
$array1 = array('Schluessel1' => 'Wert1');
$array2 = array('Schluessel2' => 'Wert2');
$array3 = $array1 + $array2;
//$array3 = array('Schluessel1' => 'Wert1', 'Schluessel2' => 'Wert2');

Die Arrays werden zu einem Array zusammengefasst

$array1 = array('Schluessel' => 'Wert1');
$array2 = array('Schluessel' => 'Wert2');
$array3 = $array1 + $array2;
//$array3 = array('Schluessel' => 'Wert1');

Der unterschiedlich belegte Schlüssel "Schluessel" erhält den Wert des zuerst angegebenen Arrays $array1

Der Zeichenketten-Operator .[Bearbeiten]

Der Zeichenketten-Operator ist der Punkt (.), er liefert als Ergebnis eine Zeichenkette die sich aus seinem linken und seinem rechten Argument zusammensetzt.

Beispiele
$a = "Ich bin eine";
$b = "zusammengesetzte Zeichenkette";
echo $a." ".$b.chr(10); // chr(10) ist ein Zeilenumbruch
$a = 20;
$b = 5;
echo $a.$b.chr(10);
$a = "Zeichenkette ";
$b = 5;
echo $a.$b;
Ausgabe
Ich bin eine zusammengesetzte Zeichenkette
205
Zeichenkette 5

Der Auswahl-Operator ?:[Bearbeiten]

Dieser besondere Operator ist gewissermaßen eine verkürzte Version von if-else. Er wird ternärer Operator genannt.

Syntax
$ergebnis = (boolwert) ? bei_true : bei_false ;

boolwert kann jeder Booleansche Ausdruck sein, ergibt die Auswertung true wird bei_true zurückgegeben, andernfalls bei_false.

Beispiel
echo "Die größere Zahl wird zuerst ausgeben:\n";
$a = 6;
$b = 30;
echo "\$a == $a und \$b == $b\n";
echo ($a > $b ? $a.chr(10).$b : $b.chr(10).$a).chr(10);
$a = 41;
$b = 22;
echo "\$a == $a und \$b == $b\n";
echo ($a > $b ? $a.chr(10).$b : $b.chr(10).$a).chr(10);
Ausgabe
Die größere Zahl wird zuerst ausgeben:
$a == 6 und $b == 30
30
6
$a == 41 und $b == 22
41
22

Der Fehler-Kontroll-Operator @[Bearbeiten]

Wird einem Funktionsaufruf oder einer Variable der @-Operator vorangestellt, unterdrückt dies die von PHP generierten Fehlermeldungen. In Kombination mit dem or-Operator und der Funktion die() lassen sich so eigene Fehlermeldungen generieren.

Anwendungsbeispiel[Bearbeiten]

Die Funktion mysql_connect() stellt eine Verbindung zu einem Datenbankserver her. Falls die Verbindung fehlschlägt, liefert die Funktion false zurück und gibt eine PHP-Fehlermeldung aus (durch @ unterdrückt). Der Operator wertet seinen rechten Ausdruck nur aus, wenn der linke false ergab (die() wird also nur dann ausgeführt). Die Funktion die() bricht schließlich das Script ab und gibt den an sie übergebenen Text aus.

$dz=@mysql_connect('localhost','Benutzer','Passwort') or
    die('Es konnte keine Verbindung zum Datenbankserver hergestellt werden!');
Wikibooks buchseite.svg Zurück zu Arrays | One wikibook.svg Hoch zu PHP | Wikibooks buchseite.svg Vor zu Kontrollstrukturen