JavaScript – M+T Pocket . Das Programmier-Handbuch (Office Einzeltitel) [Taschenbuch]

6.1
Variablen, Datentypen und Literale

Ein Literal ist in einer Programmiertechnik eine Darstellung
eines eindeutig festgelegten und unveränderlichen Werts. Etwa die Ganzzahl 42 oder die
Gleitkommazahl 3.14
oder der Text (String) "Nix
is". Ein Literal ist also ein Wert, der entweder selbst
verwendet oder einer Variablen zugewiesen werden kann. Variablen gehören zu den wichtigsten Charakteristika einer Programmiertechnik. Variablen
bezeichnen in der Mathematik Platzhalter, die verschiedene Werte aufnehmen
können. Technisch gesehen sind Variablen benannte Stellen im Hauptspeicher, in
denen irgendwelche Werte temporär gespeichert werden können. Etwa ein Passwort,
das ein Anwender eingibt und das in der Variablen zwischengespeichert wird, um
es später zu überprüfen. Die Anzahl der Versuche, um das richtige Passwort
einzugeben, kann ebenso in einer Variablen gespeichert werden. Jeder falscher
Versuch bewirkt beispielsweise, dass der Wert in der Variablen um den Wert 1 erhöht wird.
Irgendwann kann dann über einen Grenzwert festgelegt werden, dass nicht weiter
versucht werden kann, das Passwort einzugeben. Ein weiteres Einsatzgebiet für
Variablen ist die Aufnahme des Ergebnisses einer Berechnung, das an späterer
Stelle in dem Script verwendet werden soll.

6.1.1
Variablenbezeichner

Der Namen oder Bezeichner einer Variable muss in JavaScript (wie in jeder Programmiertechnik) einigen Regeln
genügen. Diese Regeln sind in JavaScript sehr locker. Es gelten folgende Maxime
für die Benennung von Variablen unter JavaScript:

1.
Das erste Zeichen eines Variablenbezeichners muss ein Buchstabe oder der
Unterstrich _ sein

2.
Es darf keines der in JavaScript gültigen Schlüsselworte als Bezeichner
verwendet werden.

3.
Ein Bezeichner darf keine Leerzeichen enthalten.

JavaScript unterscheidet streng zwischen Groß- und
Kleinschreibung. Die Variablen A und a sind nicht (!!) identisch.

Ob nun ein Bezeichner einer Variablen aus Groß- oder Kleinbuchstaben
besteht oder man diese mischt, das ist im Prinzip egal. Allgemein hat sich aber
durchgesetzt, einen Variablenbezeichner mit einem Kleinbuchstaben zu beginnen
und bei zusammengesetzten Bezeichnern jedes neue Teilwort mit einem
Großbuchstaben zu beginnen. Etwa so:

zaehleWert

browserVersion

mitteilungsFenster

Oft werden Variablenbezeichner auch – möglichst sprechend –
abgekürzt. Man muss im Hinterkopf behalten, dass JavaScript zu
interpretierender Klartext ist und jedes Zeichen, welches im Script steht, das
Script und/oder die Webseite vergrößert (das gilt auch für Leerzeichen,
Tabulatoren oder Zeilenumbrüche). Da das Internet ja (zumindest zu Stoßzeiten)
ein katastrophal langsames Netzwerk ist, gehören Webseiten zu klein und
effektiv wie möglich entwickelt, um halbwegs erträgliche Übertragungszeiten zu
gewährleisten[12].
Wenn man etwa bei einem Bestellformular die Stückzahl einer Ware (etwa einer
Hose) in einer Variablen speichern wollte, wäre stzHose eine halbwegs sprechende und
dennoch nicht zu große Variablenbezeichnung.

6.1.2
Datentypen und Deklarierung

Zu den Kerncharakteristika von Variablen (aber auch
Literalen) wird immer ein so genannter Datentyp gezählt. Dieser gibt die Größe
der Variable im Hauptspeicher an und wie mit dieser bei einer Operation zu
verfahren ist.

