# Datums- und Zeitfunktionen
Die meiste Zeit geht dadurch verloren, dass man nicht zu Ende denkt.
– Dr. Alfred Herrhausen (1930 – 1989)
# Formatierte Datumsausgabe
Das Objekt Date haben Sie bereits kennen gelernt, und Sie wissen auch, welche Möglichkeiten zur Verfügung stehen, um eine entsprechende Datums- und Zeitausgabe zu ermöglichen. Es verfügt über viele Methoden. Dazu gehören unterschiedliche Arten für die Rückgabe von Werten und zum Festlegen eines Datums und einer Uhrzeit. Jedoch gibt es keine Methode, um den Namen eines Monats zu ermitteln. Zwar könnten Sie diesen mit einer switch-Anweisung herausbekommen, es gibt aber eine elegantere Möglichkeit.
# Arrays
Dafür benötigen Sie ein so genanntes Array (dt. Feld). Das Besondere an einem Array ist, dass es viele Variablen enthalten kann, die über einen Index angesprochen werden. Der Zweck von Arrays ist, dass gleichartige Variablen zusammengefasst werden können. Möchten Sie also die Namen von zehn verschiedenen Bekannten in einer einzelnen Variablen speichern, müssten Sie zehn einzelne Variablen definieren und ihnen einen entsprechenden Wert zuweisen. Sobald es mehr als zehn Bekannte werden, wird dies sehr schnell unübersichtlich und ist mit viel Tipparbeit verbunden. Arrays sind keine Variablen, sondern Objekte, die auf der Klasse Array basieren. Um nun also ein Array-Objekt zu erzeugen, müssen Sie das Schlüsselwort new verwenden.
[Bezeichner] = new Array();
bekannte = new Array();
Bei der Definition eines Arrays können Sie entweder die Größe des Arrays mit einer Zahl festlegen oder die einzelnen Werte, die das Array enthalten soll, durch Kommata getrennt notieren. Die einzelnen Werte eines Arrays werden auch Feld oder Element genannt.
[Bezeichner] = new Array([Größe]);
bekannte = new Array(10);
Die letzte Angabe erzeugt ein Array mit dem Bezeichner bekannte und einer Größe von 10 Feldern.
[Bezeichner] = new Array([Feld1],[Feld2],[Feld3]..[FeldN]);
bekannte = new Array("Conny","Kolja","Christian");
Die letzte Angabe erzeugt ein Array mit dem Bezeichner bekannte und den Feldern "Conny", "Kolja" und "Christian". Bei dieser Variante erhalten die einzelnen Felder des Arrays einen Wert, und die Größe des Arrays wird automatisch auf 3 gesetzt.
Wie bereits erwähnt, wird auf die einzelnen Felder eines Arrays mit einem Index zugegriffen. Dieser Index wird als Zahl in eckigen Klammern nach dem Bezeichner notiert.
bezeichner[Index]
Die Zählung beginnt dabei bei 0. Die Reihenfolge der einzelnen Werte bestimmt sich durch die Reihenfolge, in der sie bei der Erzeugung des Arrays angegeben wurden. So hat z. B. der String "Conny" den Index 0, der String "Kolja" den Index 1 und der String "Christian" den Index 2.
bekannte = new Array("Conny","Kolja","Christian");
name = bekannte[0];
alert(name);
Diese drei Zeilen würden zunächst ein Array mit dem Bezeichner bekannte erzeugen, der Variablen name den Wert des Elements mit dem Index 0 zuweisen und diesen anschließend in einem Dialogfenster ausgeben. Sie können aber auch nachträglich den Wert eines Felds ändern, und zwar mit dem =-Operator. Dabei müssen Sie einfach den Index des zu verändernden Felds angeben und mit dem =-Operator den Wert zuweisen.
bekannte = new Array("Conny","Kolja","Christian");
bekannte[3] = "Stephan";
Das Array ist nun 4 Felder groß. Daraus geht auch hervor, dass ein Array während eines Programmablaufs dynamisch vergrößert werden kann. Dies müssen Sie nicht extra festlegen, stattdessen erfolgt die Vergrößerung automatisch durch die Angabe des Index.
# Monatsnamen ermitteln
Nun komme ich zum eigentlichen Vorhaben zurück, nämlich anhand der Monatszahl den entsprechenden Namen auszugeben. Zunächst benötigen Sie ein Array, in dem Sie die Monatsnamen ablegen.
monate = new Array("Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember");
Dann benötigen Sie ein Objekt der Klasse Date, um die aktuelle Monatszahl ermitteln zu können. Diese Zahl speichern Sie in der Variablen mon.
datum = new Date();
mon = datum.getMonth();
Die Methode getMonth() beginnt bei der Ausgabe der Monatszahl mit 0. Dies kommt uns sehr gelegen, da bei einem Array die Zählung ebenfalls bei 0 beginnt. Sie können die Variable mon dadurch einfach als Index für das Array monate verwenden.
alert(monate[mon]);
Im Vergleich zu dem Beispiel aus Kapitel 22.6, Fallunterscheidung – switch, bei dem Sie den Monatsnamen mit einer switch-Anweisung ermittelt haben, wurde der Quellcode viel kürzer und außerdem übersichtlicher.
# Wochentag ermitteln
Ähnlich wie mit den Monatsnamen verhält es sich auch mit dem Wochentag. Das Date-Objekt verfügt leider über keine Methode, mit der es möglich wäre, den Tag als Namen zu ermitteln, z. B. Montag oder Freitag. Aus diesem Grund erzeugen Sie wieder ein Array mit den Wochentagen.
wochentage = new Array("Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag");
Möglicherweise wundern Sie sich jetzt, warum das erste Feld des Arrays der Sonntag und nicht der Montag ist. Das liegt daran, dass die Methode getDay() bei der Zählung der Wochentage ebenfalls mit Sonntag beginnt. Den entsprechenden Wochentag können Sie nun wie folgt ermitteln:
wochentage = new Array("Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag");
datum = new Date();
wtg = datum.getMonth();
alert(wochentage[wtg]);
# Vierstellige Jahreszahl
Um die Jahreszahl zu ermitteln, kennen Sie bereits die Methode getYear(). Diese liefert im Internet Explorer immer ein vierstelliges Ergebnis. Im Netscape Navigator liefert diese Methode aber eine zweistellige Jahreszahl. Deshalb müssen Sie immer, wenn Sie eine vierstellige Jahreszahl erhalten möchten, die Methode getFullYear() verwenden.
datum = new Date();
jhr = datum.getFullYear();
alert(jhr);
# Kombinierte Ausgabe
Das endgültige Script für die formatierte Datumsausgabe, nach dem Schema
[Wochentag], [Tag]. [Monatsname] [Vierstellige-Jahreszahl]
würde dann wie folgt aussehen:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Formatierte Datumsausgabe //-->
<html>
<head>
<title>Listing 5.1</title>
<script type="text/javascript">
<!--
monate = new Array("Januar","Februar","M�rz","April",
"Mai","Juni","Juli","August","September","Oktober",
"November","Dezember");
wochentage = new Array("Sonntag","Montag","Dienstag",
"Mittwoch","Donnerstag","Freitag","Samstag");
datum = new Date();
wtg = datum.getDay();
tag = datum.getDate();
mon = datum.getMonth();
jhr = datum.getFullYear();
ausgabe = wochentage[wtg]+", der "+tag+". "+monate[mon]+" "+jhr;
document.write(ausgabe);
//-->
</script>
</head>
<body>
</body>
</html>Listing 5.1: Dieses Beispiel gibt ein Datum in einer speziellen Formatierung aus.
Abbildung 5.1: Browserausgabe des Listing 5.1 im Internet Explorer 6.0
Zuerst werden die beiden bereits bekannten Arrays monate und wochentage definiert. Anschließend wird das Objekt datum definiert, das auf der Klasse Date basiert. Nachdem der Wochentag, der Tag des Monats, die Monatszahl und die Jahreszahl ermittelt worden sind, erfolgt die kombinierte Ausgabe im Browser.
# Führende Nullen
Mit »Führende Nullen« sind nicht etwa Vorgesetzte oder gar der Chef gemeint, sondern das Erweitern einer einstelligen Stunden-, Minuten- oder Sekunden-Angabe. Die Methoden getHours(), getMinutes() und getSeconds() geben ja bekanntlich die Stunde, die Minute und die Sekunde einer Uhrzeit zurück. Da die Werte jedoch als Zahlenwert (Integer) und nicht als Zeichenkette (String) zurückgegeben werden, kann es passieren, dass eine Ausgabe der Uhrzeit, die anhand dieser Methoden erfolgte, so aussieht:
9:7:3
Diese Ausgabe der Uhrzeit ist aber unglücklich. Mit einer einfachen Entweder-oder-Abfrage lässt sich dieses Problem geschickt umgehen:
std = (std < 10) ? "0"+std : std;
min = (min < 10) ? "0"+min : min;
sek = (sek < 10) ? "0"+sek : sek;
Bei diesen Entweder-oder-Abfragen wird überprüft, ob der zurückgegebene Wert kleiner als 10 ist. Wenn dies der Fall ist, wird entweder eine 0 vor den Wert gesetzt oder der Wert ganz normal zurückgegeben. Die 0 steht in Anführungszeichen, damit der Wert in einen String umgewandelt wird. Andernfalls würden Sie den Zeitwert einfach mit 0 addieren. Das vollständige Beispiel sieht dann wie folgt aus:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Formatierte Zeitausgabe //-->
<html>
<head>
<title>Listing 5.2</title>
<script type="text/javascript">
<!--
datum = new Date();
std = datum.getHours();
min = datum.getMinutes();
sek = datum.getSeconds();
std = (std < 10) ? "0"+std : std;
min = (min < 10) ? "0"+min : min;
sek = (sek < 10) ? "0"+sek : sek;
document.write(std+":"+min+":"+sek);
//-->
</script>
</head>
<body>
</body>
</html>Listing 5.2: Beispiel zum Erweitern der Zeitwerte um eine führende Null
Abbildung 5.2: Darstellung des Listings 25.2 im Internet Explorer 6.0
# Besuchsdauer
Ein weiterer interessanter Aspekt bei der Verwendung von Objekten, die auf der Date-Klasse basieren, ist es, die Verweildauer des Benutzers auf der Webseite zu ermitteln. Sie benötigen dazu lediglich eine Funktion, die die bisherige Dauer regelmäßig errechnet.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Besuchsdauer //-->
<html>
<head>
<title>Listing 5.3</title>
<script type="text/javascript">
<!--
start = new Date();
startzeit = start.getTime();
function stoppuhr()
{
aktuell = new Date();
zeit = (aktuell.getTime() - startzeit) / 1000;
document.besuch.dauer.value = Math.round(zeit);
setTimeout('stoppuhr()',1000);
}
//-->
</script>
</head>
<body onLoad="setTimeout('stoppuhr()',0)">
<form name="besuch">
Sie sind seit <input name="dauer" size="10"> Sekunden auf dieser Seite.
</form>
</body>
</html>Listing 5.3: JavaScript, das die Verweildauer des Benutzers auf der Webseite ermittelt
Im Script-Bereich des HTML-Dokuments wird zuallererst das Objekt start erzeugt und anschließend mit getTime() die aktuelle Uhrzeit in der Variablen startzeit gespeichert. Dies ist der Ausgangswert und gleichzeitig die Uhrzeit, zu der der Benutzer die Seite aufgerufen hat.
Anschließend folgt die Funktion stoppuhr(). Diese Funktion soll dafür verwendet werden, die Dauer des Besuchs zu errechnen. In dieser Funktion wird erneut ein Objekt der Klasse Date mit dem Bezeichner aktuell instanziiert. Dieses Objekt dient dazu, die im Moment des Funktionsaufrufs aktuelle Uhrzeit auszulesen. In der Variablen zeit wird die Differenz zwischen der Start- und der Ausführungszeit der Funktion gespeichert. Dabei wird die Startzeit von der Ausführungszeit abgezogen. Das Ergebnis ist ein Integerwert, der die Differenz in Millisekunden angibt. Für uns reicht aber eine Angabe in Sekunden aus. Aus diesem Grund wird der Millisekundenwert durch 1000 (1000 Millisekunden gleich 1 Sekunde) geteilt.
Anschließend folgt eine Ihnen bisher unbekannte Anweisung:
document.besuch.dauer.value
Das Objekt document ist Ihnen bereits bekannt. Um einen Text im HTML-Dokument auszugeben, verwenden Sie dessen Methode write. Dieses Objekt enthält aber auch alle Formulare des HTML-Dokuments als Objekte, die wiederum alle Elemente eines Formulars als Objekte enthalten. Im HTML-Dokument wurde ein Formular mit dem Wert besuch im name-Attribut definiert. Innerhalb dieses Formulars wurde außerdem ein input-Element notiert, das im name-Attribut den Wert dauer aufweist. Indem Sie nun zuerst das Objekt des Formulars besuch und anschließend das Objekt des input-Elements dauer angeben, können Sie den Wert des value-Attributs auslesen oder verändern. Dafür verwenden Sie den =-Operator. Ebenfalls neu ist die Methode round des Math-Objekts.
Math.round(zeit)
Das Math-Objekt verfügt über viele Methoden, um mathematische Berechnungen durchzuführen, unter anderem auch über die Methode round, die eine kaufmännische Rundung eines Fließkommawerts (auch Dezimalzahl oder reelle Zahl genannt) durchführt. Da die Variable zeit einen solchen Fließkommawert enthält und die Ausgabe eines »runden« Werts wesentlich besser geeignet ist, müssen Sie den Wert also runden. Der gerundete Wert wird an das value-Attribut das input-Element übergeben.
Zum Schluss folgt die Anweisung setTimeout(...). Diese Anweisung findet sich auch im onLoad-Event-Handler des body-Elements wieder. Mit dieser Anweisung können Sie eine Funktion nach einer bestimmten Wartezeit in Millisekunden ausführen lassen. Im onLoad-Event-Handler ist dies die Funktion stoppuhr(), die nach 0 Millisekunden ausgeführt werden soll, also sofort nach dem Laden des Dokuments. In der Funktion stoppuhr() führt die Anweisung
setTimeout('stoppuhr()',1000);
ebenfalls die Funktion stoppuhr() aus, wartet jedoch 1000 Millisekunden (also 1 Sekunde). Dies ermöglicht einen zeitgesteuerten Ablauf, der jede Sekunde ausgeführt wird und die Verweildauer des Benutzers immer aktuell im input-Element ausgibt.
Die Methode setTimeout() gehört übrigens zum window-Objekt.
Abbildung 5.3: Browserausgabe des Listing 5.3 im Internet Explorer 6.0
Die Anwendung dieses Scripts ist nicht ausschließlich auf die Darstellung der Dauer beschränkt. Sie könnte auch verwendet werden, um zu ermitteln, wie lange ein Benutzer eine Seite betrachtet, bevor er eine Aktion ausgeführt. Dies ist für statistische Zwecke sehr interessant.
# Countdown
Eine weitere Möglichkeit ist es, die noch verbleibende Zeit bis zu einem festgelegten Zeitpunkt zu errechnen, z. B. bis Weihnachten oder das Jahr 2006.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Countdown //-->
<html>
<head>
<title>Listing 5.4</title>
<script type="text/javascript">
<!--
endzeit = new Date(2006,1,1,0,0,0);
function countdown()
{
aktuell = new Date();
zeit = (endzeit - aktuell) / 1000;
document.countdown.dauer.value = Math.round(zeit);
setTimeout('countdown()',1000);
}
//-->
</script>
</head>
<body onLoad="setTimeout('countdown()',0)">
<form name="countdown">
Es sind noch <input name="dauer" size="10"> <b>Sekunden</b> bis zum Jahr 2006.
</form>
</body>
</html>Listing 5.4: JavaScript, das die verbleibende Zeit in Sekunden bis zum Zeitpunkt t errechnet
Zuerst wird ein neues Date-Objekt erzeugt, das den Bezeichner endzeit erhält. Das Besondere ist, dass Sie, statt das aktuelle Datum zu ermitteln, diesmal ein bestimmtes Datum bei der Instanziierung festlegen, und zwar den 01.01.2006, 0:00:00 Uhr. Die Reihenfolge der Parameter für Date() lautet Jahr, Monat, Tag, Stunde, Minute und Sekunde.
Anschließend folgt die Definition der Funktion countdown(). Im Anweisungsblock der Funktion folgt zuerst die Instanziierung des Objekts aktuell. Dieses soll den aktuellen Zeitpunkt bei Ausführung der Funktion ermitteln. Der Variablen zeit wird die Differenz der Variablen endzeit und aktuell geteilt durch 1000 zugewiesen. Die Teilung durch 1000 errechnet anstelle der Zeitspanne in Millisekunden die Zeitspanne in Sekunden.
Die Differenz in Sekunden wird gerundet und an das input-Element mit dem Wert dauer im name-Attribut des Formulars countdown zugewiesen. Anschließend folgt der erneute Aufruf der Funktion countdown nach einer Wartezeit von 1000 Millisekunden. Diese Funktion wird ebenfalls im onLoad-Event-Handler des body-Elements nach der Dauer von 0 Millisekunden (also sofort) aufgerufen.
# Verbesserungen
Sowohl das Script in Listing 5.3 als auch das Script in Listing 5.4 könnten insofern verbessert werden, als dass nicht nur die Dauer in Sekunden dargestellt wird, sondern in Tagen, Stunden, Minuten und Sekunden. Probieren Sie einmal, beide Scripts um diese Funktion zu erweitern. Ein Tipp: Sie werden den %-Operator benötigen.
Abbildung 5.4: Darstellung des Listing 5.4 im Internet Explorer 6.0
# Datum validieren
Es kann vorkommen, dass der Benutzer ein Datum eingeben soll und Sie dieses Datum auf Gültigkeit überprüfen wollen oder sogar müssen, um beispielsweise zu verhindern, dass der Benutzer ein Datum wie 31.2., 32.13. oder 0.0. eingibt.
# Schaltjahr
Das folgende Listings prüft, ob ein eingegebenes Jahr ein Schaltjahr ist.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Schaltjahr //-->
<html>
<head>
<title>Listing 5.5</title>
<script type="text/javascript">
<!--
function pruefen()
{
j = parseInt(document.datum.jahr.value);
sj = (((j%4==0) && (j%100!=0)) || (j%400==0));
if (sj)
{
alert(j+" ist ein Schaltjahr!");
}
else
{
alert(j+" ist kein Schaltjahr!");
}
}
//-->
</script>
</head>
<body>
<form name="datum">
<input name="jahr" size="4" value="2002"> <a href="javascript:pruefen()">Prüfen!</a>
</form>
</body>
</html>Listing 5.5: JavaScript, das überprüft, ob ein eingegebenes Jahr ein Schaltjahr ist
Die Berechnung eines Schaltjahrs ist recht simpel. Ein Jahr ist dann ein Schaltjahr, wenn die Jahreszahl durch 4 ohne Rest, nicht aber durch 100 ohne Rest teilbar ist. Daraus ergibt sich folgende Bedingung:
(Jahr % 4 == 0) && (Jahr % 100 != 0)
Außerdem ist ein Jahr dann ein Schaltjahr, wenn sich die Jahreszahl ohne Rest durch 400 teilen lässt. Die entsprechende Bedingung lautet:
(Jahr % 400 == 0)
Die zusammengesetzte Bedingung lautet dann:
((Jahr % 4 == 0) && (Jahr % 100 != 0)) || (Jahr % 400 == 0)
Die Funktion pruefen() wird aufgerufen, sobald der Benutzer auf den Verweis klickt. Im Anweisungsblock der Funktion wird zuerst der Wert des input-Elements in eine Zahl umgewandelt. Diese Umwandlung wird mit der Funktion parseInt() ermöglicht. Enthält der umzuwandelnde String Zeichen, erhält die Zielvariable den Wert NaN (engl. not a number, dt. keine Zahl). Anschließend wird die Bedingung geprüft und das Resultat (true oder false) in der Variablen sj gespeichert. Ist der Wert der Variablen true, ist das angegebene Jahr ein Schaltjahr, bei false ist das Jahr kein Schaltjahr.
# Zahlenbereich
Eine Datumsangabe darf nur aus folgenden Zahlen bestehen:
- Tag – 1 bis 31 (bzw. 28 oder 29 für den Februar)
- Monat – 1 bis 12
- Jahr – beliebig, da Sie den Kalenderwechsel im Jahre 1582 nicht berücksichtigen
Das folgende Listing prüft ein Datum auf seine Gültigkeit:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Datum validieren //-->
<html>
<head>
<title>Listing 5.6</title>
<script type="text/javascript">
<!--
function pruefen()
{
d = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
t = parseInt(document.datum.tag.value);
m = parseInt(document.datum.monat.value);
j = parseInt(document.datum.jahr.value);
d[1] = (((j%4==0) && (j%100!=0)) || (j%400==0))?29:28;
erg = ((t>=1) && (t<=d[m-1]))?"gültig":"UNGÜLTIG";
alert(erg);
}
//-->
</script>
</head>
<body>
<form name="datum">
Tag: <input name="tag" size="2" value="1">
Monat: <input name="monat" size="2" value="1">
Jahr: <input name="jahr" size="4" value="2002">
<br>
<a href="javascript:pruefen()">Prüfen!</a>
</form>
</body>
</html>Listing 5.6: JavaScript, das die Gültigkeit eines Datums überprüft und dabei Schaltjahre berücksichtigt
Zuerst wird das Array d erzeugt, das als Felder die maximalen Tage eines Monats in der Reihenfolge Januar bis Dezember erhält, wobei für den Februar die Zahl 28 notiert wird, da diese für den Februar typisch ist. Anschließend wird der Variablen t der umgewandelte String des input-Elements tag, der Variablen m der umgewandelte String des input-Elements monat und der Variablen j der umgewandelte String des input-Elements jahr zugewiesen.
Nach dem Konvertieren der Strings in Integer-Werte wird überprüft, ob das angegebene Jahr ein Schaltjahr ist. Dabei wird die gleiche Bedingung verwendet, die auch in Listing 5.5 zum Einsatz kommt, mit dem Unterschied, dass sie hier in einer Entweder-oder-Abfrage vorkommt und als Resultat entweder 28 oder 29 zurückgegeben wird. Dieser Wert wird dann dem Feld 1 (Februar) im Array d zugewiesen.
Zum Schluss wird ebenfalls mit einer Entweder-oder-Abfrage überprüft, ob der Wert der Variablen t größer gleich 1 ist und kleiner gleich dem Wert des Feldes des d-Arrays mit dem Index mon-1. Da Array-Indizes bei der Zählung mit 0 beginnen, müssen Sie von mon den Wert 1 subtrahieren, um den entsprechenden Index zu erhalten. Liegt der Wert von t innerhalb dieses Bereichs, wird der String "gültig" zurückgegeben. Ist dies nicht der Fall, lautet der Rückgabewert "UNGÜLTIG". Der String wird in der Variablen erg gespeichert und mit alert ausgegeben.
Abbildung 5.5: Darstellung des Listing 5.6 im Internet Explorer 6.0
# Das Jahr 2000
Der Jahr-2000-Fehler (engl. Y2K-Bug) hat vor einigen Jahren die digitale Welt in Aufruhr versetzt. Von diesem Fehler waren leider auch einige Browser nicht ausgenommen. Statt des Werts 2000 lieferten sie den Wert 100, statt 2001 den Wert 101 usw. Der Grund dafür ist, dass zweistellige Jahreszahlen ausgegeben wurden und man somit für das Jahr 1998 den Wert 98, für 1999 den Wert 99 usw. erhielt.
Dieser Fehler trat vor allem mit den Browsern Netscape Communicator 2 und 4.06+ und dem Internet Explorer 2 auf. Andere Browser weisen diesen Fehler angeblich nicht auf, z. B. NC 3, NC 4.0 bis NC 4.05 und der IE ab Version 4. Da einige Benutzer jedoch auch noch ältere Browser verwenden, sollte Abhilfe geschaffen werden. Immerhin lässt sich dieses Problem sehr leicht und sicher lösen.
Da die falschen Jahreszahlen kleiner als der Wert 1000 sind, kann man davon ausgehen, dass bei Jahreszahlen, die unter diesem Wert liegen, ein Jahr-2000-Fehler vorliegt. Das folgende Script löst dieses Problem entsprechend:
function year4(year)
{
return ((year < 1000) ? year+1900 : year;
}
Dieser Bugfix verändert die Zahl year nur dann, wenn die Zahl kleiner als 1000 ist, und addiert 1900 dazu (99 + 1900 = 1999). Diese Funktion sollten Sie immer dann einsetzen, wenn Sie sich sicher sind, dass der Wert der Jahreszahl nicht wirklich als das Jahr 99, 50 oder 532 n. Chr., sondern als 1999, 1950 oder 2432 n. Chr. verstanden werden soll.
# Zusammenfassung
- Arrays sind eine Zusammenstellung von mehreren Variablen, auf die mit einem Index zugegriffen werden kann.
- Ein
Date-Objekt bietet verschiedene Methoden an, um z. B. den Tag, den Monat oder das Jahr zu ermitteln. Auch Wochentage und Ähnliches lassen sich anhand einesdate-Objekts ermitteln. - Die Methoden
getHours,getMinutesundgetSecondsgeben die Stunde, die Minute und die Sekunde eines Zeitpunkts zurück. - Die Methoden
getDay,getMonthundgetYearhingegegen ermitteln den Tag, den Monat und das Jahr eines Zeitpunkts. - In JavaScript gibt es einen Jahr-2000-Fehler. Jahre, die größer als 1999 sind, werden falsch ausgegeben. So wird aus dem Jahr 2000 einfach 100, aus 2002 wird 102 usw.
# Fragen und Übungen
- Durch welches Schlüsselwort wird ein Array definiert? Zeigen Sie dies an einem vollständigen Beispiel.
- Wie können Sie in allen Browsern eine vierstellige Jahreszahl ausgeben?
- Bei der Ausgabe von Stunde, Minute und Sekunde kann es zu unschönen Formatierungen kommen. Wie lässt sich das beheben?
- Wie können Sie anstelle einer Monatszahl den Monatsnamen ausgeben?