HTMLWorld - HTML, CSS, JavaScript, PHP, Java, Flash und vieles mehrHTMLWorld:   Home | Impressum |
 

 
 

Anzeige 
 
               Forum
 
 
HTMLWorld » JScript.NET » Änderungen bestehender Syntax

JScript.NET: Änderungen bestehender Syntax

von Jan Winkler

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.

Anzeige

Variablen deklarieren  nach oben

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  nach oben

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.

TypBeschreibung
booleanWerte booleschen Typs. true und false
byteVariablen, Konstanten oder Funktionen können einen einzelnen Byte-Wert ausgeben. Ein Byte entspricht einer Zahl im Bereich von 0 bis 255
charEs kann ein einzelnes Zeichen gespeichert werden. Dabei können alle 65536 Zeichen des Unicode-Zeichensatzes verwendet werden.
decimalDieser 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.
doubleEs 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.
floatfloat 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.
intDamit können Ganzzahlen im Bereich von -2.147.483.648 bis 2.147.483.647 dargestellt werden.
longMit long können sehr große Ganzzahlen im Bereich von -1019 bis 1019 dargestellt werden.
NumberStellt 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.
sbyteMit sbyte können Ganzzahlen im Bereich von -127 bis 127 gespeichert werden.
shortshort speichert ganze Zahlen im Bereich von -32.768 bis 32.767.
StringEntspricht 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.
uintuint stellt ganze Zahlen ohne Vorzeichen im Bereich von 0 bis einschließlich 4.294.967.295 dar.
ulongSpeichert ganze Zahlen im Bereich von 0 bis 1020.
ushortStellt 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?  nach oben

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  nach oben

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  nach oben

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  nach oben

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 heisst ' + 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  nach oben

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  nach oben

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  nach oben

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');



« zurück weiter »
Bewerten

Aus dem JScript.NET Forum ...

zum JScript.NET Forum »

 

JScript.NET

.Autor:Jan Winkler.
. Bewertung:
JScript.NET: Änderungen bestehender Syntax HTMLWorld
(5/5 bei 1 Votes)
.
. Community: 2 Beiträge im JScript.NET Forum .

Navigation

JScript.net und SQL von Raydir

zum JScript.NET Forum »


 
     
 

Anzeige