In JavaScript wird – analog wie in den meisten
Scriptsprachen, aber abweichend von der Vorgehensweise bei strengeren
Programmiersprachen wie Java – bei der Deklaration (das bedeutet die erste
Einführung) einer Variablen nicht explizit über ein Schlüsselwort ein Datentyp
festgelegt. Eine Festlegung des Datentyps erfolgt implizit durch die Art von
Wert, die der Variablen irgendwann zugewiesen wird. Bei einer erneuten
Zuweisung mit einem andersartigen Wert verändert sich sogar der Datentyp der
Variable während der Laufzeit des Scripts. Die Datentypen werden also intern
von JavaScript verwaltet.

Ein Datentyp bedeutet technisch die Festlegung der Anzahl
von Bits, die für eine Variable im Hauptspeicher reserviert werden. Dies hat
die Konsequenz, dass damit auch festgelegt ist, wie viele Zeichen in einer
Variablen dieses Typs gespeichert werden können. Neben wir eine Variable, die
einen Datentyp hat, der ein Byte (8 Bit) groß ist. In einem Byte können genau 2
hoch 8 = 256 verschiedene Zeichen oder Werte gespeichert werden. Dies können
beispielsweise die Zahlen von 0 bis 255
sein. Wenn größere Zahlen oder mehr Zeichen in der Variablen gespeichert werden
sollen, kann dies nicht in einer Variablen dieses Datentyps geschehen – es ist
einfach nicht genug Platz im Hauptspeicher dafür reserviert. Man muss für die
Variable einen größeren Datentyp verwenden.

JavaScript besitzt vier Hauptdatentypen und zwei
Sonderdatentypen, die aber – wie gerade besprochen – in JavaScript implizit
verwaltet werden. JavaScript unterstützt folgende vier Grundtypen von Variablen
(die ersten vier) sowie die am Ende der Tabelle notierten Sonderdatentypen:

Datentyp

Beschreibung

Boolean

Werte vom Typ Boolean (auch Boolesche Werte genannt – nach dem Mathematiker George Boole) sind Wahrheitswerte, die nur einen der beiden Werte true
oder false
(wahr oder falsch) annehmen. Solche Variablen werden im Rahmen von
Vergleichen genutzt.

Number

Dieser Variablentyp kann sowohl Ganzzahlwerte als auch Gleitkommawerte enthalten. Dies ist recht ungewöhnlich, denn in den meisten
Programmiersprachen werden diese Typen getrennt. Meist gibt es dort sogar
mehrere Typen für ganze Zahlen und auch Kommazahlen. Dabei muss man mit dem
Begriff »Kommazahl« in JavaScript aufpassen, denn diese werden in JavaScript
anstelle eines Kommas einen Punkt verwenden, um den Nachkommateil
abzutrennen. Neben der normalen Zahlenschreibweise ist die wissenschaftlich Notationsmöglichkeit
über die Angaben e
oder E. In
diesem Fall wird der Potenzwert hinter dieser Expotentialkennzeichnis
notiert. In JavaScript können Variablen vom Typ Number nicht nur dezimal, sondern auch
oktal (mit einer führenden 0
eingeleitet) oder hexadezimal (eingeleitet durch das Präfix 0x) dargestellt
werden.

Object

Der allgemeine Datentyp Object kann einen Wert eines beliebigen Typs enthalten. Er wird für das Speichern von Objekten verwendet.

String

