... aus »Dynamic HTML«, Galileo Computing

Skriptsprachen

Anfang der Neunzigerjahre entwickelte eine kleine Gruppe von Programmierern bei Sun Microsystems eine Programmiersprache, die wegen der Bäume vor den Bürofenstern zeitweise mit Oak (Eiche) bezeichnet wurde. Der ursprüngliche Plan von Sun bestand darin, Oak für elektronische Geräte wie z. B. interaktive Fernseher und Videogeräte zu verwenden. Als aber anstelle des interaktiven Fernsehmarktes der Internetmarkt explodierte, haben die Sun-Techniker Oak als Entwicklungssprache in einem Webbrowser verwendet, wo sieden Spitznamen WebRunner erhielt. Oak war der Vorgänger von Java. Ende 1994 war Oak bereits eine hoch entwickelte Sprache, mit der Applets entwickelt wurden, die über die Implementierung einer virtuellen Maschine überall auf jedem beliebigen Computer ausgeführt werden konnten. Zu diesem Zeitpunkt konnte es auch zur Animierung von Webseiten genutzt werden.

Die Marken Oak und WebRunner waren bereits registriert (oder im Handel verwendet), deshalb erfand ein Komitee bei Sun den Namen Java, wahrscheinlich nach einigen Café Latte. Egal, wie der Name auch lauten mag, Java ist wohl die grandioseste Technologie in der Computergeschichte.

Ein schneller Blick auf Java

Java lehnt sich in seiner Syntax und Struktur an C++ an. Es hat sich zu einer weit verbreiteten Programmiersprache entwickelt.

Anders als die meisten Programmiersprachen wird Java nicht kompiliert. Die JVM agiert als Schnittstelle und interpretiert Java-Programme für den Computer, auf dem es ausgeführt wird. Mit der JVM können Sie jedes Java-Programm auf jedem beliebigen Computerbetriebssystem verwenden. So kann Java auf jedem beliebigen Betriebssystem eingesetzt werden. Dies bedeutet, dass ein Entwickler nur eine Version eines Programms anstatt drei schreiben muss. Ähnlich müssen Benutzer nicht befürchten, dass Anwendungen nicht auf ihren Computern (oder auf einem anderen Gerät) ausgeführt werden können.

Im Jahr 1996 erhielt Java mit der Markteinführung von Netscape Navigator 2 Einzug in das Web. Mit dem Netscape-Browser konnten zahlreiche Surfer im Web Java-Applets kennen lernen und erleben. Die verbesserte Funktionalität, die Java Webentwicklern bot, hat die Verbreitung von Java im gesamten Web vorangetrieben. Natürlich hat das Javas Versprechen „Write Once, Run Anywhere“ (einmal schreiben, überall ausführen) Entwickler dazu gebracht, der neuen Programmiersprache zu verfallen.

Einer der Hauptnachteile von Java besteht darin, dass der Computer entsprechend ausgestattet sein muss, um eine akzeptable Leistung zu gewährleisten. Obwohl Java-Software auf 16-Bit-Betriebssystemen läuft, ist sie aufgrund der Ausführungsgeschwindigkeit der Anweisungen sehr langsam. Eine akzeptable Leistung erhalten Sie erst ab einem Pentium-Przessor mit einem 32-Bit-Betriebssystem. Bei dieser Kombination können selbst die komplexesten Java-Skripten ausgeführt werden. Bei den skriptbasierten Nachkommen von Java (die anschließend behandelt werden) scheint dieser Nachteil nicht zu bestehen. Diese können überall auf beliebiger Hardware mit unterschiedlichen akzeptablen Leistungen ausgeführt werden.

Die JavaScript-Familie

Etwa zur selben Zeit, als das Interesse an Java im gesamten Web gro- war, entwickelte Netscape eine Skriptsprache, die LiveScript genannt wurde. Ob esInspiration war oder einfach nur ein Marketingtrick, Netscape benannte ihre LiveScript-Sprache in JavaScript um und inspirierte die Entwicklung von Skriptsprachen in allen großen Browsern. Mit JavaScript, JScript (Microsofts Version von JavaScript) und ganz aktuell ECMAScript (der neuesten Standardsprache, die versucht, Skriptsprachen in einem Paket zu kombinieren) - beide Sprachen werden weiter unten in diesem Kapitel behandelt - wurde die Animation und Automation von Webseiten vereinfacht. Anders als ihr Namensvetter teilen sie nicht den ursprünglichen Zweck von Java: Sie stellen keine Skriptsprache dar, die überall und für jeden Zweck eingesetzt werden kann.

