Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
1 Einleitung
2 Webbrowser
3 JavaScript einbauen
4 Programmieren mit JavaScript
5 Datum
6 Zufall
7 Browserinformationen
8 Fenster
9 Formulare
10 Frames und Iframes
11 Grafiken
12 Cookies
13 Objekte und Arrays
14 Ereignisbehandlung
15 Fehlerbehandlung
16 DOM
17 DHTML und CSS
18 AJAX
19 XML
20 Web Services
21 AJAX-Frameworks
22 Plugins
23 Multimedia
24 Java
25 Serverseitige Technologien
26 JavaScript goes .NET
27 Code schützen
28 Top Secret: Passwortschutz
29 Signierte Skripte
30 JavaScript und Sicherheit
31 Navigation
32 Warenkorb
33 JavaScript-Bibliotheken
34 Referenz
35 Quellen im Web
36 Die Zukunft von JavaScript
Index
Download: - ZIP, ca. 9,2 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> / JavaScript und AJAX | vor >>
JavaScript und AJAX von Christian Wenz Das umfassende Handbuch
JavaScript und AJAX 839 S., mit DVD, 39,90 Euro Galileo Computing ISBN 3-89842-859-1 |
| Kapitel 4 Programmieren mit JavaScript
|  | 4.1 Variablen
|  |  | 4.1.1 Namensgebung
|  |  | 4.1.2 Numerische Variablen
|  |  | 4.1.3 Zeichenketten
|  |  | 4.1.4 Boolesche Variablen
|  |  | 4.1.5 Variablendeklaration
|  | 4.2 Operatoren
|  |  | 4.2.1 Arithmetische Operatoren
|  |  | 4.2.2 Boolesche Operatoren
|  |  | 4.2.3 String-Operatoren
|  |  | 4.2.4 Umwandlung zwischen den Variablentypen
|  | 4.3 Kontrollstrukturen: Schleifen
|  |  | 4.3.1 For-Schleifen
|  |  | 4.3.2 Do-while-Schleife
|  |  | 4.3.3 While-Schleife
|  |  | 4.3.4 For-in-Schleife
|  |  | 4.3.5 Schleifensteuerung
|  | 4.4 Kontrollstrukturen: Fallunterscheidung
|  |  | 4.4.1 If-Anweisung
|  |  | 4.4.2 Switch-Anweisung
|  |  | 4.4.3 Try
|  | 4.5 Datenspeicherung
|  |  | 4.5.1 Die eval()-Funktion
|  |  | 4.5.2 Arrays
|  | 4.6 Funktionen
|  | 4.7 Objekte
## 4.4 Kontrollstrukturen: Fallunterscheidung Eines der Hauptelemente aller JavaScript-Programme ist die Fallunterscheidung. Schon im vorigen Kapitel haben Sie gesehen, dass man mit den bereits vorgestellten Mitteln schnell an seine Grenzen stößt. ### 4.4.1 If-Anweisung Gehen wir zu dem Beispiel zurück, in dem alle As durch Bs ersetzt werden sollen. Mit einer while-Schleife geht das, aber bei einer do-while-Schleife hatten wir das Problem, dass eine Fehlermeldung erscheint, wenn die Zeichenkette von Anfang an kein A enthält. Der Code sah folgendermaßen aus:
    var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    do {
       io = Zk.indexOf("A");
       Zk = Zk.substring(0, io) + "B" +
            Zk.substring(io+1, Zk.length);
    } while (Zk.indexOf("A")>-1);
Wenn man die Möglichkeit hätte, innerhalb der Schleife zu überprüfen, ob die Zeichenkette noch ein A enthält, hätte man kein Problem. Natürlich gibt es eine solche Möglichkeit. Man bedient sich einer if-Anweisung oder einer if-else-Anweisung. Die Syntax sieht folgendermaßen aus:
    if (Bedingung) {
       //Anweisungsblock
    } else {
       //Anweisungsblock
    }
Ist die Bedingung erfüllt, wird der erste Anweisungsblock ausgeführt; falls nicht, wird der zweite Anweisungsblock ausgeführt. Der else-Teil ist hier optional, und wieder können die geschweiften Klammern weggelassen werden, wenn der Anweisungsblock aus genau einer Anweisung besteht. Wenn der erste Anweisungsblock keine geschweiften Klammern enthält und das else in derselben Zeile steht, muss die Anweisung mit einem Semikolon beendet werden. Falsch ist also:
    if (a==5) b=6 else c=7
Richtig ist dagegen:
    if (a==5) b=6; else c=7