Dieser Variablentyp steht für eine Zeichenkettenvariable und kann eine Reihe von alphanumerischen Zeichen enthalten. Maximal sind 256 in
einer Zeichenkette erlaubt. Bei Bedarf können aber mehrere Zeichenkette mit
dem Operator +
verknüpft werden. In einer Zeichenkette können alphanumerische Zeichen auch
maskiert (verschlüsselt) werden. Insbesondere ist so etwas notwendig, wenn in Zeichenkettenvariablen Sonderzeichen wie Hochkommata, Tabulatoren, oder einen Zeilenumbruch enthalten sollen. Diese kann man nicht direkt eingeben, da sie
in der Regel eine Steuerfunktion unter JavaScript oder im Editor haben. Sie
müssen maskiert werden, was so ja auch aus HTML bekannt ist. Maskierte
Zeichen werden in JavaScript durch das Zeichen eingeleitet, gefolgt von einem
Buchstaben, der das Steuerzeichen beschreibt (im Fall einer Escape Sequenz). Die Zeichen können auch mit Unicode-Sequenzen dargestellt werden. Die Sequenz n (bzw. u000A) steht im
Rahmen einer JavaScript-Ausgabe für einen Zeilenumbruch, f (bzw. u000C) ist ein
Wagenrücklauf, b
(bzw. u0008)
bedeutet Backspace, r
(bzw. u000D)
einen Carriage Return, t
(bzw. u0009)
das Tabulatorzeichen, v
(bzw. u000B)
der vertikale Tabulator, \
für Backslash (bzw. u005C) ‚ (bzw. u0027) ein einfaches
Anführungszeichen und
" (bzw. u0022) ein doppeltes Anführungszeichen.

undefined

Der Datentyp beschreibt eine nichtdefinierte Situation.
Eine Variable besitzt so lange diesen Wert, bis ihr nach dem Anlegen explizit
ein Wert zugewiesen worden ist.

null

Dieser Sonderdatentyp entspricht der Situation, wenn
ein Objekt noch keinen Wert hat und entspricht "keiner Bedeutung"
oder Null. Das ist durchaus ein sinnvoller Wert, der sich von einer leeren
Zeichenkette oder der Zahl 0
unterscheidet. Der Datentyp null kann beispielsweise zurückgegeben werden, wenn in
einem Dialogfenster mit ABBRECHEN-Schaltfläche diese betätigt wird.

Tabelle 6.1: Die Datentypen von JavaScript

Grundsätzlich muss eine Variable vor ihrer ersten Verwendung
deklariert, d.h. eingeführt und im Script bekanntgemacht werden. Dies erfolgt
in JavaScript allgemein mit folgender Syntax:

var [Variablenbezeichner];

Das Wort var ist ein JavaScript-Schlüsselwort, das die Deklaration der Variablen einleitet. Nun gehört JavaScript aber zu einem Typ von Sprachen, der als lose typisiert bezeichnet
wird. Dies hat einmal die Folge, dass eine Variable auch dann entstehen kann,
wenn einem neuen Bezeichner einfach nur ein Wert zugewiesen wird (auch ohne das
Schlüsselwort var
voranzustellen). Die positive Auswirkung ist, dass sich ein JavaScript-Programmierer
wenig Gedanken um Variablen machen muss. Er kann einfach einen Begriff zu einer
Variablen machen, indem dem Begriff ein Wert zugewiesen wird. Das bedeutet,
dass Variablen nicht explizit deklarieren werden müssen. Der Preis für so eine
Bequemlichkeit (denn nicht mehr und nicht weniger ist das) ist aber extrem hoch
und kann massivste Fehler nach sich ziehen, wenn man nicht wie ein Schießhund
aufpasst. Das und die allgemeine Deklaration von einer Variablen soll mit einem
kleinen Beispiel deutlich werden.

<HTML>

<BODY>

<SCRIPT
language="JavaScript">

var meineVariableDieEinenWertBekommt;

meineVariableDieeinenWertBekommt = 1 + 1;

document.write("Ergebnis der Berechnung: "

+ meineVariableDieEinenWertBekommt);

</SCRIPT>

</BODY>

</HTML>

Listing 6.1: Probleme der lockeren
Variablendeklaration bei JavaScript

