JScript.net: Änderungen bestehender Syntax

Bei der Verwendung von Variablen, Konstanten und Objekten etc. hat sich einiges getan. Variablen müssen deklariert und wenn möglich mit einem Typ beschrieben werden, es gibt jetzt Konstanten (wie in JavaScript 1.5 auch schon vorgestellt in JScript bisher aber noch nicht übernommen) und Objekte kann nun auch ganz anders erstellt werden.

Variablen deklarieren

Wie bereits mehrmals erwähnt sollten Variablen nun immer deklariert werden. Dies geschieht - wie bisher auch - über die var-Anweisung. Ihr folgt der Name der Variablen sowie eventuelle weitere Variablendeklarationen, die durch Kommata getrennt werden - die gewöhnliche Syntax also. Alternativ kann auch hier schon der Variablen ein Wert zugewiesen werden. Neu ist, dass Variablen nun auch typisiert sein können. Typisierte Variablen bringen zum einen einen Geschwindigkeitsvorteil erschweren jedoch die Programmierung für alle die, die es gewohnt sind untypisierte Variablen zu verwenden. Der Unterschied zwischen beiden ist recht simpel: Typisierte Variablen können nur Werte eines bestimmten Datentyps annehmen, wie z.B. Zahlen, Zeichen oder boolesche Werte. Bei typisierten Variablen wird bei der Deklaration der zu verwendende Datentyp durch einen Doppelpunkt getrennt an den Variablennamen angehängt. Beispiel:

var VariableA;
var VariableB = 123;
var VariableC : int;
var VariableD : String = 'typisierte Variable';
var VariableE:Object, VariableF : Object = new Object();

print(VariableB);
print(VariableD);

Im Beispiel werden 6 Variablen erstellt, wovon die ersten beiden untypisiert sind. Ihnen können Werte jeglichen Typs zugewiesen werden. Dahingegen sind die restlichen Variablen typisiert und können dementsprechend nur Werte des definierten Typs annehmen. Im Beispiel wird auch die Methode print verwendet. Sie ist eine der wichtigsten Methoden und gibt den ihr übergebenen Inhalt aus.

Datentypen

Das .NET-Framework stellt eine Reihe von Datentypen zur Verfügung. Darüber hinaus können Variablen und Konstanten natürlich auch einem selbstdefiniertem Typ angehören. Folgende Datentypen sind definiert.

Typ	Beschreibung
boolean	Werte booleschen Typs. true und false
byte	Variablen, Konstanten oder Funktionen können einen einzelnen Byte-Wert ausgeben. Ein Byte entspricht einer Zahl im Bereich von 0 bis 255
char	Es kann ein einzelnes Zeichen gespeichert werden. Dabei können alle 65536 Zeichen des Unicode-Zeichensatzes verwendet werden.
decimal	Dieser Typ kann sehr große Dezimalzahlen oder Dezimalzahlen mit sehr vielen Kommastellen annehmen. Es können die Zahlen von -1028 bis 1028 mit einer Genauigkeit von bis zu 28 signifikanten Stellen verwendet werden.
double	Es können Zahlen im Bereich von -10323 bis 10308 dargestellt werden mit einer Genauigkeit von etwa 15 Stellen. Außerdem können die Werte NaN (not a number), positiv und negativ unendlich sowie die positive und negative 0 dargestellt werden.
float	float speichert Zahlen von -1044 bis 1038 mit einer Genauigkeit von 7 Stellen. NaN (not a number), negativ und positiv unendlich sowie die negative und positive 0 können ebenfalls dargestellt werden.
int	Damit können Ganzzahlen im Bereich von -2.147.483.648 bis 2.147.483.647 dargestellt werden.
long	Mit long können sehr große Ganzzahlen im Bereich von -1019 bis 1019 dargestellt werden.
Number	Stellt Zahlen im Bereich von -10323 bis 10308 mit einer Genauigkeit von 15 Stellen dar. Ebenfalls enthalten sein können NaN (not a number), positiv und negativ unendlich sowie die positive und negative 0.
sbyte	Mit sbyte können Ganzzahlen im Bereich von -127 bis 127 gespeichert werden.
short	short speichert ganze Zahlen im Bereich von -32.768 bis 32.767.
String	Entspricht dem bekannten String aus JavaScript . Der Datentyp kann eine Menge von Zeichen speichern. Minimale Länge ist 0 - maximale Länge liegt bei ca. 2 Mrd. Zeichen. Jedes Zeichen muss dem 16-Bit-Unicode-Zeichensatz entsprechen.
uint	uint stellt ganze Zahlen ohne Vorzeichen im Bereich von 0 bis einschließlich 4.294.967.295 dar.
ulong	Speichert ganze Zahlen im Bereich von 0 bis 1020.
ushort	Stellt ganze Zahlen im Bereich von 0 bis 65.535 dar.

