Vergleiche

Man kann Werte auf Gleichheit und Ungleichheit, auf größer und kleiner prüfen. Das Ergebnis eines solchen Vergleiches ist entweder true oder false. Für den Vergleich auf Gleichheit / Ungleichheit gibt es vier Operatoren:

=== strikte Gleichheit
!== strikte Ungleichheit
== lose Gleichheit
!= lose Ungleichheit

Strikte Gleichheit liegt vor, wenn die Werte vom gleichen Typ sind und wenn sie gleich sind. Lose Gleichheit liegt vor, wenn die Werte nach einer möglichen Typkonvertierung gleich sind. So ist die Zahl 1 und der String „1“ nicht strikt gleich, da sie nicht denselben Typ besitzen. Sie sind aber lose gleich, da sich der String „1“ in die Zahl 1 konvertieren lässt und diese Werte dann gleich sind.

// Alle Ausdrücke ergeben true.

1 === 1;
1 !== 2;
"1" !== 1;
"Hallo Welt" === "Hallo Welt";
false === false;
true !== false;

1 == 1;
"1" == 1;
0 == false;
1 == true;
2 != true;
2 != false;
"0" == false;

Bei der Typkonvertierung wird versucht, Strings in entsprechende Zahlen umzuwandeln. false wird in 0 und true wird in 1 umgewandelt. Da diese (nicht mal vollständigen) Konvertierungs-Regeln recht kompliziert sind und da man Werte von unterschiedlichem Typ erst garnicht vergleichen sollte, sollte man immer die strikte Gleichheit bzw. Ungleichheit verwenden.

Für den Größenvergleich stehen ebensfalls vier Operatoren zur Verfügung:

<= kleiner gleich
< echt kleiner
>= größer gleich
> echt größer

Mit diesen Operatoren kann man Zahlen und Strings vergleichen. Strings werden wie in einem Lexikon sortiert. Dabei sind Großbuchstaben kleiner als Kleinbuchstaben und Ziffern (in Strings) kleiner als Buchstaben. Auch hier gilt: nur gleiche Datentypen miteinander vergleichen, also Zahlen mit Zahlen und Strings mit Strings.

// Alle Ausdrücke ergeben true.

1 < 2;
3.00001 > 3;
1 <= 1;
9 < 10;

"Arno" < "Franz";
"Hannah" > "Hanna";
"Rot" > "lila";
"9" > "10";

Math

Wir hatten gesehen, dass man mit Zahlen die üblichen Rechenarten durchführen kann, also + - * /. In dieser Auszählung fehlt nur noch der Modulo-Operator. Modulo gibt den Rest einer Division zurück:

console.log(13 % 5); // 3 (13/5 = 2 Rest 3)

Alle weiteren mathematischen Operationen sind im Math-Objekt gebündelt. Hier gibt es Methoden zur Berechnung der Wurzel, von Potenzen, von Sinus und Cosinus. Desweiteren stellt das Math-Objekt eine handvoll mathematischer Konstanten zur Verfügung.

Math.sqrt(9);  // Wurzel aus 9
Math.pow(2, 10); // 2 hoch 10
Math.sin(1); // Sinus von 1 in Radiant
Math.max(2, 17, 6); // = 17 (Maximum)
Math.min(2, 17, 6); // = 2 (Minimum)
Math.floor(6.845); // = 6 (Abrunden)
Math.ceil(6.845); // = 7 (Aufrunden)
Math.PI; // = 3.14...
Math.random(); // eine Zufallszahl
  // größer gleich 0 und kleiner 1

Weitere Methoden findest du bei SELFHTML und MDN.

Aufgabe: Berechne in einer Schleife Primzahlen und gebe sie mit console.log aus.

String

Strings (Zeichenketten) hatten wir weiter unten eingeführt. Wir hatten gesehen, dass man sie in einfachen oder doppelten Anführungszeichen schreiben kann. Und wir hatten gesehen, dass man sie mit dem + Operator zusammen fügen kann. Mit Strings kann man aber noch einiges mehr machen. String ist auch ein sogenanntes Objekt und dieses Objekt besitzt eine wichtige Eigenschaft und eine Reihe von Methoden. Diese Eigenschaft und ein paar dieser Methoden möchte ich hier vorstellen.

length

Die Eigenschaft length gibt die Anzahl der Zeichen (die Länge) eines Strings zurück.

var name = prompt("Wie heißt Du?");
alert("Dein Name hat " + name.length +
    " Buchstaben.");

Der Leerstring besitzt die Länge 0:

var laenge = "".length;
console.log(laenge); // 0

trim

Mit der Methode trim werden Leerzeichen am Anfang und am Ende des Strings entfernt:

var name = " Franz ";
console.log(name.length); // 7
name = name.trim(); // name = "Franz"
console.log(name.length); // 5

Wichtig ist, dass die Methode trim (wie alle anderen String-Methoden) den eigentlichen String nicht verändern. Sie geben den neuen String zurück. Erst durch die Zuweisung name = name.trim() erhällt name den getrimmten Wert.