JavaScript ist eine interpretierte Skriptsprache, mit der clientseitige Steuerelemente für interaktive Webseiten hinzugefügt werden können. Alternativ kann es als serverseitiges Skript für Active Server Pages (ASP) dienen, die vom Microsoft Internet Information Server (IIS) und anderen Serverpaketen (dazu zählen auch Server von ChiliSoft) verteilt werden. Clientseitige Steuerelemente, wie z. B. Formularschaltflächen und viele Navigationssysteme, verwenden JavaScript, um die Funktionsweise des Steuerelements zu manipulieren. Da JavaScript mit dem Dokument verknüpft ist und der Webbrowser des Besuchers die Verarbeitung des Skripts übernimmt, werden diese Steuerelemente als „clientseitig“ bezeichnet. Anders ausgedrückt, sie werden vom Webclient verwaltet. Serverseitige Skripten werden vom Webserver verwaltet und sind möglicherweise für den Webbrowser nicht sichtbar. Mit Hilfe von JavaScript-Dokumenten können Autoren sicherstellen, dass Formulare richtig ausgefüllt sind, bevor diese abgesendet werden, Informationen an Java-Applets oder Browser-Plug-Ins senden, den Inhalt eines Dokuments ändern oder einfach Benutzeragenten erkennen, und Kopien von Dokumenten im Voraus laden, die für einen bestimmten Browser optimal funktionieren.

JavaScript soll so einfach sein, dass praktisch jeder, der Interesse und Zeit hat, die Programmierung erlernen kann. Einer der größten Nachteile von JavaScript kann jedoch auf die Entscheidungsträger im Unternehmen zurückgeführt werden. Die Unterstützung für JavaScript ist in den Netscape- und Microsoft-Browsern unterschiedlich. Microsofts eigene Entwicklung von JavaScript, JScript, enthält Skripteigenschaften, -Methoden und -Objekte, die nicht von Netscape unterstützt werden. Folglich unterstützt JScript nicht alle der in Netscape integrierten JavaScript-Eigenschaften, -Methoden und -Objekte. Die meisten dieser Unterschiede können auf viele der Unterschiede in den Produkten und der generellen Philosophie des Unternehmens zurückgeführt werden, das diese Entscheidungen trifft. So wird die Entwicklung dynamischer Sites, die mit beiden Browsern kompatibel sind, eine schwierige Aufgabe, wenn Sie einige der erweiterten Funktionen jeder dieser Sprachen integrieren möchten.

Ende 1995 hat Netscape die Entwicklung von JavaScript (damals LiveWire) vorangetrieben und es als „offenen Internet-Skriptsprachenstandard“ gefördert, bevor es der European Computer Manufacturers Association (ECMA) übergeben wurde, die im nachfolgenden Abschnitt behandelt wird. Eine der aktuellen Aufgaben von Netscape besteht darin, die eigene Version von JavaScript mit dem neuen ECMAScript-Standard der ECMA zu synchronisieren. Wenn die Hoffnungen und Träume vieler Webentwickler erfüllt werden, werden sowohl Netscape als auch Microsoft den ECMAScript-Standard übernehmen, ohne eigene „personalisierte“ Erweiterungen hinzuzufügen.

Der ECMAScript-Standard