Was macht das Beispiel? Es führt eine Variable ein,
berechnet die hochkomplizierte 😉 Aufgabe, was 1 + 1 ist und speichert das Ergebnis in
einer Variablen. Anschließend wird die im Script eingeführte Variable
ausgegeben. Nur, was wird als Ergebnis von 1 + 1 ausgegeben? undefined!

Das Beispiel enthält einen brutalen Leichtsinnsfehler, der
in strengeren Programmiersprachen zu einem Laufzeitfehler führen würde. Hier in
JavaScript wird das Script ohne Fehlermeldung durchgeführt, was aber kein
Vorteil ist. Das Script arbeitet falsch, was viel schlimmer ist, denn vielfach
wird ein solcher Fehler nicht bemerkt und falls doch, nur schwer gefunden.
Haben Sie den Fehler entdeckt? Die Lösung ist, dass die mit

var meineVariableDieEinenWertBekommt;

eingeführte Variable nicht (!) das Ergebnis der Berechnung
zugewiesen bekommt. Die Variable, welche das Ergebnis aufnimmt, heißt meineVariableDieeinenWertBekommt
(ein kleines e
bei einen).
JavaScript unterscheidet Groß- und Kleinschreibung! Die Wertzuweisung erzeugt
eine neue (!) Variable und die vorgesehene Variable bleibt ohne gültigen Wert –
sie ist undefiniert. Ausgegeben wird aber wieder diese zuerst eingeführte
Variable.

Ein wenig wird die Situation durch eine Syntaxregel von
JavaScript wieder entschärft. Jede Variable muss vor ihrer ersten Verwendung
(!) initialisiert (mit einem Vorgabewert belegt) werden, was dann oft im
Fehlerfall auch eine sinnvolle Fehlermeldung bewirkt. Diese Initialisierung
einer Variablen unter JavaScript wird einfach mit einer Wertzuweisung
durchgeführt, wie es in unserem Beispiel erfolgt ist. Aber auch eine reine
Einführung mit var
initialisiert eine Variable mit einem gültigen Defaultwert. Eben undefined und das
genügt.

In dem letzten Beispiel wurde einer Variablen ein Wert
zugewiesen. Dies nennt man eine Wertzuweisung. Eine Wertzuweisung erfolgt in
der Regel, dass auf der linken Seite eine Variable steht, dann das
Gleichheitszeichen und dann auf der rechten Seite der Wert, eine Berechnung
eines Wertes oder eine Funktion, die einen Rückgabewert liefert. Grundsätzlich
kann sowohl beim Anlegen einer Variablen als auch später im Laufe des
Scriptablaufs ein Wert zugewiesen werden. Sehr oft wird einer Variablen bei der
Deklaration auch gleich ein Initialisierungswert zur Vorbelegung zugewiesen
werden. Dies erfolgt allgemein mit folgender Syntax:

var [Variablenbezeichner] = [Wert];

Der Wert einer Variablen zur Laufzeit wird einfach durch
Zuweisung eines neuen Wertes über ein Gleichheitszeichen verändert. Dabei
können auf der rechten Seite direkt Werte, aber auch Ausdrücke mit Wertrückgabe
(Berechnungen, Funktionen, etc.) stehen. Es gibt aber zahlreiche Feinheiten,
die noch gesondert behandelt werden (siehe Seite 104).

Wir testen nun noch die verschiedenen Variablendatentypen in
einem Beispiel:

<HTML>

<BODY>

<SCRIPT
language="JavaScript">

var a = true;

var b = 1;

var c = 3.14;

var d = 1.123E2;

var e = 7e-2;

var f = "Wo ist mein Handtuch";

var g = new Date();

document.write(a +
"<BR>");

document.write(b +
"<BR>");

document.write(c +
"<BR>");

document.write(d +
"<BR>");

document.write(e +
"<BR>");

document.write(f +
"<BR>");

document.write(g);

</SCRIPT>

</BODY>

</HTML>

Listing 6.2: Deklaration von Variablen mit
verschiedenen Datentypen