Am wenigsten Probleme haben Sie freilich, wenn Sie prinzipiell jede Anweisung durch ein Semikolon abschließen. Bei einer if-Anweisung ist die Gefahr besonders groß, dass statt des Gleichheitsoperators == die Zuweisung = verwendet wird. Achten Sie hier besonders auf die Syntax! Aber zurück zum Beispiel. Es gibt hier mehrere Möglichkeiten. Die Überprüfung, ob die Zeichenkette ein A enthält, ist recht einfach darzustellen, und bei den Konsequenzen hat man die Wahl. Nahe liegend ist die folgende Variante:
    var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    do {
       io = Zk.indexOf("A");
       if (io > –1) {
          Zk = Zk.substring(0, io) + "B" +
               Zk.substring(io+1, Zk.length);
       }
    } while (Zk.indexOf("A")>-1);
Man kann auch bei Bedarf die Schleife einfach verlassen:
    var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    do {
       io = Zk.indexOf("A");
       if (io==-1) {
          break;
       }
       Zk = Zk.substring(0, io) + "B" +
            Zk.substring(io+1, Zk.length);
    } while (Zk.indexOf("A")>-1);
Dann braucht man die while-Bedingung aber gar nicht mehr und könnte beispielsweise folgende Variante verwenden:
    var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    do {
       io = Zk.indexOf("A");
       if (io==-1) {
          break;
       }
       Zk.charAt(io) = "B";
    } while (true);
Die Bedingung true ist immer erfüllt, der Anweisungsblock kann also nur durch ein break verlassen werden. Ob der Programmierstil des obigen Beispiels besonders gut ist, steht auf einem völlig anderen Blatt. Es gibt noch eine besondere, verkürzte Variante der if-else-Anweisung. Sie hat folgende Syntax:
    (Bedingung) ? Wert1 : Wert2
Ist die Bedingung erfüllt, ihr Wert also true, so wird Wert1 zurückgegeben, ansonsten Wert2. Meistens wird diese Schreibweise bei einer Variablenzuweisung verwendet, also in der Form:
    var Figur = (Essen=="Honig") ? "Pooh" : "Tigger";
Es gibt somit eine weitere Möglichkeit, in einer Zeichenkette alle As durch Bs zu ersetzen, indem alle Zeichen überprüft und gegebenenfalls ersetzt werden. Auch hier gibt es mehrere Möglichkeiten, um das Ganze auszuprogrammieren, aber unter Verwendung der gerade vorgestellten Kurzschreibweise bietet sich die folgende Variante an:
    var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    for (var i=0; i<Zk.length; i++) {
       ca = Zk.charAt(i);
       ca = (ca=="A") ? "B" : ca;
       Zk = Zk.substring(0, i) + ca +
            Zk.substring(i+1, Zk.length);
    }
Ausgeschrieben hätte das Beispiel die folgende, etwas längere Form:
    var Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    for (var i=0; i<Zk.length; i++) {
       ca = Zk.charAt(i);
       if (ca=="A") {
          ca = "B";
       }
       Zk = Zk.substring(0, i) + ca +
            Zk.substring(i+1, Zk.length);
    }
Die letzte – und einfachste – Möglichkeit, in einer Zeichenkette Zeichen auszutauschen, besteht in der Verwendung des Spezialkommandos replace(). Innerhalb der runden Klammern geben Sie zunächst die Zeichenkette, nach der gesucht werden soll, und dann die Ersatzzeichenkette an. Das sieht dann so aus:
    zar Zk = "AXAYAZ";  //Zk steht für "Zeichenkette"
    Zk.replace("A", "B");
Mit Fallunterscheidungen hat das freilich wenig zu tun, weswegen wir diesen kleinen Exkurs auch sofort wieder beenden. ### 4.4.2 Switch-Anweisung Die Aufgabenstellung klingt einfach: In einer Variablen steht die Nummer eines Monats. Das Programm soll den Namen des Monats ausgeben. Mit if-Anweisungen kann das Ganze folgendermaßen erledigt werden:
    if (monat == 1) {
       document.write("Januar");
    }
    if (monat == 2) {
       document.write("Februar");
    }
    if (monat == 3) {
       document.write("März");
    }
    if (monat == 4) {
       document.write("April");
    }
    if (monat == 5) {
       document.write("Mai");
    }
    if (monat == 6) {
       document.write("Juni");
    }
    if (monat == 7) {
       document.write("Juli");
    }
    if (monat == 8) {
       document.write("August");
    }
    if (monat == 9) {
       document.write("September");
    }
    if (monat == 10) {
       document.write("Oktober");
    }
    if (monat == 11) {
       document.write("November");
    }
    if (monat == 12) {
       document.write("Dezember");
    }