Bitte beachten Sie, dass die Typen String und Number die einzigen sind, die groß geschrieben werden.

Neu ist auch, dass jeder Name einer dieser Datentypen gleichzeitig als Funktion zur Umwandlung bzw. Erstellung eines Wertes dieses Datentyps verwendet werden kann. Notiert man den Namen des Datentyps als Funktion, so wird z.B. aus dem String 34 ein Integer (Ganzzahl) gemacht. Beispiel:

var a = 0;
a = int('34');
a += 3;
print(a); //ergibt 37 da 34 + 3 = 37

var b = 0;
b = '34';
b += 3;
print(b); //ergibt 343 da zum String '34' die 3 hinzugefügt wird

Welchen Datentyp für was?

Wie Sie sicher bereits festgestellt haben überlagern sich die meisten Datentypen mehr oder weniger. Bei der Mehrzahl der Datentypen handelt es sich um Zahlenbereiche - mal mit und mal ohne Vorzeichen; mal mit höherer und mal mit geringerer Genauigkeit. Aber wozu so viele Zahlentypen? Die Antwort liegt im Speicherverfahren mit dem Variablen dieses Typs behandelt werden. Je höher die Genauigkeit ist und je mehr Zahlen der Bereich umfaßt um so mehr Informationen müssen über diese Zahl gespeichert werden. Für einfache Anwendungen, wie Sie sie hier finden werden, reichen die Datentypen String, int, Number und boolean. int und Number benötigen 4 bzw. 8 Byte zur Speicherung und sind damit relativ klein. Ein String benötigt pro Zeichen 2 Byte und boolean benötigt insgesamt nur ein Byte (bzw. wird gleich im System mitgezählt als ein Bit). Im Gegensatz dazu braucht decimal 12 Byte - und ist damit der größte Datentyp vom Speicherbedarf her. Objekte brauchen - je nach "Inhalt" - wesentlich mehr.

Konstanten

Erstmals mit JScript.NET sind in JScript auch Konstanten verfügbar. Auch sie können typisiert oder untypisiert sein. Konstanten werden wie bereits in JavaScript mit der const-Anweisung definiert werden und folgen der Syntax einer Variablendeklaration. Ihnen muss bei der Definition ein Wert zugewiesen werden der dann nicht mehr geändert werden kann. Beispiel:

const KonstanteA = 123;
const KonstanteB : int = 456;
const KonstanteC : String = 'Ich bin konstant!';

Enumeratoren - ein neuer Typ

Ein ganz neuer Datentyp sind die Enumeratoren. Man kann Sie sich im Prinzip wie ein Array oder Objekt vorstellen sind aber nicht während der Laufzeit erweiterbar und besitzen in diesem Sinne auch keine Methoden. Im Grunde könnte man sie also als eine Art Zusammenfassung von Konstanten zu einer Konstanten verstehen. Ein Enumerator wird durch die enum-Anweisung erzeugt. Danach folgt ein selbstvergebener Name unter dem der Enumerator angesprochen werden kann. Letztlich folgt innerhalb von geschweiften Klammern die Definition der einzelnen Einträge des Enumerators. Diese werden durch einen Namen definiert und durch Kommata voneinander getrennt. Ein einfacher Enumerator könnte z.B. so aussehen:

enum Anreden
{
Herr,
Frau,
Familie
}

Der so erstellte Enumerator kann dann als Datentyp für eine Variable verwendet werden. Die Variable selbst kann dann nur die vorgegebenen Werte des Enumerators annehmen. Beispiel:

var an : Anreden;
an = Anreden.Herr;

//oder gleich:
var an : Anreden = Anreden.Herr;

print(int(an) + ': ' + an); // 0: Herr
an = "Frau";
print(int(an) + ': ' + an); // 1: Frau
an = 2;
print(int(an) + ': ' + an); // 2: Familie

Wie am obigen Beispiel ersichtlich, wird dann auch der Zugriff auf die Werte eines solchen Datentyps geregelt: Man notiert den Namen des Datentyps, einen Punkt sowie anschließend den zu verwendenden Wert. Die Syntax entspricht somit in etwa der von Objekten - sollte soweit also bereits bekannt sein. Außerdem kann auch ein String, der den Namen eines Werte repräsentiert, oder der Index eines Eintrags notiert werden.
Grundsätzlich wird intern zum Verarbeiten der Enumerator-Werte eine Art Zahlenliste erstellt, wobei jeder Wert des Enumerators eine eindeutige Zahl zugewiesen bekommt. Der erste Wert hat so den Index 0 (Null), der zweite 1, der dritte 2 usw. Soll ein anderes Zählverfahren verwendet werden, muss der Datentyp des Enumerators angegeben werden. Hier sind nur Zahlentypen mit Ganzzahlen (int, short, byte, long, uint, ushort, sbyte und ulong) verwendbar, die wie bei Variablendeklarationen durch einen Doppelpunkt vom Namen des Enumerators getrennt notiert werden. Wird kein Datentyp im speziellen Ausgewiesen, wird int verwendet. Zusätzlich kann auch der Index der Einträge selbst bestimmt werden indem nach dem Namen eines Eintrags eine Zuweisung mit einer Zahl erfolgt. Beispiel:

enum Anreden : byte
{
Herr = 1,
Frau = 2,
Familie = 4
}

var an : Anreden = Anreden.Herr | Anreden.Frau;
var s : String;
s = '';

print('Ein Brief an:');

if(an amp; Anreden.Herr){s += 'Herrn ';}
if(an == 3){s += 'und ';}
if(an & Anreden.Frau){s += 'Frau ';}
if(an & Anreden.Familie){s += 'Familie ';}

print(s); // Ein Brief an: Herrn und Frau

Wie am Beispiel erkennbar, können Enumerator-Datentypen auch zu einem neuen Wert verknüpft werden. Es ergibt sich somit eine quasi Mehrfachauswahl von Einträgen.

Objekte erstellen

Bei der Erstellung von eigenen Objekten hat sich soweit nichts geändert. Eigene Objekte können immer noch mit Hilfe einer Funktion erstellt werden. Innerhalb der Funktion können immer noch mit this Eigenschaften, Methoden und Unterobjekte definiert werden. Ebenso können auch weiterhin Prototypen verwendet werden, wie bereits im Kapitel zu JavaScript Objekte n beschrieben. Soweit ist also alles beim Alten.
Neu ist die Erstellung von Objekten, die auf Klassen basieren. Klassen sind sozusagen Schablonen für neue Objekte die weitaus flexiblere und anpassbarere Möglichkeiten zur Definition von Objekten bieten. Ein Objekt, das von einer Klasse abgeleitet werden soll wird ebenso initialisiert wie es bei normalen Objekten auch der Fall ist: Mit dem new-Operator. Beispiel:

class Person
{
var name : String;
var alter : int;
}
var a : Person = new Person;
a.name = 'Frank';
a.alter = 42;
print('Die Person heißt ' + a.name +' und ist '+a.alter+
' Jahre alt.');

In diesem Beispiel wird die Klasse Person definiert, die die Eigenschaften name und alter besitzt. Es wird eine Variable a erzeugt, die von ebendiesem Typ abgeleitet wird und dementsprechend die Eigenschaften besitzt. Wie Sie Klassen definieren, wird in einem späteren Kapitel erläutert werden - hier soll es erstmal soweit ausreichend sein zu wissen, dass Person eine Klasse ist.

Funktionen

Wie sollte es anders sein - natürlich sind auch Funktionen von den Änderungen bei JScript.NET betroffen. Prinzipiell können Sie zwar immer noch so deklariert werden, wie es bisher der Fall war, aufgrund der Typisierung müssen nun jedoch zusätzliche Angaben in den Funktionskopf eingebunden werden.
Gibt eine Funktion einen Wert wieder (return), kann der Datentyp des Rückgabewerts benannt werden. Dies geschieht durch einen Doppelpunkt getrennt nach der schließenden Klammer der Parameterdefinition. Beispiel:

function a() : String
{
return ('Dies ist JavaScript!');
}
print(a());

Gleiches geschieht bei Parametern. Auch hier wird nach dem Namen der Datentyp durch einen Doppelpunkt getrennt angeschlossen. Vorteil: Es können nur Werte eines bestimmten Typs übergeben werden, womit ausgeschlossen ist, dass ein falscher Wert in die Funktion gelangt. Beispiel:

function plus(x:int, y:int) : int
{
return(x+y)
}
print(plus(3,'4'));

Schleifen und Kontrollstrukturen

Bei diesen Dingen hat sich im Grunde nichts geändert. Hier treffen lediglich einige Dinge bezüglich der Verwendung von Datentypen zu. So sollte z.B. im Kopf einer for-Schleife die Zählervariable mit einem Datentyp belegt werden. So wird aus ursprünglich ...

for(i=0; i<10; i++){/* ... mach was ... */}

... eben das gleiche mit Zuweisung der Datentypen:

for(var i:int = 0; i<10; i++){ /* ... mach was ... */ }

Wurde die Variable i vorher schon deklariert, braucht das natürlich auch nicht mehr in der Schleife getan werden. Letztlich ist dies also keine allzugroße Änderung.

Debugger

Ganz neu ist auch die debugger-Anweisung. Sie macht im Grunde nichts anderes als den installierten Debugger zu starten. Beispiel:

debugger;
print('Willkommen in JScript.NET');

Du arbeitest in einer Agentur oder als Freelancer?
Dann wirf doch mal einen Blick auf unsere Software FeatValue.

Weiterlesen: ⯈ Arbeiten mit Klassen

Über uns

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

JScript.net: Änderungen bestehender Syntax

Über uns

Cookie-Einstellungen