6.1.3
Casting

In JavaScript ergibt sich wie gesagt der Datentyp einer
Variablen implizit durch die Zuweisung eines bestimmten Werts. Nun kann es aber
passieren, dass eine Variable zuerst einen Wert eines bestimmten Typs (etwa
eine Zahl) beinhaltet und ihr dann ein Wert eines anderen Typs (etwa Text)
zugewiesen wird. Das wirft Probleme auf. Offensichtlich ist, dass Text ab ein
paar Buchstaben mehr Platz im Hauptspeicher benötigt als jede Zahl[13].
Variablen sind ja nur Stellen im Hauptspeicher. Die Umorganisation und
Verwaltung des Hauptspeichers muss von der Plattform gemanagt werden, was nicht
gerade trivial ist. Ein anderes Problem tritt bei der Verbindung von Werten mit
verschiedenen Datentypen auf. Wenn zwei Werte gleichen Typs miteinander
verbunden werden, ist die Vorgehensweise meist logisch. So ist die
Multiplikation von zwei Zahlen (etwa 3 * 4) ziemlich eindeutig. Wie aber
sollen sich Variablen verhalten, wenn sie miteinander verknüpft werden und
nicht vom gleichen Datentyp sind? Etwa, wenn ein Text mit einer Zahl verknüpft
wird. Was ist das Ergebnis von von "Schulze" * 7? Und von welchen
Datentyp ist das Ergebnis? Das mag zwar unsinnig erscheinen, aber genau so
etwas wie Ihr Empfinden, dass das Unsinn ist, muss in die Syntax einer
Programmiersprache implementiert werden. Und auch die Situationen, wo eine
Verbindung von verschiedenen Typen sinnvoll ist. So kann man etwa einen Text
mit einer Zahl auch sinnvoll verknüpfen. Was ist das Ergebnis von von "Schulze" + 7
und von welchen Datentyp ist das Ergebnis? Nun, es kommt ein String heraus – "Schulze7".
Das ist eine sehr oft zu findende Situation. Grundsätzlich muss also erklärt
werden, was für Operationen mit welchen Datentypen erlaubt sind.

Grundsätzlich ist bei der Verbindung von verschiedenen
Datentypen ein Vorgang notwendig, der Casting oder Typkonvertierung genannt wird. Dies bedeutet die Umwandlung von einem Datentypen in einen anderen
Datentypen. Prinzipiell unterscheidet man in der Programmierung zwei
unterschiedliche Arten von Konvertierungen:

Ad hoc-Typkonvertierungen

Explizite Typkonvertierungen

Explizite Konvertierungen werden nur von sehr
leistungsfähigen Programmiersprachen unterstützt. Etwa Java. Bei expliziten
Konvertierungen löst der Programmierer mittels einer dafür von der
Programmiersprache bereitgestellten Syntax selbst eine Umwandlung in einen
anderen Datentyp aus. JavaScript unterstützt solches explizites Konvertieren
nicht, was auch schon deshalb logisch ist, weil ja schon bei der Deklaration
gar kein Datentyp explizit angegeben wird. Es gibt allerdings in JavaScript
einige Funktionen und Methoden, die indirekt eine explizite Typkonvertierung
innerhalb enger Grenzen erlauben. Dies sind beispielweise parseInt() und parseFloat(), Number() oder eval(). JavaScript verwendet ansonsten Ad-hoc-Typkonvertierungen. Dabei werden bei der Auswertung von Ausdrücken, in denen Variablen oder Werte verschiedenen Datentyps miteinander verbunden
werden, durch den Interpreter die eventuell notwendigen Typkonvertierungen
automatisch durchgeführt.

