Vorschau: JavaScript 2.0

Die letzte JavaScript Version war die Version 1.5 und war schon damals (1999) mehr als überfällig. Schon zu dieser Zeit wurden die Stimmen nach weiteren Verbesserungen der Sprache laut geworden. Bei Netscape setzte sich unterdessen eine Forschungsgruppe zusammen, die die weitere Entwicklung von JavaScript diskutieren und ausarbeiten sollte. Ihr Resultat: JavaScript Version 2.0 an dem nun seit fast 3 Jahren gearbeitet wird.

Java Script Version 2.0 soll Mitte 2003 fertig gestellt werden, die Überlegungen zur Verbeserung von JavaScript gingen (und gehen) allgemein in eine Richtung: Verbesserung durch Anpassung an bekannte Sprachen wie Java oder C/C++. Auf Grundlage dieser Ideen wird derzeit entwickelt und die ersten Ergebnisse lassen schon recht tief in die (neue) Materie einblicken. So sollen u.A. alltbekannte Dinge wie Typen-Deklarationen oder Klassen-Definitionen in die Sprache einfließen. Auch sollte allgemein Objekt-bezogenes Programmieren mehr unterstützt werden. Zu dem, was es derzeit Neues gibt, hier eine kleine Zusammenfassung:

Syntax

Der Syntax wird, wenn er im Grunde eigentlich der gleiche bleibt, doch etwas komplizierter als er ist. Unter Anderem wird nun versterkt auf korrekte Schreibweise (z.B. Semikolon nach einer Anweisung, Verwendung von Klammern) geachtet und es wird neue Statements (z.B. get, set, exclude, include, named, …) geben die verwendet werden können. Ausserdem wird die Verwendung von Einheiten (cm, inch, liter, …) vorangertieben und die Beschreibung von Typen eingeführt. Was die Notation von Abfragen, Schleifen und Funktionen angeht, wird sich im Grunde nicht viel ändern. Beispiel:

var a:Integer;
//Variable a vom Type Integer

a get = function ():Integer{/*code*/; return x;};
a set = function (x):Integer{/*code*/; return true;};
//Funktion zum setzten und lesen der Variablen a

namespace DEF;
//Verwendung von Namespaces
DEF extend(String) function machwas():String {/*code*/}
//Hinzufügen der Eigenschaften/Methoden der Klasse
//String zur Klasse DEF

Attribute

Wie im vorherigen Abschnitt schon beschrieben wird JavaScript um einiges erweitert. Dazu gehören auch eine Reihe von neuen Attributen. Einige Beispiele von neuen Attributen:

• extend – Übernimmt Eigenschaften und Methoden aus einer Klasse in eine andere.

Klasse_A extend(Klasse_B)

• compile – Beschreibt eine Konstante als Compile-Zeit konstant (Konstante die zur Compilierungszeit schon fest stehend ist).

compile const abc = 123;

• final – Beschreibt eine Konstante oder Variable als final/ausgereift (nicht überschreibbar).

final const abc;

• constructor – Definiert einen Constructor (Funktion die zum Erstellen eines Objektes aufgerufen wird) einer Klasse.

constructor function Klasse(){/*…*/}

• abstract, virtual – Deklaration von Funktionen als abstrakt bzw. virtuell (ähnlich anderen Programmiersprachen).

abstract a();
virtual b(){/*…*/}

Getter und Setter

In Mozilla’s aktuellem Browser kann man es schon, wenn auch nicht wie gedacht, testen: getter und setter. JavaScript 2.0 wird durch die Statements get und set (also nicht wie im Mozilla praktiziert getter und setter) erweitert werden. Damit lassen sich das lesen und schreiben von Variablen mit einer Funktion verknüpfen. Beispiel:

function get x():t {return z };
function set x(a:t):Void { z = a}; 

Funktionen

Auch bei Funktionen wird es einige Änderungen geben. Zu diesen gehören z.B. die Definition des Rückgabe- und Parametertyps oder die Beschreibung von optionalen Parameter(-werten). Typen werden, wie bei anderen Programmiersprachen auch, durch einen Doppelpunkt getrennt an die jeweilige Variable bzw. an die Funktion heran geschrieben. Optinale Parameter werden mit einem Ist-Gleich-Zeichen sowie dem alternativen Wert notiert. Beispiel:

function f(a:Integer, b:Integer = a, c:Integer = b):Integer
{
 return a + b + c;
}

f(3); // == 9
f(3, 4); // == 11
f(3, 4, 10); // == 17 

Klassen

Mit JavaScript 2.0 wird erstmalig in JavaScript die Definition von Klassen möglich sein. Was vorher nur über Funktionen und Prototypen zugänglich war wird so klar und einfach definiert. Eine Klasse wird im Prinzip wie vorher ein Objekt definiert: Ein class-Statement gefolgt vom Namen und einem Block mit Eigenschaften und Funktionen dieser Klasse. Beispiel:

class MeineKlasse
{
 var A:Integer = 1;
 function B() {return A;}
 function C() {return A+B();}
} 

Namespaces

Namespaces sind in etwa vergleichbar mit den Namespaces aus XML : Sie definieren eine bestimmte Untermenge an Variablen, Klassen und Funktionen (etc.), die über diesen Namespace aufgerufen werden können (Ähnlich einer Bibliothek). Beispiel:

package My.P1
{
 explicit namespace N;
 N const a = „wert“;
}

use namespace(N); // Importiert namespace N
a; // == „wert“; 

Die neuen Funktionen und Möglichkeiten die in JavaScript 2.0 eröffnet werden werden, allgemein gesehen, mehr Vor- als Nachteile bringen. Dazu zählen z.B. bessere Bedienung, strikteres und damit genaueres Programmieren, Klassen, Packages oder Namespaces. Aber mit vielem Neuen wird es auch kommen, dass die Sprache deutlich schwerer wird. Allein das lesen des JavaScript 2.0 Proposals (Vorschlag des JavaScript Gremiums für die Weiterentwicklung der Sprache) gestaltet sich derzeit schon eher kompliziert als einfach. Mit einem umfasserenden JavaScript werden sicher die meisten freude haben, aber auch viele, die gerade erst damit anfangen wollen, werden ihre Probleme bekommen.

Der Umstieg von 1.5 auf 2.0 wir den meisten Programmierern erstmal Schwierigkeiten bereiten: Neuer Syntax, neue Attribute und Definitionen müssen erlernt und eingeprägt werden. Allerdings gibt es auch eine gute Nachricht: Dadurch dass aus Version 1.5 quasi nichts gestrichen wurde, sondern nur Neues dazu kam, werden die ‚alten Scripte‘ auch unter JavaScript 2.0 lauffähig sein.

Da die Entwicklung von JavaScript noch nicht abgeschlossen ist und immernoch daran gefeilt wird, werden wir in der nächsten Zeit wohl erstmal noch keine Browser sehen können, die die ersten Ansätze von JavaScript 2.0 implementieren. Derzeit befasst sich lediglich der Mozilla mit einigen Neuerungenschaften aus JavaScript 2.0 (siehe „Getter und Setter“), doch dies auch nur in Ansätzen. Es ist jedoch anzunehmen, dass sich dies schlagartig ändern wird, sobald die 2te Version von JavaScript ganz fertig ist.

Mit der Weiterentwicklung von JavaScript wird auch ECMAScript Version 4.0 entwickelt. Auch die neue Version wird wieder ähnlich JavaScript sein. Die Grundzüge beider Sprachen sind nahezu identisch und auf den ersten Blick ließen sich bisher keine Unterschiede erkennen. Was Microsofts JScript angeht so ist es eher fraglich, ob die Redmonder die Linie von JavaScript weiter verfolgen werden oder ‚ihre‘ Sprache weiterhin relativ einfach erhalten wollen. An JScript Version 6.0 wird gearbeitet, soviel ist sicher, wie es sich letztlich entwickeln wird ist aber noch unklar. Die 2te Version von JavaScript bzwECMA4.0 wurde bereits für Mitte 2003 angekündigt – wird aber sicher nochmals verschoben werden.