Die European Computer Manufacturers Association (im Web unter http://www.ecma.ch) ist eine Organisation für die Standardisierung von Informations- und Kommunikationssystemen. Im Juni 1997 wurde die ECMAScript-Sprache als offener Standard für Skriptsprachen offiziell anerkannt, nachdem die ECMA einige Monate zusammen mit Netscape, Microsoft, Borland, Sun, der Internet Engineering Task Force (IETF) und dem W3C daran gearbeitet hat. Dieser Standard, mit dem Namen ECMA-262, ist hauptsächlich von Netscapes JavaScript und Microsofts JScript abgeleitet und umfasst Erweiterungen und Strukturen von anderen in der Industrie verwendeten Skriptsprachen.

Im ECMA-Standard sind alle Typen, Werte, Objekte, Eigenschaften und Funktionen definiert, die in der ECMAScript-Sprache verwendet werden. Zudem ist die Programmsyntax definiert, die für eine ordnungsgemäße Interpretation des Skripts erforderlich ist. Als die Spezifikationen für diese Skriptsprache entwickelt wurden, wurde eine Gruppe von „zukünftig reservierten Wörtern“ zusammengestellt, die ein einfaches Wachstum der Sprache innerhalb der vorgegebenen Grenzen ermöglicht. Da die ECMA daran gedacht hat, Begriffe zu reservieren, von denen sie ausgeht, dass diese in Zukunft zum Einsatz kommen werden, können Sie auf „widgets“ als „widgets“ und nicht als „object_misunderstood“ verweisen. So wird das Wachstum von ECMAScript um ein Vielfaches einfacher als für andere Sprachen, da dessen künftige Entwicklung bereits teilweise vorgegeben ist und nicht in der Luft schwebt, wie dies für viele Sprachen der Fall ist.

Funktionsweise von ECMAScript

ECMAScript ist wie JScript und JavaScript eine objektorientierte Skriptsprache. Wie andere Skriptsprachen baut es auf seiner Umgebung auf, z. B. dem HTML-Dokument und dem Webbrowser, um die unter Umständen erforderlichen externen Daten bereitzustellen. Da ECMAScript ursprünglich als Webskriptsprache entwickelt wurde, kann es auf einer Vielzahl von Hostsystemen, wie Java, JavaScript und JScript, eingesetzt werden. Sie benötigen keinen UNIX- oder NT-Computer, um ECMAScript nutzen zu können.

Ihr Webbrowser stellt ECMAScript mit einer vollständigen Umgebung bereit, die ein Programmierer manipulieren kann, einschließlich Objekte, wie z. B. Fenster, Menüs, Dialogfelder, Textbereiche, Anker, Frames, Cookies und eine Eingabe-/Ausgabequelle. Wie bei JavaScript und JScript ist der ECMAScript-Code in den HTML-Dokumenten enthalten und wird vom Skript-Engine verarbeitet, der Teil des Webbrowsers ist. Aufgrund der Tatsache, dass ein Webbrowser Dokumente erheblich manipuliert und dass ECMAScript direkt an die Nutzung des Dokuments durch den Browser gebunden werden kann, kann ECMAScript bei jedem Öffnen und Schließen eines Dokuments mit dem Browser interagieren. Dies ist auch möglich, wenn der Fokus auf ein Objekt gelenkt oder geändert wird, wenn ein Formular gesendet wird, wenn eine Maus bewegt wird oder wenn ein Fehler auftritt. Da die Skriptsprache auf alle Benutzeraktionen reagieren kann (die als spezifisches Ereignis in der Skriptsprache selbst bezeichnet werden), ist kein einzelnes Programm erforderlich, das alle in Funktionen unterteilte Skripten enthält. Sie können jede Funktion direkt von dem Teil des Programms aus aufrufen, der die Aktionen der Funktion manipuliert.

Der Webserver bietet eine weitere Gelegenheit, mit Anfragen für zusätzliche Informationen vom HTTP-Server, von Clients und von Dateien zu arbeiten. Es gibt eine Vielzahl von serverseitigen Skriptsprachen, die häufig zusammen mit ECMAScript-Funktionen eingesetzt werden. Die serverseitigen Skripten bieten Ihnen eine Methode, Dateien mit den Skripten gemeinsam zu nutzen. Sie können die serverseitigen Skripten oder Programme verwenden, um den Inhalt Ihrer Seiten zu erstellen, den Inhalt zu aktualisieren oder Seiten vollkommen interaktiv zu erstellen. Sie können ECMAScript (oder eine der anderen Versionen von JavaScript) in Ihren serverbasierten Code integrieren. Auf diese Weise können Sie multifunktionale Seiten erstellen, auf denen jeder Task vom Programm, vom Webbrowser des Clients oder von dem Server durchgeführt wird, der am Besten für die Verarbeitung der Informationen geeignet ist. Die Kombination aus clientseitigen und serverseitigen Skripten ermöglicht Ihnen, den für die Verarbeitung der Seite einer Website erforderlichen Aufwand auf zwei Computer zu verteilen und eine vollkommen angepasste Oberfläche für Ihre Webanwendungen bereitzustellen. Zudem wird der gesamte Prozess beschleunigt.

ECMAScript-Eigenschaften

Ein ECMAScript-Objekt ist in eine Reihe von Eigenschaften unterteilt, wie z. B. eval(x), parseInt, parseFloat, parseString, length und value. Mit Hilfe von Eigenschaften im ECMAScript ist ein Verweis auf bestimmte Aspekte eines Objekts möglich. Beispielsweise verfügt ein image-Objekt über die Eigenschaften width und height. Jede Eigenschaft verfügt wiederum über eine Reihe von Attributen, mit denen die Verwendungsweise der Eigenschaft festgelegt wird. Wenn z. B. eines dieser Attribute die Eigenschaft als schreibgeschützt kennzeichnet, können Sie den Wert dieser Eigenschaft nicht über das ECMAScript ändern. Die in Anhang D „Kompatibilität mit JavaScript und JScript“ aufgeführten Eigenschaften kommen der ECMAScript-Spezifikation sowohl in der Funktion als auch im Format sehr nahe. Obwohl die Sprachen weiterhin von ihren jeweiligen Entwicklern als JavaScript und JScript bezeichnet werden, übernehmen diese Unternehmen die ECMAScript-Grundlage. Die Namen selbst werden sich wohl nicht so schnell ändern.

Eigenschaften können andere Objekte, Werte oder Methoden enthalten. Wenn eine Eigenschaft einen Wert enthält, ist dieser einer der integrierten Typen, wie z. B. Boolean, Null, Number, String oder Undefined. Eine Methode ist einfach eine Funktion, die über die Eigenschaft dem Objekt zugewiesen wurde. Wenn die Eigenschaft ein weiteres Objekt enthält, ist dieses einer der integrierten Objekte, wie z. B. Array, Boolean, Date, Global, Math, Number, Object oder String.

ECMAScript verwendet zudem einen Satz von Operatoren, mit denen Daten oder Objekte mit anderen Daten oder Objekten verglichen oder ihnen zugeordnet werden können. ECMAScript verwendet wie JavaScript und JScript die Standardoperatoren, um Berechnungen durchzuführen. Einige dieser Operatoren finden Sie in der nachfolgenden Liste:

- Addition (+)
- Addition mit dem Wert (++)
- Bitweises ausschl. ODER (^)
- Bitweises ausschl. ODER mit dem Wert (^=)
- Bitweises NICHT (~)
- Bitweises ODER (|)
- Bitweises ODER mit dem Wert (|=)
- Bitweises UND (&)
- Bitweises UND mit dem Wert (&=)
- Bitweises Verschieben nach links (<<)
- Bitweises Verschieben nach rechts (>>)
- Division (/)
- Division mit dem Wert (/=)
- Gleichheit (==)
- Größer als (>)
- Größer oder gleich (>=)
- Kleiner als (<)
- Kleiner oder gleich (<=)
- Logisches NICHT (!)
- Logisches ODER (||)
- Logisches UND (&&)
- Multiplikation (*)
- Multiplikation mit dem Wert (*=)
- Negation (-Wert)
- Schrittweises Erhöhen (++)
- Subtraktion (-)
- Subtraktion mit dem Wert (-=)
- Ungleichheit (!=)
- Verminderung (--)
- Zuweisung (=)

Das einfache Format der ECMAScript-Syntax wurde an der Syntax von JavaScript und JScript angelehnt, wodurch sie problemlos zu verwenden ist. Ein Beispiel ist die Behandlung von Variablen. In ECMAScript müssen Sie nicht alle Variablen deklarieren oder sie einem bestimmten Wertetyp zuweisen. In vielen anderen Skript- und Programmiersprachen müssen alle Variablen definiert werden, bevor sie verwendet können, und als bestimmter Variablentyp angegeben werden, wie z. B. „string“, „integer“, „array“ oder „Boolean“.

Microsoft, Netscape, Sun, Borland und IBM haben bereits ihre Zustimmung zu ECMAScript gegeben und begonnen, die Unterstützung dafür in ihre Produkte zu implementieren. In naher Zukunft werden Sie möglicherweise immer weniger echtes JavaScript und JScript, dafür aber mehr und mehr ECMAScript sehen.

Die Microsoft-Implementierung: JScript

Die einfachste Beschreibung von JScript lautet „JavaScript mit einer Drehung“. JScript ist die Microsoft-eigene Version von ECMAScript und JavaScript. JScript 3 ist eine vollständige Implementierung der ECMAScript-Spezifikation mit zusätzlichen Erweiterungen, die nur mit dem Internet Explorer genutzt werden. JScript hat wie JavaScript einige gemeinsame Funktionen mit Java, ist aber keine vereinfachte Version dieser Sprache. JScript ist eine echte objektorientierte Skriptsprache. (Informationen zu den von JScript unterstützten Objekten, Eigenschaften und Methoden finden Sie in Anhang D, „Kompatibilität mit JavaScript und JScript“.)

JScript unterstützt eine Reihe von Gruppen und Funktionen, die in der ursprünglichen Implementierung von JavaScript durch Netscape nicht unterstützt werden. Neben der Übernahme von ECMAScript durch beide Unternehmen wird der Kern dieser Befehle, die sich auf HTML-Dokumente beziehen, immer universeller, während JScript weiterhin mit den Microsoft-eigenen Bereichen, die in Tabelle 4-1 aufgeführt sein, erweitert wird.

Tabelle 4-1. Microsoft-eigene Sammlungen, Funktionen, Objekte und Operatoren.

Es gibt eine Vielzahl von Methoden, Eigenschaften und Anweisungen, die in JScript implementiert wurden und nicht in JavaScript verfügbar sind. Listen dieser Unterschiede finden Sie in den Tabellen in Anhang D, „Kompatibilität mit JavaScript und JScript“.

Die Netscape-Implementierung: JavaScript

Wenn Sie JScript gelernt haben, kann es schwierig werden, mit JavaScript weiterzumachen und ihre besonderen Eigenheiten auseinander zu halten. Es gibt viele Möglichkeiten, Aktionen innerhalb von JScript durchzuführen, die in JavaScript einfach nicht möglich sind. Darüber hinaus gibt es wenige Objekte, Methoden, Eigenschaften oder Anweisungen, die nicht in JScript unterstützt werden. Sie müssen jedoch bedenken, dass Objekte oder Methoden mit demselben Namen in JScript und JavaScript eine ganz andere Funktion haben können. In JavaScript steht nur eine Programmierstruktur zur Verfügung: FileSystemObject.

Gemeinsamkeiten der beiden Browser

Die Skriptgrundlagen sind im Internet Explorer und im Netscape Navigator gleich. Beide JavaScript-Ableger ermöglichen Ihnen, Objekte zu ändern und selbst mit den Aktivitäten des Sitebesuchers oder den Ereignissen innerhalb des Dokuments auf Grundlage des DOM zu interagieren, während Sie weiterhin interaktive Elemente und Animationen in Ihren Dokumenten erstellen können. Diese Unterstützung für einen angepassten Satz mit Ereignissen gibt Ihnen die Möglichkeit, Dokumente zu gestalten, die in ähnlicher Weise in beiden gängigen Browsern interagieren. Da ein Ereignis ein Tastendruck eines Besuchers oder das Laden einer Seite sein kann, können Sie ein Ereignis so einstellen, dass es bei praktisch jeder beliebigen Änderung auf Ihren Webseiten ausgelöst wird oder reagiert.

Beide Browser unterstützen die folgenden Hauptereignisse:

- onMouseMove
- onMouseOut
- onMouseOver
- onBlur
- onClick
- onDblClick
- onFocus
- onMouseDown
- onMouseUp
- onResize
- onScroll
- onChange
- onKeyDown
- onKeyPress
- onKeyUp
- onReset
- onSubmit
- onLoad
- Unload

Im Internet Explorer gibt es viele weitere Ereignisse, die nur hier unterstützt werden und deshalb bei browserübergreifenden Sites vermieden werden sollten. Alle von jedem Browser verwendeten Ereignisse sind in Anhang D aufgeführt.
Neben den gemeinsamen DOM-Objekten und -Ereignissen teilen sich JScript und JavaScript die folgenden programmiersprachenspezifischen Befehle für Objekte, Methoden, Operatoren, Eigenschaften und Anweisungen. Die folgenden Skriptbefehle funktionieren in beiden Browsern. Sie sollten jedoch jeden dieser Befehle gründlich testen. Einige davon führen nämlich in beiden Browsern nicht zum gewünschten Ergebnis.

Befehle für Objekte

- Array
- Date
- FileSystemObject
- Global
- Function
- Math
- Number
- Object
- RegExp
- RegularExpression
- String

Befehle für Methoden

abs(number)
- acos(number)
- anchor(string)
- asin(number)
- atan(number)
- atan2(x,y)
- big()
- blink()
- bold()
- ceil(number)
- charAt(index)
- charCodeAt(index)
- compile(pattern)
- concat(array2)
- CreateTextFile(filename[, overwrite[, unicode]])
- escape(charstring)
- eval(codestring)
- exec(string)
- exp(number)
- fixed()
- floor(number)
- fontcolor(color)
- fontsize(intSize)
- fromCharCode(code1, code2, ..., coden)
- getDate()
- getDay()
- getFullYear
- getHours()
- getMinutes()
- getMonth
- getSeconds()
- getTime()
- getTimezoneOffset()
- getUTCDate()
- getUTCDay()
- getUTCFullYear()
- getUTCHours()
- getUTCMinutes()
- getUTCMonth()
- getUTCSeconds()
- getYear()
- indexOf(string, [i,j])
- isNaN(expression)
- italics()
- join(char)
- lastIndexOf(string, [i,j])
- link(url)
- log(number)
- match(regexp)
- max(num1, num2)
- max(num1, num2)
- parse(datestring)
- parseFloat(string)
- parseInt(string)
- pow(num, power)
- random()
- replace(regexp, string)
- reverse()
- round(number)
- search(string, string)
- setDate()
- setFullYear()
- setHours()
- setMinutes()
- setMonth()
- setSeconds()
- setTime()
- setUTCDate()
- setUTCFullYear()
- setUTCHours()
- setUTCMinutes()
- setUTCMonth()
- setUTCSeconds()
- setYear()
- sin(number)
- slice(i,j)
- small()
- sort(comp.function)
- split(char)
- sqrt(number)
- strike()
- sub()
- substr(start, length)- substring(intA, intB)
- sup()
- tan(number)
- test(string)
- toGMTString()
- toLocaleString()
- toLowerCase()
- toString()
- toUpperCase()
- unescape(string)
- UTC()
Befehle für Operatoren
- Addition (+)
- Addition mit dem Wert (++)
- Bitweises ausschl. ODER (^)
- Bitweises ausschl. ODER mit dem Wert (^=)
- Bitweises NICHT (~)
- Bitweises ODER (|)
- Bitweises ODER mit dem Wert (|=)
- Bitweises UND (&)
- Bitweises UND mit dem Wert (&=)
- Bitweises Verschieben nach links (<<)
- Bitweises Verschieben nach rechts (>>)
- dieser Operator
- Division (/)
- Division mit dem Wert (/=)
- Einheitliche Negation (-)
- Gleichheit (==)
- Größer als (>)
- Größer oder gleich (>=)
- Identität (===)
- Keine Identität (!==)
- Kleiner als (<)
- Kleiner oder gleich (<=)
- Komma (,)
- Konditional (trinär) (?:)
- Logisches NICHT (!)
- Logisches ODER (||)
- Logisches UND (&&)
- Löschen
- Modulo (%)
- Modulo mit dem Wert (%=)
- Multiplikation (*)
- Multiplikation mit dem Wert (*=)
- Negation (-Wert)
- neuer Operator
- Schrittweises Erhöhen (++)
- Subtraktion (-)
- Subtraktion mit dem Wert (-=)
- Typ des Operators
- Ungleichheit (!=)
- Ungültig
- Vergleiche
- Verminderung (--)
- Verschieben nach rechts ohne Vorzeichen (>>>)
- Zusammengesetzte Zuweisung
- Zuweisung (=)

Befehle für Eigenschaften

- $1...$9-Eigenschaften
- arguments
- caller
- E
- global - ignoreCase
- index
- Infinity
- input
- lastIndex
- lastMatch
- lastParen
- leftContext
- length
- LN2
- LN10
- LOG2E
- LOG10E
- MAX_VALUE
- MIN_VALUE
- multiline
- NaN
- NEGATIVE_INFINITY
- POSITIVE_INFINITY
- prototype
- rightContext
- SQRT1_2
- SQRT2

Befehle für Anweisungen

- break
- @cc_on
- Comment s
- continue
- do...while
- for
- for...in
- function
- @if
- if...else
- Labeled
- return
- @set
- switch
- this
- var
- with
- while