Ad-hoc-Konvertierungen sind prinzipiell nicht ungefährlich.
Wenn eine Konvertierung von einem Datentyp mit mehr Informationen in einen mit
weniger Informationen automatisch durchgeführt wird (etwa ein Zahl mit
Nachkommastellen wird in eine Ganzzahl konvertiert), kann Information verloren
gehen. Je nach Strenge einer Sprache werden automatische Konvertierung deshalb
nur innerhalb sehr enger Grenzen durchgeführt. Java ist beispielsweise eine
extrem strenge Sprache, wo eine automatische Konvertierung nur dann
stattfindet, wenn keine Informationen verloren gehen können. Bei JavaScript
wird das Verfahren etwas lockerer gehandhabt. Wenn die übrige Syntax darauf
schließen lässt, dass die Konvertierung sinnvoll ist, wird sie meist so
sinnvoll wie möglich durchgeführt. Dennoch – es können unter Umständen
Informationen verlorengehen. Etwa bei einer Konvertierung von einer als String
gespeicherten Telefonnummer mit führender Null in eine Zahl. Die führende Null
oder auch Nullen (bei einer Auslandnummer) wird bzw. werden verschwinden
(Zahlen werden in JavaScript, wie auch den meisten anderen Sprachen so
dargestellt), was durchaus ein Informationsverlust bedeutet.

Ein weiteres Problem von automatischen Typkonvertierungen
ist, dass sie auch dann stattfinden können, wenn es eigentlich nicht sinnvoll
oder gewünscht ist oder aber auch eventuell unterbleiben, obwohl gewünscht. Die
folgenden Beispiele demonstrieren verschiedene Typkonvertierungen und einige
potentiellen Probleme damit.

<html>

<body>

<h1 align=center>Addition von zwei
Zahlen</h1>

<SCRIPT LANGUAGE="JavaScript">

