Hi,
heut geht's ab! Ich zeig' dir, wie du Abfragen erstellst und Vergleiche vornehmen kannst. Außerdem lernst du ein paar neue, praktische Funktionen kennen. Kontrollstrukturen bringen wieder etliche zusätzliche Möglichkeiten, um spannende Webanwendungen zu schreiben. Gehen wir's an!
<h2>Kontrollstrukturen</h2>
Das Wort "Kontrollstrukturen" klingt, wenn man sich so wie du bisher nichts darunter vorstellen kann, ziemlich behindert. Hä, Kontrollstrukturen, was für Shit? Doch dahinter verbirgt sich wieder ein Schlüsselkonzept der Programmierung - Kontrollstrukturen gibt es in jeder Programmiersprache und sie sind essentiell, um den Programmfluss zu steuern. So richtig Bewegung und Logik kommt nämlich erst hiermit in deine Programme rein.
Kontrollstrukturen sind ein Sprachkonstrukt, mit dem wir Aktionen ausführen können aufgrund von Bedingungen die erfüllt oder nicht erfüllt wurden. Ein Ausdruck wird ausgewertet zu einem (boolschen) Wahrheitswert. Den Datentyp "Boolean" hast du im Artikel mit den Variablen und Datentypen schon kennen gelernt, damals konnten wir damit aber noch nicht viel tun - das ändert sich ab heute!
Ausdruck wird zu einem Wahrheitswert ausgewertet? Wat? Nun, jede Art von Prüfung oder Vergleich wird im Endeffekt ausgewertet zu true oder false. true bedeutet soviel wie "trifft zu" und false dann logischerweise "trifft nicht zu". So wie man eine Frage mit Ja (true) oder Nein (false) beantworten kann oder -bleiben wir technisch- wie ein Zustand nur 0 oder 1 sein kann. In der Programmierung geht's präzise zu, da gibt's kein "Vielleicht". Ein Ausdruck ist entweder wahr oder falsch.
Eine recht simple Sache im Grunde, du wirst sehen. Man könnte zum Beispiel prüfen, ob der vom Benutzer eingegebene Text ein Zahlenwert ist (Integer oder Float). Und falls ja, wird irgendeine Aktion ausgeführt. Falls nicht, kann alternativ eine andere Aktion ausgeführt werden, wie zum Beispiel die Ausgabe des Textes "Bitte gib einen Zahlenwert ein und versuche es erneut.". Im Endeffekt beschreibe ich gerade die Funktionalität, die uns im vorherigen Artikel bei den Formularen noch gefehlt hat.
Jetzt stellt sich die Frage, was wir alles prüfen und vergleichen können - und vor allem wie. Und genau hierfür gibt es die sogenannten ...
<h2>Vergleichsoperatoren</h2>
Und was sind "Vergleichsoperatoren"? Na eigentlich müsstest du es schon selber wissen, ist Mathe-Stoff aus der 1. Klasse. Wir können Werte miteinander vergleichen, zum Beispiel, ob ein Text gleich einem anderen Text ist (beisp. bei einer Passwortabfrage, da muss die Eingabe mit dem festgelegten Kennwort übereinstimmen - das wäre ein Text-Vergleich) oder ob eine Zahl gleich / ungleich / größer / kleiner ist wie eine andere Zahl.
Stell dir vor du willst prüfen, ob die Zahl 4 größer ist als 9 (also wenn 4 > 9 ). Dieser Ausdruck würde zu false ausgewertet werden, ist also nicht wahr, denn 4 ist nicht größer sondern kleiner als 9.
Meist werden wir nicht mit Zahlen direkt zu tun haben, sondern mit Variablen oder Arrays, die Zahlen als Werte enthalten.
<h3>Welche Vergleichsoperatoren gibt es?</h3>
Einige, und die meisten kennst du sicher aus der Schule. Ich verwende die Variablen $a und $b. Die Werte darfst du dir in Gedanken hinein interpretieren. Eine kurze Tabelle, welches es gibt (oder in einer schönen Übersicht hier). Wenn du dir denkst "ohje der Shit sieht kompliziert aus", kein Problem, überspringe das und lies ab dem nächsten Absatz weiter.
<ul> <li><span style="font-family: courier new,courier,monospace;"><strong>$a == $b</strong></span> Ergibt true, wenn $a gleich $b ist. Beispiele: (1 == 2 ) ergibt false (4 == 4) ergibt true ("3" == 3) ergibt true (obwohl die erste 3 vom Typ String ist) (5.0 == 5) ergibt true</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a === $b</strong></span> Ergibt true, wenn $a gleich $b ist und beide vom gleichen Datentyp sind. Beispiele: (2 === 3) ergibt false (2 === 2) ergibt true ("2" === 2) ergibt false (2.0 === 2) ergibt false</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a != $b</strong></span> Ergibt true, wenn $a nicht gleich $b ist. Beispiele: (2 != 3) ergibt true (weil 2 ja tatsächlich <strong>nicht</strong> 3 ist) (4 != 4) ergibt false</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a <> $b</strong></span> Das gleiche wie mit "!=" nur eben eine andere Schreibweise.</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a !== $b</strong></span> Ergibt true, wenn $a nicht gleich $b ist oder wenn beide nicht vom gleichen Typ sind. Beispiele: ("2" !== 2) ergibt true (2 !== 2) ergibt true ("2" !== 3) ergibt true (2 !== 2) ergibt false (weil ja beide Werte gleich und beide vom gleich Typ sind)</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a > $b</strong></span> Ergibt true, wenn <span style="font-family: courier new,courier,monospace;">$a</span> gröÃer $b ist. Beispiele: (4 > 2) ergibt true (2 > 4) ergibt false</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a < $b</strong></span> Ergibt true, wenn $a kleiner $b ist. Beispiele: (4 < 2) ergibt false (2 < 4) ergibt true</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a >= $b</strong></span> Ergibt true, wenn <span style="font-family: courier new,courier,monospace;">$a</span> gröÃer oder gleich <span style="font-family: courier new,courier,monospace;">$b</span> ist. Beispiele: (4 >= 3) ergibt true (4 >= 4) ergibt true (4 >= 5) ergibt false</li> <li><span style="font-family: courier new,courier,monospace;"><strong>$a <= $b</strong></span> Ergibt true, wenn <span style="font-family: courier new,courier,monospace;">$a</span> kleiner oder gleich <span style="font-family: courier new,courier,monospace;">$b</span> ist. Beispiele: (4 <= 3) ergibt false (4 <= 4) ergibt true (4 <= 5) ergibt true</li> </ul>
<h3>Wichtig: Unterscheidung von Vergleich und Zuweisung</h3>
Wie Variablen oder Arrays deklariert werden weißt du bereits: die Zuweisung des Wertes wird nach dem Ist-Gleich-Zeichen vorgenommen, also quasi $Variable = "Wert"; . Bei einem Vergleich hingegen arbeitet man mit zwei Ist-Gleich-Zeichen. Wenn ich prüfen will, ob $a gleich $b ist, würde ich das mit $a == $b ausdrücken.
Das heißt es kann dir am Anfang passieren, dass du für einen Vergleich nur ein = Zeichen schreibst - somit also eine Zuweisung vornimmst anstatt zwei Variablen zu vergleichen. Trotzdem wird der Code ausgeführt. Warum ist das so? Nun, weil die Zuweisung sofern sie erfolgreich war, ebenfalls true ergibt. Behalte das also als möglichen Leichtsinnsfehler im Hinterkopf.
<h2>Praxiseinsatz von Kontrollstrukturen mit PHP</h2>
Kontrollstrukturen schreibt man in PHP mit if( Bedingung ){ ... } , in Klammern kommt die Abfrage oder der Vergleich. Anschließend definiert man mit den geschweiften Klammern den sog. Anweisungsblock. Dort wird also der Code reingeschrieben der ausgeführt werden soll, wenn die Prüfung erfolgreich war (wenn die Bedingung true ergibt).
Sehen wir uns ein Code-Beispiel hierzu an:
<pre class="lang:php decode:true"><?php $zahl = 5; if( $zahl == 5 ) { echo 'Bedingung ergibt true, weil $zahl gleich 5 ist'; } ?></pre>
Und im Regelfall wird man auch noch festlegen wollen, was andernfalls passiert. Dazu hängt man an die schließende geschweifte Klammer noch ein else und öffnet einen neuen Anweisungsblock:
<pre class="lang:php decode:true"><?php $zahl = 5; if( $zahl == 5 ) { echo 'Bedingung ergibt true, weil $zahl gleich 5 ist'; } else { echo 'Bedingung ergibt false, weil $zahl nicht gleich 5 ist'; } ?></pre>
<h2>Beispiele mit weiteren Vergleichen</h2>
<h3>Weitere Zahlen-Vergleiche</h3>
Schauen wir uns andere mathematische Vergleichsoperatoren an:
<pre class="lang:default decode:true "><?php $zahl = 5; # GröÃer oder gleich if( $zahl >= 4 ) { # $zahl ist gröÃer oder gleich 4 (trifft zu) } else { # $zahl ist nicht gröÃer oder gleich 4 } # Kleiner oder gleich if( $zahl <= 4 ) { # $zahl ist kleiner oder gleich 4 } else { # $zahl ist nicht kleiner oder gleich 4 (trifft zu) } # Nicht gleich (ungleich) # Statt != klappt auch <> als Operator if( $zahl != 4 ) { # $zahl ist nicht 4 (trifft zu) } else { # $zahl ist gleich 4 } ?></pre>
Text-Operatoren
Das ganze funktioniert mit Zahlen oder auch mit Text:
<pre class="lang:default decode:true "><?php $text = "Hallo Welt"; # Vergleicht 2 Texte if( $text == "Bla bla bla" ) { # Das trifft offensichtlich nicht zu } else { # Der Code hier wird ausgeführt } # Checken wir den ersten Buchstaben eines Textes if( substr($text, 0, 1) == "H" ) { # Stimmt, der erste Buchstabe von $text ist ein "H" } ?></pre>
Die Funktion substr holt aus einem String einen gewünschten Teil raus, in dem Fall aus der Variable $text ab dem nullten (0) Index des Strings 1 Zeichen.
<h3>Wichtig ist ... !</h3>
... dass du dir merkst, dass wir bei Kontrollstrukturen immer eine Bedingung auf ihren Wahrheitsgehalt hin prüfen, und der kann nur WAHR oder FALSCH sein (eben true oder false). Dabei ist es ganz egal, welche Datentypen, Variablen oder Arrays wir in welcher Art und Weise vergleichen möchten, es kann immer nur true oder false dabei raus kommen. Daher empfehle ich dir, die Bedingungen mit if in Gedanken etwas anders zu formulieren. Statt "Wenn zahl ist gleich 4 ist" denkst du dir "Wenn (zahl ist gleich 4) WAHR ist". Wenn du so rum denkst, fällt es dir in Zukunft leichter, davon bin ich überzeugt.
<h3>Beispiel mit Benutzereingaben</h3>
Im vorherigen Artikel hatten wir mit HTML-Formularen und Benutzereingaben zu tun. Damit wir hier gleich dynamisch entwickeln können, basteln wir uns auch in dieses Beispiel ein Formular. Erstmal nur ein Textfeld.
Diesmal möchte ich keine separate Datei, an die die Formulardaten gesendet werden. Im Artikel zuvor haben wir dafür ja eine ziel.php festgelegt. Die fällt jetzt weg, und deswegen ebenso auch das action Attribut im form-Tag (Zeile 29). Damit wird beim Absenden des Formulars die aktuelle Datei aufgerufen. Daher will ich dir den ersten praktischen Einsatz von Kontrollstrukturen dabei demonstrieren, wie wir prüfen ob ein Formular abgesendet wurde. Los geht's:
<pre class="lang:php decode:true"><?php # Die beiden Zeilen hier zum Aktivieren der Fehlerausgabe # wie ich dir ja bereits gezeigt hab ini_set('display_errors', 1); error_reporting(E_ALL); ?> <!DOCTYPE html> <html lang='de'> <head> <meta charset='utf-8'> <title>Test mit Kontrollstrukturen</title> <style type='text/css'> * { font-family: "verdana"; font-size: 11pt; } input, button { padding: 8px; } </style> </head> <body> <strong>Bitte gib eine Zahl ein:</strong><br> <form method='POST'> <p><input type='text' name='text' placeholder='z.B. "8"'></p> <p> <button type='submit' name='formular_abgesendet'>Absenden</button> </p> </form> <?php /** * Hier ist der PHP-Teil, der NACH dem Absenden * des Formulars ausgeführt wird. */ if( isset($_POST['formular_abgesendet']) ) { echo "<br><hr><br>"; echo "<p>Du hast das Formular abgesendet - gut gemacht :)</p>"; echo "<p>Deine Eingabe lautet: <span style='background-color: #eeeeee; padding: 2px;'>" . $_POST['text'] . "</span>"; } ?> </body> </html></pre>
Ne ganze Menge Zeug. Lass uns mal durchgehen:
<ul> <li>Oben wird zuallererst die Fehlerausgabe aktiviert - kennst du, passt.</li> <li>Unten basteln wir wieder ein HTML-Formular: - Ein Textfeld - Ein Submit-Button Der Submit-Button hat diesmal ein name-Attribut. Das nehmen wir nachher in PHP zur Ãberprüfung her.</li> <li>Unter dem Formular noch ein weitere PHP-Block:</li> <li>Wir verwenden die Funktion<a href="http://php.net/manual/en/function.isset.php"> isset()</a> - die ist neu für dich. isset() erwartet eine Variable als Argument und prüft damit, ob die übergebene Variable deklariert wurde und nicht NULL ist (zu dieser NULL Geschichte kommen wir später noch). Wenn man -so wie wir- prüfen will, ob in einem Array ein bestimmtes Element vorhanden ist, übergibt man das Array mit Angabe des Index. Klar, das $_POST Array ist immer verfügbar und somit bereits deklariert, aber es enthält ja nur Elemente wenn auch ein Formular mit POST übermittelt wurde.</li> <li>Mit <span style="font-family: courier new,courier,monospace;">if</span> wird abgefragt, ob im <span style="font-family: courier new,courier,monospace;">$_POST</span> Array ein Wert unter dem assoziativen Index <span style="font-family: courier new,courier,monospace;">formular_abgesendet</span> existiert. Falls ja, erfolgt eine Ausgabe. Deswegen steht dort beim ersten Aufruf deines Skripts auch erstmal nix unter dem Formular, erst nach dem Absenden.</li> </ul>
Ok ganz toll, aber so wirklich anfangen kann man damit noch nix. Wird Zeit dass wir was sinnvolles anstellen. Platzieren wir also in der Form 2 Textfelder für ein ...
<h3>Formular zum Addieren von Zahlen</h3>
Zuerst bauen wir uns also noch ein zusätzliches Textfeld dazu. Nach dem Absenden des Formulars soll mit PHP geprüft werden, ob das Formular abgesendet wurde. Anschließend nehmen wir die zwei Benutzereingaben und konvertieren sie mittels der von PHP zur Verfügung gestellten Funktion floatval in den Datentyp float (du weißt schon, eine Dezimalzahl mit Nachkommastellen, wir wollen ja nicht nur ganze Zahlen addieren können). Die Konvertierung ist praktisch, denn wenn wir Text statt Zahlen eingeben (z.B. "Test") wird durch die logischerweise fehlgeschlagene konvertierung der Wert auf 0 gesetzt. Checken wir das:
<pre class="lang:default decode:true "><?php # Die beiden Zeilen hier zum Aktivieren der Fehlerausgabe # wie ich dir ja bereits gezeigt hab ini_set('display_errors', 1); error_reporting(E_ALL); ?> <!DOCTYPE html> <html lang='de'> <head> <meta charset='utf-8'> <title>Test mit Kontrollstrukturen</title> <style type='text/css'> * { font-family: "verdana"; font-size: 11pt; } input, button { padding: 8px; } </style> </head> <body> <strong>Bitte gib zwei Zahlen ein:</strong><br> <form method='POST'> <p><input type='text' name='zahl1' placeholder='Zahl 1'></p> <p><input type='text' name='zahl2' placeholder='Zahl 2'></p> <p> <button type='submit' name='formular_abgesendet'>Absenden</button> </p> </form> <?php /** * Hier ist der PHP-Teil, der NACH dem Absenden * des Formulars ausgeführt wird. */ if( isset($_POST['formular_abgesendet']) ) { echo "<br><hr><br>"; # Zahlen aus dem $_POST Array holen und zu float konvertieren $zahl1 = floatval($_POST['zahl1']); $zahl2 = floatval($_POST['zahl2']); # Ergebnis berechnen $ergebnis = $zahl1 + $zahl2; # Ausgabe echo $zahl1 . " + " . $zahl2 . " = " . $ergebnis; } ?> </body> </html></pre>
Cooler shit, funktioniert doch schon ganz toll. Und wenn du Text statt Zahlen eingibst, wird einfach zu 0 konvertiert.
Es gibt eine Besonderheit dir ich dir anhand eines Beispiels zeigen will. Führe den Code bei dir aus und trage im Formular ins erste Textfeld "2x" ein und im zweiten Textfeld "x2". Klicke danach auf "Absenden". Was kommt dabei raus? Genau, folgende Ausgabe solltest du sehen:
2 + 0 = 2
Waaaaaas? Das macht doch gar keinen Sinn! Doch, weil nämlich die Funktion floatval (genau genommen generell die Konvertierung von Strings zu Zahlen) einfach im Text beginnende Zeichen die Zahlen sind mitnimmt und den Rest ab dem ersten Wert der keine Zahl ist wegschneidet. So wird aus "2x" dann "2" und aus "x2" wird "0".
<h3>Brutto / Netto Rechner</h3>
Ein weiteres Beispiel um aus einem Preis den Brutto oder Netto Wert zu berechnen. Dazu nehmen wir wieder ein Textfeld und 2 Submit-Buttons. Mit einem wollen wir den Netto Betrag errechnen, d.h. es wird davon ausgegangen dass vom Benutzer ein Brutto-Preis eingegeben wurde. Und mit dem anderen möchten wir den Brutto Betrag berechnen (in der Annahme dass der Benutzer einen Netto Betrag eingegeben hat).
Wichtig zu wissen ist dabei, dass im Formular nur der Submit-Button im $_POST Array übergeben wird, der angeklickt wurde. Schauen wir uns das an:
<pre class="lang:default decode:true"><?php # Die beiden Zeilen hier zum Aktivieren der Fehlerausgabe # wie ich dir ja bereits gezeigt hab ini_set('display_errors', 1); error_reporting(E_ALL); ?> <!DOCTYPE html> <html lang='de'> <head> <meta charset='utf-8'> <title>Test mit Kontrollstrukturen</title> <style type='text/css'> * { font-family: "verdana"; font-size: 11pt; } input, button { padding: 8px; } </style> </head> <body> <strong>Bitte gib zwei Zahlen ein:</strong><br> <form method='POST'> <p><input type='text' name='betrag' placeholder='Betrag'></p> <p> <button type='submit' name='berechne_netto'>Netto berechnen</button> </p> <p> <button type='submit' name='berechne_brutto'>Brutto berechnen</button> </p> </form> <?php /** * Hier ist der PHP-Teil, der NACH dem Absenden * des Formulars ausgeführt wird. */ echo "<br><hr><br>"; # Brutto zu Netto if( isset($_POST['berechne_netto']) ) { # Benutzereingabe aus $_POST holen und zu float konvertieren $Brutto = floatval($_POST['betrag']); # Berechnung durchführen $Netto = $Brutto / 119 * 100; # Ausgabe echo $Brutto . " - 19% MwSt. = " . $Netto . " &euro;"; } # Netto zu Brutto if( isset($_POST['berechne_brutto']) ) { # Benutzereingabe aus $_POST holen und zu float konvertieren $Netto = floatval($_POST['betrag']); # Berechnung durchführen $Brutto = $Netto / 100 * 119; # Ausgabe echo $Netto . " + 19% MwSt. = " . $Brutto . " &euro;"; } ?> </body> </html></pre>
Wenn du Kommazahlen eingeben willst, vergiss nicht, dass die dann nach der englischen Schreibweise angegeben werden müssen, das heißt 12.5 anstatt 12,5 (also mit Punkt als Dezimaltrennzeichen).
Gut, das funktioniert ja schon sehr schön, allerdings haben wir nicht spezifiziert, bis auf wieviele Stellen gerundet werden soll. Dafür gibt's die coole Funktion number_format, die nicht nur dafür sorgt dass das Ergebnis gerundet wird sondern auch, dass wir die Zahl in deutschem Format ausgeben können. Schreibe den Code in den beiden Kontrollstrukturen also geringfügig um:
<pre class="lang:default decode:true "><?php # Brutto zu Netto if( isset($_POST['berechne_netto']) ) { # Benutzereingabe aus $_POST holen und zu float konvertieren $Brutto = floatval($_POST['betrag']); # Berechnung durchführen $Netto = $Brutto / 119 * 100; # Zahl schön formatieren $Netto = number_format($Netto, 2, ',', '.'); # Ausgabe echo $Brutto . " - 19% MwSt. = " . $Netto . " &euro;"; } # Netto zu Brutto if( isset($_POST['berechne_brutto']) ) { # Benutzereingabe aus $_POST holen und zu float konvertieren $Netto = floatval($_POST['betrag']); # Berechnung durchführen $Brutto = $Netto / 100 * 119; # Zahl schön formatieren $Brutto = number_format($Brutto, 2, ',', '.'); # Ausgabe echo $Netto . " + 19% MwSt. = " . $Brutto . " &euro;"; } ?></pre>
Wir übergeben an number_format die zu formatierende Zahl, die Anzahl an Nachkommastellen, das Trennzeichen für Nachkommastellen und das Tausender-Trennzeichen. Exakt in der Reihenfolge.
<h3>Verschachtelte WENN-DANN Bedingungen</h3>
Hier hab ich einen neuen Code vorbereitet, in dem wir uns verschachtelte Bedingungen ansehen können. Wir möchten, dass der Benutzer einen Wert in das Textfeld eingibt, mit folgenden Bedingungen:
<ol> <li>Der Wert muss eine gültige, ganze Zahl sein (keine Kommazahl)</li> <li>Die Zahl muss kleiner als 100 sein</li> <li>Die Zahl muss ohne Rest durch 2 teilbar sein</li> </ol>
So funktioniert's:
<pre class="lang:default decode:true"><?php # Die beiden Zeilen hier zum Aktivieren der Fehlerausgabe # wie ich dir ja bereits gezeigt hab ini_set('display_errors', 1); error_reporting(E_ALL); ?> <!DOCTYPE html> <html lang='de'> <head> <meta charset='utf-8'> <title>Test mit Kontrollstrukturen</title> <style type='text/css'> * { font-family: "verdana"; font-size: 11pt; } input, button { padding: 8px; } </style> </head> <body> <strong>Bitte gib eine <u>ganze Zahl</u> ein, die <u>kleiner als 100</u> und ohne Rest <u>durch 2 teilbar</u> ist:</strong><br> <form method='POST'> <p><input type='text' name='zahl' placeholder='Eingabe ...'></p> <p> <button type='submit' name='submit'>Absenden</button> </p> </form> <?php /** * Hier ist der PHP-Teil, der NACH dem Absenden * des Formulars ausgeführt wird. */ echo "<br><hr><br>"; # Prüfen ob das Formular abgesendet wurde if( isset($_POST['submit']) ) { # Benutzereingabe in Variable speichern $Eingabe = $_POST['zahl']; # Prüfen, ob die Eingabe eine ganze Zahl ist if(is_numeric($Eingabe)){ # An dieser Stelle ist schonmal klar, dass wir # nur Zahlen als Eingabe erhalten haben. # $Eingabe zu Integer konvertieren $Eingabe = intval($Eingabe); # Prüfen, ob die Zahl kleiner als 100 ist if($Eingabe < 100){ # Perfekt, die Zahl ist kleiner als 100. # Prüfen, ob die Zahl durch 2 teilbar ist if($Eingabe % 2 == 0){ # Perfekt, alles wurde geprüft und ist erfolgreich echo "Super, alles richtig gemacht!<br>"; echo $Eingabe . " &div; 2 = " . ($Eingabe / 2); }else{ echo "Die Zahl ist nicht durch 2 teilbar!"; } }else{ echo "Die Zahl muss <strong>kleiner</strong> als 100 sein!"; } }else{ echo "Der eingegebene Wert ist keine ganze Zahl!"; } } ?> </body> </html></pre>
Das ist doch schon ganz schön viel Code. Gehen wir das in Ruhe durch um in Erfahrung zu bringen, was dort passiert:
<ol> <li>Wir haben wieder ein Formular mit einem Eingabefeld ("zahl") und einem Absenden-Button ("submit").</li> <li>Nach dem Absenden wird geprüft, ob das Formular abgesendet wurde. Wie immer mit <span style="font-family: courier new,courier,monospace;">isset</span>.</li> <li>Wir speichern die Eingabe des Benutzers in die Variable <span style="font-family: courier new,courier,monospace;">$Eingabe</span>.</li> <li>Es wird mit der Funktion <a href="http://php.net/manual/en/function.is-numeric.php">is_numeric</a> geprüft, ob die Variable <span style="font-family: courier new,courier,monospace;">$Eingabe</span> nur aus Zahlen besteht.</li> <li>Danach konvertieren wir die Eingabe zum Datentyp Integer. Warum? Theoretisch können wir Text der nur aus Zahlen besteht auch addieren, das wäre logisch gesehen aber unsauber und falsch. Wenn wir mathematische Berechnungen durchführen, sollten wir mit Integer oder Float arbeiten.</li> <li>Danach wird geprüft, ob die Zahl jetzt kleiner als 100 ist.</li> <li>Jetzt kommt was neues: der Modulus-Operator (kurze <a href="http://php.net/manual/de/language.operators.arithmetic.php">Ãbersicht</a>) der durch ein <span class="lang:default highlight:0 decode:true crayon-inline ">%</span> Prozent-Zeichen dargestellt wird, berechnet den Rest einer Division. Wenn eine Zahl geteilt wird und ein Rest bleibt (9 / 4 = 2 Rest 1), kann man den mit dem Modulus Operator ermitteln (somit also 9 % 4 = 1). Damit checken wir also, ob die Benutzereingabe geteilt durch 2 einen Rest von 0 hat.</li> <li>Wenn alles erfolgreich war, wird eine Meldung ausgegeben (und wenn man was falsch gemacht hat auch schon vorher, damit man als Benutzer ein Feedback bekommt).</li> </ol>
Und schon ist das alles gar nicht mehr so kompliziert. Deutlich gemacht wurde hier die Anwendung von verschachtelten Bedingungen. Nach und nach prüfen wir verschiedene Fällt und können mit jedem Schritt sicherer sein, dass die Benutzereingabe dem gewünschten Format entspricht. Wie du siehst mussten wir oben zuerst sicherstellen, dass die Eingabe nur aus Zahlen besteht, erst danach konvertieren wir die Eingabe in den Datentyp Integer.
<h3>Fallstrick is_numeric</h3>
Lass mich dich noch kurz darauf hinweisen, dass die Funktion is_numeric eine Variable darauf prüft, ob sie nur Zahlen enthält (im Erfolgsfall wird true zurückgegeben, die Bedingung ist WAHR). Für den Fall also eine super Funktion, weil wir eine Ganzzahl erwarten. Würden wir im Beispiel auch Kommazahlen zulassen, wäre die Funktion jedoch nicht hilfreich, denn Kommazahlen enthalten nicht nur Zahlen sondern eben auch den Punkt bzw. das Komma als Dezimaltrennzeichen. Hierfür würden wir uns dann einer anderen Vorgehensweise bedienen:
<pre class="lang:default decode:true"><?php if( floatval($Eingabe) > 0 ) { /* Eingabe ist eine gültige Ganzzahl (oder Kommazahl) und gröÃer als 0 */ } ?></pre>
Was noch viel wichtiger ist, und behalte das immer im Kopf, für jedes Problem gibt es in 99,99% der Fälle mehrere Lösungen. Merk dir das immer.
<h3>Multiple Bedingungen</h3>
Bisher konnten wir mit dem if ... else Konstrukt eigentlich immer nur 2 Fälle prüfen. Im if-Anweisungsblock wird der Code ausgeführt wenn die Bedingung zutrifft (true), im else Block wird der Code ausgeführt, falls die Bedingung nicht zutrifft (false). PHP kennt darauf aufbauend ein weiteres Sprachkonstrukt das mit elseif geschrieben wird, und das ist dazu da, um mehr Fälle zu behandeln. Aber schauen wir uns das einfach an:
<pre class="lang:default decode:true "><?php # Stellen wir uns an der Stelle vor, dass der Wert # eine Benutzereingabe darstellt. $Wert = "Test Test Test"; if( $Wert == "Test" ) { /* Du hast Test eingegeben */ } elseif( $Wert == "abc" ) { /* Du hast abc eingegeben */ } elseif( strlen($Wert) >= 5 ) { /* Deine Eingabe ist 5 oder mehr Zeichen lang */ } elseif( substr($Wert, 0, 1) == "T" ) { /* Der erste Buchstabe deiner Eingabe ist "T" */ } else { /* Irgendetwas anderes trifft zu */ } ?></pre>
Krass oder? Wir können so mehrere Bedingungen prüfen und auf sie reagieren. Und in jedem Anweisungsblock können wir natürlich weitere, verschachtelte Bedingungen erstellen, wenn wir das möchten.
Noch ein Hinweis zum elseif - das kannst du wenn du möchtest auch in zwei Wörtern schreiben, also elseif oder auch else if .
<h3>Ausdruck negieren</h3>
Wir können die Ausdrücke (ob wir es Bedingungen oder Ausdrücke nennen, darfst du dir aussuchen) auch ins negative umkehren. Klar, wenn eine gewünschte Bedingung nicht zutrifft, können wir den Code dafür auch in den else-Block schreiben. Aber es wird auch sehr viele Fälle geben, bei denen es gewünscht ist, dass die Bedingung FALSCH ist - das können wir formulieren als "WENN (Bedingung ist WAHR) FALSCH ist" oder "WENN (Bedingung ist FALSCH) WAHR ist". Oben habe ich dir die Vergleichsoperatoren vorgestellt. Mit != prüfen wir auf "ist nicht gleich" bzw "ist ungleich". Wir können aber auch einen geklammerten Ausdruck mit vorangestelltem Ausrufezeichen ins Gegenteil umkehren.
Ich zeige dir das anhand eines Beispielt in dem wir möchten, dass Variable $Wert nicht komplett aus Zahlen besteht. Das können wir auf zweierlei Arten prüfen:
<pre class="lang:default decode:true"><?php $Wert = "Test"; # Wir möchten, dass die Eingabe nicht ausschlieÃlich Zahlen enthält. if( is_numeric($Wert) == false ) { /* Gut, Wert besteht nicht nur aus Zahlen */ } # Alternative Schreibweise: if( !is_numeric($Wert) ) { /* Gut, Wert besteht nicht nur aus Zahlen */ } ?></pre>
Die Funktion is_numeric ergibt wie schon gesagt true, wenn die übergebene Variable nur Zahlen enthält. In beiden Fällen nehmen wir also den Rückgabewert von is_numeric entgegen (was true oder false sein kann) und checken, ob wir false bekommen, was dann auf die Bedingung bezogen wieder true ergibt. Als Programmierer formuliert man sich das im Kopf als "WENN (BEDINGUNG ist FALSCH) WAHR ist". Ich glaub ein Praxisbeispiel klärt hier wieder viele Fragen:
<pre class="lang:default decode:true"><?php var_dump(true); echo "<br>"; var_dump(false); echo "<br>"; var_dump(!true); echo "<br>"; var_dump(!false); echo "<br>"; echo "<br>"; var_dump(is_numeric("abc")); echo "<br>"; # Interessant ist das hier ... var_dump(is_numeric("abc") == false); echo "<br>"; # ... und das hier var_dump(!is_numeric("abc")); echo "<br>"; var_dump(is_numeric("123")); echo "<br>"; var_dump(is_numeric("123") == false); echo "<br>"; ?></pre>
Die Ausgabe des Codes ist folgende:
<pre class="lang:default highlight:0 decode:true">bool(true) bool(false) bool(false) bool(true) bool(false) bool(true) bool(true) bool(true) bool(false) </pre>
Am interessantesten ist der 6. und 7. var_dump (steht auch in den Kommentaren wo es interessant wird). Eine Prüfung mit is_numeric auf den Wert "abc" gibt natürlich false zurück, effektiv erfolgt hier also die Abfrage, ob false gleich false ist - was true ergibt. Ebenso wie !false auch true ergibt (nicht-false = true). Soweit verstanden? Probier einfach ein bisschen rum - du lernst nur was, wenn du selbst Code schreibst, nur so kannst du Dinge 100%ig verstehen.
<h3>Logische Operatoren ...</h3>
... sind ziemlich geiles Zeug, wenn wir schon mit if-Anweisungen arbeiten können. Damit können wir mehrere Ausdrücke logisch verketten mit UND, ODER und ENTWEDER-ODER.
<ul> <li>UND (Operator <span style="font-family: courier new,courier,monospace;">&&</span> oder <span style="font-family: courier new,courier,monospace;">AND</span>) Es müssen zwei (oder mehr) Bedingungen WAHR sein.</li> <li>ODER (Operator <span style="font-family: courier new,courier,monospace;">||</span> oder <span style="font-family: courier new,courier,monospace;">OR</span>) Es muss mindestens eine Bedingung WAHR sein (eine oder mehrere).</li> <li>ENTWEDER-ODER (Operator <span style="font-family: courier new,courier,monospace;">XOR</span>) Es darf nur die eine oder andere Bedingung WAHR sein, aber nicht beide zugleich. Man nennt den Operator auch <em>Exklusiv-Oder</em>. Wahnsinn was es alles für Begriffe gibt, oder?</li> </ul>
Ein kurzer Überblick:
<pre class="lang:default decode:true "><?php /** * UND Operator */ echo "UND Operator<br>"; var_dump(true && true); echo "<br>"; var_dump(true && false); echo "<br>"; var_dump(false && false); echo "<br><br>"; /** * ODER Operator */ echo "ODER Operator<br>"; var_dump(true || true); echo "<br>"; var_dump(true || false); echo "<br>"; var_dump(false || false); echo "<br><br>"; /** * ENTWEDER-ODER Operator */ echo "ENTWEDER-ODER Operator<br>"; var_dump(true XOR true); echo "<br>"; var_dump(true XOR false); echo "<br>"; var_dump(false XOR false); ?></pre>
Die Ausgabe dazu:
<pre class="lang:default highlight:0 decode:true ">UND Operator bool(true) bool(false) bool(false) ODER Operator bool(true) bool(true) bool(false) ENTWEDER-ODER Operator bool(false) bool(true) bool(false)</pre>
Sinn macht das, wenn wir z.B. prüfen wollen, ob eine Zahl größer als 50 UND kleiner als 100 ist. Man kann das entweder in zwei verschachtelten Abfragen machen (wie du es schon kennengelernt hast) oder durch die Verknüpfung von Bedingungen mit logischen Operatoren. Ein Beispiel mit beiden Möglichkeiten:
<pre class="lang:default decode:true "><?php $Zahl = 60; # Möglichkeit #1 if($Zahl > 50){ if($Zahl < 100){ /* Perfekt */ } } # Möglichkeit 2 if($Zahl > 50 && $Zahl < 100){ /* Perfekt */ } ?></pre>
Bei Möglichkeit #1 prüfen wir zuerst einen Fall, wenn der zutrifft den nächsten Fall. Bei Möglichkeit #2 prüfen wir gleich, ob beide Bedingungen true ergeben.
Möglichkeit #1 hat hier den "Vorteil", dass man, wenn nur die erste Bedingung erfolgreich ist, dort noch zusätzliche Anweisungen ausführen kann. Das heißt wir könnten prüfen ob die Zahl größer als 50 ist und falls ja vor oder nach der zweiten Prüfung noch beliebigen Code ausführen der eben nur zutrifft, wenn Zahl auf jeden Fall größer als 50 ist. Es kommt einfach darauf an, was man vorhat.
<h3>Mehrere logische Operatoren verwenden</h3>
Auch bei logischen Operatoren gibt es (ebenso wie in der Mathematik) die Klammern-Regel. So können wir so viele Ausdrücke prüfen wie wir wollen. Zum Beispiel ob eine Zahl größer als 0 UND kleiner als 100 ODER größer als 500 UND kleiner als 1000. Wenn wir Klammern setzen, können wir genau festlegen, wie die Ausdrücke ausgewertet werden sollen, außerdem dient es der besseren Übersicht und dem leichteren Verständnis.
Nehmen wir das eben genannte Beispiel:
<pre class="lang:default decode:true "><?php $Zahl = 60; if( ( $Zahl > 0 && $Zahl < 100 ) || ( $Zahl > 500 && $Zahl < 1000 ) ) { echo "Trifft zu wenn Zahl " . $Zahl . " ist.<br>"; } ?></pre>
Wir klammern beide UND-Ausdrücke und legen mit ODER fest, dass wenigstens eine der beiden zutreffen muss.
<h3>Beispiel mit Exklusiv-ODER</h3>
Wir fordern den Benutzer auf, einen Namen einzugeben der ENTWEDER mit einem "B" beginnt ODER mit "B" endet - er darf aber nicht mit "B" beginnen UND mit "B" enden ("BOB" wäre somit nicht zulässig, "BERND" jedoch schon).
Formulieren wir das in Code:
<pre class="lang:default decode:true "><?php $Name = "BOB"; if( substr($Name, 0, 1) == 'B' XOR substr($Name, -1, 1) == 'B' ) { echo "Der Name " . $Name . " ist okay.<br>"; } else { echo $Name . " passt nicht!<br>"; } ?></pre>
Der Einfachheit halber gehen wir davon aus, dass der Name in Großbuchstaben vorliegt - später lernen wir effizientere Möglichkeiten kennen. Jedenfalls tut der Code aber genau das was er soll. Mit substr($Name, 0, 1) holen wir den ersten Buchstaben von $Name, mit substr($Name, -1, 1) den letzten (mehr zu substr). Mit XOR legen wir fest, dass nur eine der beiden Bedingungen WAHR sein darf.
Und wie immer kannst du dann im Anweisungsblock -sofern erforderlich- beliebig viele weitere verschachtelte Bedingungen auswerten ... du bist der Chef deines Programms :)
<h3>Auswertung von Ausdrücken ohne if</h3>
Du kannst Bedingungen auch direkt im Code ohne zusätzliche if-Anweisung auswerten - und das Ergebnis dann beispielsweise einer Variable zuweisen.
Ein Beispiel hierzu - wir weisen einer Variable $Var true zu, wenn eine Zahl größer als 5 ist. Dabei nutzen wir den ganz normalen Weg den du schon kennst:
<pre class="lang:default decode:true "><?php # Variable $Var deklarieren und ausgeben $Var = "Irgendein Text"; var_dump($Var); $Zahl = 10; # Prüfen ob $Zahl gröÃer als 5 ist ... if ($Zahl > 5) { # ... und falls ja, setzen wir $Var auf true $Var = true; } # Den neuen Wert von $Var ausgeben echo "<br>"; var_dump($Var); ?></pre>
Führen wir den Code aus, erhalten wir folgende Ausgabe:
<pre class="lang:default highlight:0 decode:true ">string(14) "Irgendein Text" bool(true)</pre>
Macht soweit Sinn. Können wir aber auch viel kürzer haben - schau dir das mal an:
<pre class="lang:default decode:true "><?php # Variable $Var deklarieren und ausgeben $Var = "Irgendein Text"; var_dump($Var); $Zahl = 10; # Prüfen ob $Zahl gröÃer als 5 ist ... $Var = ($Zahl > 5); # Den neuen Wert von $Var ausgeben echo "<br>"; var_dump($Var); ?></pre>
Falls du's nicht gleich siehst - Zeile 10. Wir werden also quasi inline einen Ausdruck aus und zur besseren Übersichtlichkeit (und das empfehle ich dir ebenso zu machen) wird dieser in Klammern gesetzt. Bedeutet im Klartext dass wir an der Stelle eine Zuweisung eines Wertes für die Variable $Var vornehmen, und der Wert ist in dem Fall das Ergebnis eines Ausdrucks. Wie ich schon mal sagte, es gibt für Ausdrücke nur Ergebnisse die WAHR oder FALSCH sein können.
So richtig Sinn wird das machen, wenn wir Funktionen kennenlernen. Wie auch immer, es gibt bei der ganzen Geschichte einen Haken - wir können auf diese Weise entweder true oder false auswerten, jedoch nicht (wie bei einer normalen if-Anweisung) festlegen, was bei else passiert, d.h. wir können nur auf ein Ergebnis reagieren. Zum Glück gibt's dafür aber auch was:
<h3>WENN-DANN Anweisungen ohne if ... else ...</h3>
Wir können -ähnlich wie wir es eben gemacht haben- Bedingungen auswerten und sowohl auf true als auch auf false reagieren. Das geht mit der Kurzschreibweise (Short Syntax mit dem ternären Operator), die ich dir gleich zeige. Sehen wir uns zuerst ein klassisches Beispiel an:
<pre class="lang:default decode:true "><?php $Zahl = 50; echo "Die Zahl ist "; if ($Zahl > 10) { echo "gröÃer als"; } else { echo "kleiner oder gleich"; } echo " 10."; ?></pre>
Wir checken, ob die Zahl größer als 10 ist oder nicht - dementsprechend passen wir unseren Text an. Soweit cool. Kriegen wir das mit der Kurzschreibweise mit weniger Code hin? Allerdings, wir können das alles auf 2 Zeilen beschränken:
<pre class="lang:default decode:true "><?php $Zahl = 50; echo "Die Zahl ist " . ($Zahl > 10 ? "gröÃer als" : "kleiner oder gleich") . " 10."; ?></pre>
BAM! Krass, oder? Mit echo geben wir Text aus, dazwischen haben wir in Klammern eine Bedingung, das Ganze ist in 3 Teile aufgeteilt:
<ul> <li>Zuerst die Bedingung (WENN irgendwas WAHR ist ...).</li> <li>Falls die Bedingung WAHR ist, führe den Code nach dem Fragezeichen aus.</li> <li>Falls die Bedingung FALSCH ist (else), führe den Code nach dem Doppelpunkt aus.</li> </ul>
Einiges haben wir für heute schon geschafft, aber schauen wir uns zumm Schluss noch eine letzte, ganz wichtige Sache an:
<h3>Typsicherer Vergleich</h3>
Die Operatoren habe ich dir bereits gezeigt (gleich, ungleich, größer, kleiner und so weiter). Was du noch nicht gesehen hast, ist ein typsicherer Vergleich. Ganz am Anfang dieser PHP-Tutorial-Reihe habe ich erwähnt, dass PHP eine typschwache Sprache ist - jetzt finden wir heraus, was das bedeutet.
Am besten eignet sich hierzu ein Praxisbeispiel:
<pre class="lang:default decode:true "><?php var_dump(5 == 5); // true echo "<br>"; var_dump(5 == "5"); // true echo "<br>"; var_dump(5); // true echo "<br>"; var_dump(0); // false echo "<br>"; var_dump("abc" == "ABC"); // false echo "<br>"; var_dump("abc"); // true echo "<br>"; var_dump(""); // false echo "<br>"; var_dump(true); // true echo "<br>"; var_dump(false); // false echo "<br>"; var_dump("" == true); // false echo "<br>"; ?></pre>
Die Ausgabe hierzu:
<pre class="lang:default highlight:0 decode:true ">bool(true) bool(true) int(5) int(0) bool(false) string(3) "abc" string(0) "" bool(true) bool(false) bool(false) </pre>
Was hat es damit auf sich? Nun, das liegt daran, dass Werte durch PHP implizit zu einem boolschen Wert (WAHR oder FALSCH, also true oder false) ausgewertet werden können. So ergibt ein leerer String zum Beispiel false, während ein String mit Inhalt zu true ausgewertet wird. Eine kleine Übersicht:
Ist WAHR
<ul> <li><span style="font-family: courier new,courier,monospace;">"abc"</span></li> <li><span style="font-family: courier new,courier,monospace;">5</span></li> <li><span style="font-family: courier new,courier,monospace;">-2</span></li> <li><span style="font-family: courier new,courier,monospace;">["wert im array"]</span></li> </ul>
Ist FALSCH
<ul> <li><span style="font-family: courier new,courier,monospace;">"" (leerer String)</span></li> <li><span style="font-family: courier new,courier,monospace;">0 (Zahl 0)</span></li> <li><span style="font-family: courier new,courier,monospace;">[]</span> (leeres Array)</li> </ul>
Gehen wir auf die typschwäche ein. PHP erlaubt es uns (im Gegensatz zu vielen anderen Programmiersprachen) Datentypen zu mischen und automatisch in einen anderen zu konvertieren. So können wir zum Beispiel Strings addieren - was eigentlich nicht Sinn der Sache ist, denn dafür gibt es ja eigentlich Datentypen wie Integer oder Float. Schau her:
<pre class="lang:default decode:true"><?php # Addition von String und Integer echo (5 + 5) . "<br>"; echo ("5" + 5) . "<br>"; echo ("5" + "5") . "<br>"; echo "<br>"; $Var = "5"; echo '$Var hat den Datentyp ' . gettype($Var) . "<br>"; $Var = $Var + 1; echo '$Var hat den Datentyp ' . gettype($Var) . "<br>"; ?></pre>
Das hier ist die Ausgabe:
<pre class="lang:default highlight:0 decode:true ">10 10 10 $Var hat den Datentyp string $Var hat den Datentyp integer</pre>
Überrascht? Ohne dass wir was gemacht haben, hat sich der Datentyp der Variable geändert. PHP hat erkannt, dass wir eine Addition vornehmen, und den Datentyp entsprechend zu einem Integer geändert. Wir man Datentypen explizit angeben kann, erfährst du in einem späteren Artikel.
<h3>Fazit</h3>
Wie du siehst, können wir mit Kontrollstrukturen fantastische Dinge tun - den Programmfluss anhand von Bedingungen steuern und Dynamik in unsere Anwendungen bringen. Wie oben erwähnt ist das ein sehr wichtiges und essentielles Konstrukt der Softwareprogrammierung. Falls du Fragen dazu hast, lass einen Kommentar da.
Im nächsten Artikel zeige ich dir sog. Schleife, mit denen sich Code wiederholt ausführen lässt - auch eine super Sache.
Grüße Marius
Kommentare
Kommentar schreiben