Dieses Beispiel hat wenigstens den Vorteil, dass man keine else-Zweige verwenden muss2 , dann würde nämlich der obige Code noch viel unübersichtlicher werden. JavaScript kennt jedoch ein Sprachfeature, mit dem der Code etwas übersichtlicher gestaltet werden kann. Es hat folgende Syntax:
    switch (Ausdruck) {
       case Wert1:
          //Programmblock
          break;
       case Wert2:
          //Programmblock
          break;
       //usw.
       default:
          //Programmblock
    }
Hierbei dreht sich alles um den Ausdruck, der in der Regel eine Variable ist. Hat dieser Ausdruck den Wert Wert1, wird der erste Programmblock ausgeführt, bei Wert2 der zweite Programmblock und so weiter. Der default-Abschnitt wird ausgeführt, wenn keiner der vorherigen Werte zutrifft. Dieser Abschnitt ist optional. Jeder Programmblock sollte mit dem Kommando break abgeschlossen werden, denn ansonsten führt der JavaScript-Interpreter alle Anweisungen bis zum nächsten break oder dem Ende des switch-Blocks aus – inklusive etwaiger anderer case-Anweisungen, die nicht zutreffen! Das Beispiel mit den Monaten lässt sich folgendermaßen umformulieren, und der Code ist deutlich kürzer und übersichtlicher:
    var monat = (new Date()).getMonth() + 1;

    switch (monat) {
       case 1: var m = "Januar"; break;
       case 2: var m = "Februar"; break;
       case 3: var m = "März"; break;
       case 4: var m = "April"; break;
       case 5: var m = "Mai"; break;
       case 6: var m = "Juni"; break;
       case 7: var m = "Juli"; break;
       case 8: var m = "August"; break;
       case 9: var m = "September"; break;
       case 10: var m = "Oktober"; break;
       case 11: var m = "November"; break;
       case 12: var m = "Dezember"; break;
       default: var m = "Unbekannter Monat";
    }
    document.write(m);
Beachten Sie die erste Zeile, die etwas Unbekanntes enthält; in dieser Anweisung wird die Nummer des aktuellen Monats in der Variablen monat abgelegt. Dies dient hier lediglich dazu, dass Sie das Listing auch testen können. Auf Datumswerte gehen wir im nächsten Kapitel ein. Bei der Programmiersprache Perl beispielsweise gibt es kein switch, es muss dort mühsam durch andere Sprachkonstrukte »emuliert« werden. Aber die meisten anderen Programmiersprachen kennen switch, nur heißt es unter Umständen anders, beispielsweise in Visual Basic/VBScript/VB.NET/Visual Basic 2005 Select Case. ### 4.4.3 Try Eine besondere Form der Kontrollstruktur ist try...catch. Damit können Sie Fehler abfangen. Hier ist der Aufbau:
    try {
       // Block 1
    } catch (ex) {
       // Block 2
    }
Wenn in Block 1 ein Fehler auftritt, bricht JavaScript die Code-Ausführung nicht ab, sondern springt direkt in Block 2. Hier ein Beispiel:
    try {
       window.gibtsnicht.gibtsauchnicht = true;
    } catch (ex) {
       window.alert("Hoppla!");
    }
Die Variable ex (Namensgebung beliebig) enthält die Exception, also Ausnahme (Fehler), die aufgetreten ist. Der folgende Code würde die Fehlermeldung ausgeben:
    try {
       window.gibtsnicht.gibtsauchnicht = true;
    } catch (ex) {
       window.alert(ex);
    }
Im vorliegenden Fall wäre die Meldung übrigens: window.gibtsnicht has no properties. Der Wert dieser Exception kann auch gesetzt werden. JavaScript unterstützt hier das Spezialkonstrukt throw, das eine selbst kreierte Fehlermeldung ausspuckt. Die Syntax ist etwas gewöhnungsbedürftig: Keine Klammern, lediglich Leerzeichen:
    try {
       throw "Meine eigene Fehlermeldung";
    } catch (ex) {
       window.alert(ex);
    }
Das Konstrukt try...catch wurde in JavaScript 1.5 eingeführt, wird aber von allen modernen Browsern unterstützt.
<< zurück | <top> | vor >>
Zum Katalog
JavaScript und AJAX bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung
Buchtipps
| JavaScript und AJAX - Das Video-Training
| Webseiten programmieren und gestalten
| XHTML, HTML und CSS
| CSS-Praxis
| AJAX
| PHP 5 und MySQL 5
| TYPO3 4.0
Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

Copyright © Galileo Press 2007
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de