var a = prompt("Geben Sie die erste Zahl
ein","");

var b = prompt("Geben Sie die zweite Zahl","");

document.write(

"Die Addition von ", a, " + ", b,
" ergibt : ");

document.write(a + b);

document.write("<br>");

</SCRIPT>

</body>

</html>

Listing 6.3: Eingabe von zwei Zahlen, die addiert
werden sollen

Das Beispiel öffnet beim Laden nacheinander zwei
Dialogfenster, in denen Sie jeweils eine Zahl eintragen sollen.

Die in den Variablen a und b gespeicherten Eingaben werden dann
addiert werden. Das macht die Zeile

document.write(a + b);

Aber was heißt hier addiert? Die beiden Eingaben werden
nicht nummerisch addiert, sondern als Texte zusammengesetzt.

Der Grund dafür ist, dass die Anwendereingaben von der prompt()-Methode
als Strings zurückgegeben werden. Strings können aber mit dem +-Operator
verbunden werden. Es wird einfach Zeichen für Zeichen aneinander gehängt. Hier
aber ist das so ja nicht gewünscht und man muss zu Konvertierungsfunktionen
oder einem Trick greifen, JavaScript zu überlisten, damit eine automatische
Konvertierung vor der Verbindung mit dem +-Operator durchgeführt wird und die
Benutzereingaben als Zahlen addiert werden. Die Zeile

document.write(a
+ b);

wird dabei durch

document.write(a*1
+ b*1);

ersetzt. Die Multiplikation verändert nicht den Wert einer
nummerischen Eingabe, erzwingt aber die Ad-hoc-Typkonvertierung (ein String,
der nur Zahlen beinhaltet und mit einer Zahl multipliziert wird, wird zu einer
Zahl). Beachten Sie, dass Punkt-vor-Strichrechnung ausgenutzt wird.

Im folgenden Beispiel nimmt eine Variable nacheinander
verschiedene Datentypen an.

<html>

<body>

<SCRIPT
language="JavaScript">

var chamaeleon = 42;

document.write("Gib mir die Antwort: ",
chamaeleon, "<br>");

chamaeleon = "Wie ist die Frage?"

document.write(chamaeleon,"<br>");

chamaeleon = new Date();

document.write("Was ist heute für ein Tag?
", chamaeleon,"<br>");

chamaeleon = 4/5;

document.write("Jemand eine Ahnung, was 4 geteilt
durch 5 gibt? ", chamaeleon);

</SCRIPT>

</body>

</html>

Listing 6.4: Eine Variable, mehrere Datentypen

Das Beispiel verwendet eine einzige Variable. Zuerst ist sie
vom Typ Number
und ganzzahlig, dann String,
danach vom Datentyp Object
und zum Abschluss wieder Number,
aber als Gleitzahl.

6.1.4
Variablenvarianten

Bei Variablen unterscheidet man von der Konzeption
verschiedene Arten, wobei der Ort, wo sie vorhanden sind, die Variante
bestimmt. Für JavaScript spielt im Wesentlichen der Unterschied zwischen
lokaler und globaler Variablen eine Rolle.

Es gibt neben der Unterscheidung in lokale und globale
Variablen auch den objektorientierten Ansatz mit Klassenvariablen und Instanzvariablen. Dieser soll hier nicht weiter verfolgt werden. Wir werden
diese Formen von Variablen aber verwenden, wenn wir mit Objekten arbeiten.
Sie stellen deren Eigenschaften dar.

Globale Variablen werden außerhalb von Funktionen
(Funktionen folgen gleich) bzw. vergleichbaren Konstruktionen deklariert und
stehen in dem gesamten Script (oder genauer – der gesamten Lebenszeit einer
Webseite) zur Verfügung. Sie können damit zum Datenaustausch zwischen
Funktionen oder der dauerhaften (solange eine Webseite im Speicher gehalten
wird) Speicherung von Werten genutzt werden. Das nachfolgende Beispiel nutzt
eine Eingabe in eine globale Variable, die beim Laden der Seite in einer
globalen Variablen abgelegt wurde, um eine Information an eine
JavaScript-Inline-Referenz weiterzugeben.

<html>

<SCRIPT language="JavaScript">

var name=prompt("Gib mir Deinen
Namen","");

</SCRIPT>

<body>

<a href="javascript:alert(‚Hallo
‚ + name)">Klick</a>

</body>

</html>

Listing 6.5: Eine globale Variable dient zur
Weitergabe einer Information

Um mehr Effekte und Anwendungen von globalen Variablen zu
sehen, müssen wir mit Funktionen arbeiten, die im Folgeabschnitt eingeführt
werden (siehe dazu das Beispiel Seite 90). Das gilt auch für lokale Variablen. Lokale
Variablen werden innerhalb von Funktionen bzw. vergleichbaren Konstruktionen
deklariert (explizit mit var
oder erstes Auftauchen des Bezeichners) und können dann auch nur dort benutzt
werden. Dazu gibt es den Fall der schleifenlokalen Variablen, die nur als im Rahmen einer Schleife definiert sind. Lokale Variablen existieren
nur solange im Speicher, wie die verwendende Struktur existiert.

In vielen Situationen kann man sowohl mit globalen als auch
lokalen Variablen arbeiten. Grundsätzlich gilt die Regel, dass die Verwendung
von lokalen Variablen der Verwendung von globalen vorzuziehen ist, sofern die
Situation es erlaubt. Einmal dient es der Übersichtlichkeit, aber noch wichtiger
ist, dass durch die Freigabe des von einer lokalen Variablen belegten Speichers
nach Abarbeitung einer Funktion oder eines Blocks ein Script weniger
Hauptspeicher verwendet. Der Bereich wird wieder freigegeben. Zu guter Letzt
kann ein Variablenbezeichner in einem Script mehrfach verwendet werden. Das
findet man oft bei schleifenlokalen Zählvariablen. Für diese hat sich
eingebürgert, die Bezeichner
i oder j für
eine Zählvariable zu verwenden.

Der konkreten Einsatz von lokalen Variablen sehen wir gleich
bei den Funktionen (siehe dazu wie schon angedeutet
das Beispiel Seite
90).

Die Kommentare wurden geschlossen