toLowerCase / toUpperCase

Diese beiden Methoden wandeln einen String in Klein- bzw. Großbuchstaben um:

var name = "Franz";
console.log(name.toLowerCase()); // "franz"
console.log(name.toUpperCase()); // "FRANZ"

Zeichen, die kein Buchstabe sind (Zahlen, Satzzeichen, …) bleiben unverändert. Für ß gibt es keinen Großbuchstaben. Es wird in SS umgewandelt.

substr

Mit der Methode substr kann man aus einem String einen Teilstring extrahieren. Dabei muss man der Position des ersten zu extrahierenden Zeichens und optional die Anzahl der zu extrahierenden Zeichen angeben. Gibt man die Anzahl der zu extrahierenden Zeichen nicht an, werden alle Zeichen bis zum Ende der Zeichenkette extrahiert. Die Zählung der Zeichenposition beginnt mit 0. Die Syntax sieht wie folgt aus: str.substr(start[, length]). Hier einige Beispiele:

var text = "Willkommen!";
console.log(text.substr(4)); // "kommen!"
console.log(text.substr(0, 4)); // "Will"
console.log(text.substr(3, 0)); // ""

indexOf

Syntax: str.indexOf(searchValue[, fromIndex])
Mit dieser Methode wird das erste Vorkommen einer Zeichenkette innerhalb der aufrufenden Zeichenkette ermittelt. Zurückgegeben wird die Position des ersten Vorkommens. Gibt es keine Übereinstimmung, wird -1 zurückgegeben. Optional kann ein Index angegeben werden, ab dem die Suche startet. Beispiele:

var text = "Blütenweiß, blütenweiß";
console.log(text.indexOf("weiß")); // 6
console.log(text.indexOf("weiß"), 10); // 18
console.log(text.indexOf("schwarz"); // -1

charAt

charAt gibt den Buchstaben an der spezifizierten Stelle zurück. Syntax: str.charAt(index)

var text = "Versenkung";
console.log(text.charAt(0)); // "V"
console.log(text.charAt(text.length - 1)); // "g"

Weitere Methoden

Weitere String-Methoden findest du bei SELFHTML. Die vollständige Liste aller String-Methoden findest du beim MOZILLA DEVELOPER NETWORK.

Aufgabe: Gebe einen Namen gesperrt zurück. Aus „Franz“ sollte „F r a n z“ werden.

console.log

Alle Browser besitzen sogenannte Entwickler-Tools. Beim Firefox aktiviert man diese unter Extras -> Web-Entwickler -> Werkzeuge ein-/ausblenden oder mit dem Shortcut F12. Im Safari muss man in der Menüleiste unter Safari -> Einstellungen -> Erweitert die Checkbox Menü Entwickler in der Menüleiste anzeigen aktivieren. Hat man die Entwickler-Tools aktiviert, sieht man im unteren Browser-Fenster eine Reihe von Tabs. Man kann damit HTML, CSS und JavaScript analysieren und bearbeiten. Es sind leistungsstarke Tools, die uns als Webentwickler unterstützen. Hier interessiert uns die Konsole. In die Konsole kann man von JavaScript-Programmen aus schreiben. Und zwar mit dem Befehl console.log:

console.log("Hallo Console!");

Ist die Konsole geöffnet, sieht man die entsprechende Ausgabe. Ist die Konsole nicht geöffnet, wird die Programmzeile ignoriert. Mit der Konsole-Ausgabe kann man wunderbar die Werte von Variablen verfolgen:

var x = "";
for (var i = 0; i < 10; i++) {
  x = x + "x";  
  console.log(i, x);
}

Neben console.log bietet die Console noch weitere Methoden: console.debug, console.info, console.warn und console.error. Diese Methoden schreiben ebenfalls in die Konsole. Sie werden jedoch farblich anders gekennzeichnet und man kann sich in den entsprechenden Konsole-Tabs nur die Meldungen eines Typs anschauen. Das macht die Ausgabe strukturierter.

Aufgabe: Gebe auf der Konsole ein nxn Schachbrett aus. Weiße Felder sollen durch ein o, schwarze Felder durch ein x symbolisiert werden. Für n=4 sollte die Ausgabe in etwa so aussehen:

oxox
xoxo
oxox
xoxo

Open Books

Im Netz gibt es eine Reihe von Büchern, die frei zugänglich sind (leider häufig veraltete Auflagen). Hier möchte ich auf das HTML5-Handbuch von Clemens Gull und Stefan Münz (dem Autor von SELFHTML) aufmerksam machen. Es stellt alle HTML-Elemente systematisch vor. Der Schwerpunkt liegt dabei auf der Semantik (der Bedeutung) der HTML-Elemente. Eine kurze Einführung in CSS und JavaScript rundet das Buch ab. Einfach mal reinschauen!

if – Anweisung

Mit der if-Anweisung steuert man, ob ein Code-Block ausgeführt wird oder nicht. Die einfachste Form sieht wie folgt aus:

var zahl = prompt("Gebe eine Zahl ein!");
zahl = parseFloat(zahl);
if (zahl > 10) {
  var message = "Die Zahl ist zu groß." +
      "Sie wird auf 10 zurückgesetzt.";
  alert(message);
  zahl = 10;
}
alert("Zahl = " + zahl);

Ist die Bedingung in der Klammer der if-Anweisung erfüllt, wird der anschließende Code-Block ausgeführt. Andernfalls nicht. Eine if-Anweisung kann man noch mit else if und else erweitern:

var zahl = prompt("Gebe eine Zahl ein!");
zahl = parseFloat(zahl);
if (zahl > 10) {
  alert("Die Zahl ist zu groß!");
} else if (zahl > 100) {
  alert("Die Zahl ist viel zu groß!");
} else {
  alert("Passt!");
}

Der else-if-Zweig wird ausgeführt, wenn die vorherige if-Bedingung falsch war und die else-if-Bedingung wahr ist. Der else-Zweig wird ausgeführt, wenn alle vorherigen Bedingungen falsch waren. Einer if-Anweisung können beliebig viele else-if-Anweisungen folgen. Zum Abschluss einer if-Anweisung darf maximal eine else-Anweisung stehen.

for – Schleife

Mit Schleifen können wir einen Code-Abschnitt mehrmals durchlaufen. JavaScript kennt mehrere Schleifenarten. Die einfachste ist die for-Schleife:

var summe = 0;
for (var i = 1; i <= 10; i++) {
  summe = summe + i;
}
alert("Summe 1-10: " + summe);

Die for-Schleife wird über drei Ausdrücke, der Start-Anweisung, einer Bedingung und einer Schleifen-Anweisung gesteuert. Zunächst wird die Start-Anweisung ausgeführt. Hier wird normalerweise eine Variable initialisiert. Wir initialisieren hier die Variable i mit dem Wert 1. Anschließend wird die Bedingung ausgewertet. Ist sie true, wird der Schleifen-Code ausgeführt. Der Schleifen-Code steht zwischen den beiden Mengenklammern. Nach Ausführung des Schleifen-Codes wird die Schleifen-Anweisung ausgeführt. Wir erhöhen hier die Variable i um 1 (i++ ist identisch mit i = i + 1). Anschließend wird wieder die Schleifen-Bedingung ausgewertet. Sobald die Bedingung false ergibt, wird die Schleife beendet und der Code nach der Schleife wird ausgeführt.

Aufgabe: Schreibe ein Programm mit dem der User die Fakultät einer natürlichen Zahl berechnen kann.

JavaScript in HTML einbinden

Unsere bisherigen JavaScript-Beispiele funktionierten zwar alle in einem Browser, waren jedoch formal nicht korrekt. JavaScript muss in gültiges HTML eingebunden werden. Das möchte ich hier nachholen. Es gibt zwei Möglichkeiten, JavaScript in HTML einzubinden: direkt im HTML-Dokument oder als Referenz auf eine externe Datei. Beides funktioniert mit dem script-Element:

<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>JavaScript direkt in HTML</title>
    <script>
      alert("Hallo JavaScript!");
    </script>
  </head>
  <body>
    Hallo HTML!
  </body>
</html>

Hier steht der JavaScript-Code direkt zwischen dem öffnenden und schließenden script-Tag.
Für die externe Referenz benötigen wir zwei Dateien: eine HTML-Datei und JavaScript-Datei. Die HTML-Datei kennen wir schon. Es ist einen Datei mit der Endung ‚html‘. Eine JavaScript trägt die Endung ‚js‘. Das folgende HTML schreiben wir wie gewohnt in die Datei index.html:

<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>JavaScript direkt in HTML</title>
    <script src="index.js"></script>
  </head>
  <body>
    Hallo HTML!
  </body>
</html>

In index.js schreiben wir folgenden Code:

alert("Hallo JavaScript!");

Beide Dateien müssen im selben Ordner liegen. Mit dem src-Attribute des script-Elements wird die JavaScript-Datei referenziert. src steht dabei für source (engl. Quelle).
Von der Funktionalität her sind beide Arten JavaScript einzubinden identisch. Die externe Referenz ist jedoch deutlich übersichtlicher. Aus diesem Grund schreiben wir JavaScript immer in gesonderte Dateien und binden diese per Referenz in HTML-Dokumente ein.

SELFHTML

SELFHTML ist ein Projekt, dass eine deutschsprachige Dokumentation zu HTML, CSS und JavaScript bereitstellt. Insbesondere der Teil zu HTML ist empfehlenswert. SELFHTML wurde 1995 von Stefan Münz aufgebaut und entwickelte sich schnell zu einer wichtigen, deutschsprachigen Dokumentation für HTML. 2005 übernahm ein Entwicklerteam SELFHTML und Stefan Münz zog sich aus dem Projekt zurück. Heute wird das Projekt von dem Verein SELFHTML e.V. geführt. Mitarbeit an SELFHTML ist jederzeit willkommen!