Vordefinierte Kernobjekte

Dieses Kapitel beschreibt die vordefinierten Objekte im Kern von Javascript: Array, Boolean, Date, Function, Math, Number, RegExp, und String.

Array-Objekt

JavaScript selbst besitzt keinen eigenständigen Array-Datentyp, jedoch kann das vordefinierte Array-Objekt und seine Methoden eingesetzt werden, um in eigenen Applikationen mit Arrays zu arbeiten. Das Array-Objekt besitzt verschiedene Methoden, womit Arrays manipuliert werden können. Mit Hilfe dieser Methoden lassen sich Arrays z.B. zusammenfügen, invertieren und sortieren. Des Weiteren besitzt das Array-Objekt eine Eigenschaft für die Länge des Arrays und Methoden zum Arbeiten mit regulären Ausdrücken.

Ein Array ist ein geordneter Satz von Werten, auf die mit einem Namen und einem Index verwiesen werden kann. Zum Beispiel kann man ein Array emp erstellen, welches die Namen von Mitarbeitern enthält, und die Mitarbeiter-Nummer als Index verwenden. Dann wäre emp[1] der erste Mitarbeiter, emp[2] der zweite Miitarbeiter und so weiter.

Erstellen eines Arrays

Die drei folgenden Anweisungen zur Erstellung von Arrays sind gleichbedeutend:

var arr = new Array(element0, element1, ..., elementN);
var arr = Array(element0, element1, ..., elementN);
var arr = [element0, element1, ..., elementN];

element0, element1, ..., elementN ist eine Liste von Werten für das entsprechende Element des Arrays. Wenn diese Form verwendet wird, wird das Array mit den angegebenen Werten als Elemente initalisiert und die length-Eigenschaft des Arrays auf die Anzahl der Argumente gesetzt.

Die Klammer-Syntax wird Array-Literal oder Array-Initialisierer genannt. Sie ist kürzer und wird im Allgemeinen bevorzugt; siehe Array Literale.

Zur Erstellung eines Arrays mit einer Länge ungleich 0, das jedoch keine Elemente enthält, kann eine der folgenden Methoden zum Einsatz kommen:

var arr = new Array(arrayLength);
var arr = Array(arrayLength);

// Dasselbe in literaler Notation:
var arr = [];
arr.length = arrayLength;

Merke: Beim obenstehenden Code muss arrayLength vom Typ Number sein. Andernfalls wird ein Array mit nur einem Element (den übergebenen Wert) enthält. Der Aufruf von arr.length gibt dann zwar den Wert von arrayLength zurück, aber das Array enthält leere Elemente (undefined). Bei der Anwendung einer for...in-Schleife auf das Array wird keines der Array-Elemente angesprochen.

Anstatt ein Array wie oben einer neu definierten Variablen zuzuweisen, kann es auch einer Eigenschaft eines bereits bestehenden oder neuen Objekts zugewiesen werden:

var obj = {};
// ...
obj.prop = [element0, element1, ..., elementN];

// OR
var obj = {prop: [element0, element1, ...., elementN]}

Falls man ein Array mit einem einzelnen Element initialisieren möchte und das Element ist vom Typ Number, so muss auf die Klammer-Notation zurückgegriffen werden. Denn wird ein einzelner Wert vom Typ Number an eine Array()-Konstruktorfunktion als Argument übergeben, so wird dieser Wert als Länge des Arrays interpretiert und nicht als Wert für ein einzelnes Array-Element.

var arr = [42]; var arr = Array(42); // Erstellt ein Array ohne Elemente; arr.length wird auf 42 gesetzt

// Der obenstehende Code ist äquivalent zu:
var arr = [];
arr.length = 42;

Möchte man ein Array mit einem einzelnen Element über die Konstruktorfunktion erstellen und dieses Element ist keine Ganzzahl (sondern eine Gleitkommazahl mit nicht zu vernachlässigenden Kommastellen), wird ein RangeError ausgeworfen. Darum sollte man zur Sicherheit Array-Literale verwenden, wenn anzunehmen ist, dass der Code Arrays mit einzelnen Elementen erzeugt, oder zuerst leere Arrays erstellen und diese anschließend befüllen.

var arr = Array(9.3); // RangeError: Invalid array length

Befüllen von Arrays

Ein Array kann mit Elementen befüllt werden, indem man den Positionen über den Index Werte zuweist:

var emp = [];
emp[0] = "Casey Jones";
emp[1] = "Phil Lesh";
emp[2] = "August West";

Achtung: Wenn man bei obenstehendem Code keine Ganzzahl (Integer) als Index sondern z. B. eine Gleitkommazahl oder einen String angibt, wird anstatt eines Array-Elements eine Eigenschaft erstellt, die auf das Array verweist.

var arr = [];
arr[3.4] = "Oranges";
console.log(arr.length);                // 0
console.log(arr.hasOwnProperty[3.4]);   // true

Man kann ein Array auch direkt bei der Erstellung befüllen:

var myArray = new Array("Hello", myVar, 3.14159);
var myArray = ["Mango", "Apple", "Orange"]

Verweise auf Array-Elemente

Auf die Elemente eines Arrays verweist man über die entsprechende Positionsnummer (Index). Wenn z. B. folgendes Array gegeben ist:

var myArray = ["Wind", "Rain", "Fire"];

Dann verweist man mit myArray[0] auf das erste Element des Arrays und mit myArray[1] auf das zweite Element. Der Index der Elemente startet bei 0.

Achtung: Der Array-Operator [] (eckige Klammern) wird auch für den Zugriff auf Array-Eigenschaften verwendet (Arrays sind auch Objekte bei JavaScript).

Zum Beispiel:

var arr = ["one", "two", "three"];
arr[2];  // three
arr["length"];  // 3

Die Eigenschaft length

Auf der Implementierungsseite werden die Elemente von JavaScript-Arrays wie normale Eigenschaften gespeichert - mit dem Array-Index als Eigenschaftsnamen. Die Eigenschaft length ist speziell; sie gibt immer den Index des letzten Elements zurück. Noch einmal zur Erinnerung: JavaScript-Arrays sind 0-basiert: Der Index startet mit 0 und nicht mit 1. Das bedeutet, dass der Wert von length eins mehr ist als der höchste Index der Array-Elemente:

var cats = [];
cats[30] = ['Dusty'];
print(cats.length); // 31

Man kann der length-Eigenschaft auch direkt einen Wert zuweisen. Wird ein Wert zugewiesen, der kleiner ist als die Anzahl der gespeicherten Elemente, wird das Array auf diese Länge gekürzt. Bei der Zuweisung von 0 werden alle Elemente gelöscht:

var cats = ['Dusty', 'Misty', 'Twiggy'];
console.log(cats.length); // 3

cats.length = 2;
console.log(cats); // gibt "Dusty,Misty" aus - Twiggy wurde entfernt

cats.length = 0;
console.log(cats); // keine Ausgabe; Das cats-Array ist leer

cats.length = 3;
console.log(cats);  // [undefined, undefined, undefined]

Iterieren über Arrays

Eine beliebte Vorgehensweise ist das Iterieren über die Werte eines Arrays, wobei jedes Elemente beliebig verarbeitet wird:

var colors = ['red', 'green', 'blue'];
for (var i = 0; i < colors.length; i++) {
  console.log(colors[i]);
}

Wenn man sicher ist, dass keines der Elemente im booleschen Kontext zu false evaluiert - z. B. wenn das Array nur DOM-Nodes enthält - gibt es eine effizientere Lösung:

var divs = document.getElementsByTagName('div');
for (var i = 0, div; div = divs[i]; i++) {
  /* Verarbeitung von div */
}

Hierbei wird auf die Überprüfung der Länge des Arrays verzichtet und die Variable div bei jedem Schleifendurchlauf dem aktuellen Element zugewiesen.

Mit der Methode forEach(), die ab JavaScript 1.6 zur Verfügung steht, gibt es eine weitere Möglichkeit:

var colors = ['red', 'green', 'blue'];
colors.forEach(function(color) {
  console.log(color);
});

Die Funktion, die an forEach übergeben wird, wird einmal für jedes Array-Element ausgeführt, wobei das Array-Element an die Funktion als Argument übergeben wird. Elemente denen kein Wert zugewiesen ist, werden bei der forEach-Schleife nicht berücksichtigt.

Elemente, die bei der Definition des Arrays ausgelassen wurden, werden beim Iterieren mit forEach nicht aufgelistet. Weist man den Elemente jedoch manuell undefined zu, werden sie aufgelistet:

var array = ['first', 'second', , 'fourth'];

// returns ['first', 'second', 'fourth'];
array.forEach(function(element) {
  console.log(element);
}

if(array[2] === undefined) { console.log('array[2] is undefined'); } // true

var array = ['first', 'second', undefined, 'fourth'];

// returns ['first', 'second', undefined, 'fourth'];
array.forEach(function(element) {
  console.log(element);
}

Da JavaScript-Elemente wie Standard-Objekt-Eigenschaften gespeichert werden, ist es nicht empfehlenswert mit einer for...in-Schleife über Arrays zu iterieren, weil dabei auch normale Elemente und alle aufzählbaren Eigenschaften einbezogen werden.

Array-Methoden

Das Array-Objekt besitzt die folgenden Methoden:

• concat() fügt zwei Arrays zusammen und gibt das Ergebnis als neues Array zurück:
  

  var myArray = new Array("1", "2", "3");
  myArray = myArray.concat("a", "b", "c"); // myArray ist nun ["1", "2", "3", "a", "b", "c"]
  

• join(deliminator = ",") fügt alle Elemente zu einem String zusammen:
  

  var myArray = new Array("Wind", "Rain", "Fire");
  var list = myArray.join(" - "); // list is "Wind - Rain - Fire"
  

• push() fügt eines oder mehrere Elemente am Ende des Arrays hinzu und gibt die Länge des neuen Arrays zurück:

  var myArray = new Array("1", "2");
  myArray.push("3"); // myArray is now ["1", "2", "3"]
  

• pop() entfernt das letzte Element des Arrays und gibt den Wert dieses Elements zurück:

  var myArray = new Array("1", "2", "3");
  var last = myArray.pop(); // myArray is now ["1", "2"], last = "3"
  

• shift() entfernt das erste Element aus dem Array und gibt dessen Wert zurück:

  var myArray = new Array ("1", "2", "3");
  var first = myArray.shift(); // myArray is now ["2", "3"], first is "1"
  

• unshift() fügt eines oder mehrere Elemente am Anfang des Arrays hinzu und gibt die Länge des neuen Arrays zurück:

  var myArray = new Array ("1", "2", "3");
  myArray.unshift("4", "5"); // myArray becomes ["4", "5", "1", "2", "3"]
  

• slice(start_index, upto_index) extrahiert einen Bereich eines Arrays und liefert ein neues Array zurück:

  var myArray = new Array ("a", "b", "c", "d", "e");
  myArray = myArray.slice(1, 4); /* starts at index 1 and extracts all elements
    until index 3, returning [ "b", "c", "d"] */
  

• splice(index, count_to_remove, addelement1, addelement2, ...) entfernt Elemente aus dem Array und ersetzt diese (optional).
  

  var myArray = new Array ("1", "2", "3", "4", "5");
  myArray.splice(1, 3, "a", "b", "c", "d"); // myArray ist jetzt ["1", "a", "b", "c", "d", "5"]
    // This code started at index one (or where the "2" was), removed 3 elements there, 
    // and then inserted all consecutive elements in its place.
  

• reverse() dreht die Anordnung der Elemente herum: das erste Element ist dann das letzte Elemente das letzte Element das erste.
  

  var myArray = new Array ("1", "2", "3");
  myArray.reverse(); // tauscht die Reihenfolge, sodass myArray = [ "3", "2", "1" ]
  

• sort() sortiert die Elemente eines Arrays.

  var myArray = new Array("Wind", "Rain", "Fire");
  myArray.sort(); // sorts the array so that myArrray = [ "Fire", "Rain", "Wind" ]
  

  sort() kann auch eine Callback-Funktion übergeben werden, womit festgelegt wird, wie die Elemente verglichen werden. Die Funktion vergleicht zwei Werte und gibt einen der folgenden drei Werte zurück:

  • Wenn a kleiner als b ist, nach dem Sortierverfahren, gib -1 (oder eine beliebige negative Zahl) zurück.
  • Wenn a größer ist als b, nach dem Sortierverfahren, gib 1 (oder eine beliebige positive Zahl) zurück.
  • Wenn a und b gleich sind, gib 0 zurück.

  Beim folgenden Code wird z. B. anhand des letzten Buchstabens der Elemente sortiert:

  var sortFn = function(a, b){
    if (a[a.length - 1] < b[b.length - 1]) return -1;
    if (a[a.length - 1] > b[b.length - 1]) return 1;
    if (a[a.length - 1] == b[b.length - 1]) return 0;
  }
  myArray.sort(sortFn); // sorts the array so that myArray = ["Wind","Fire","Rain"]
  

Kompatibler Code für ältere Browser kann für jede dieser Funktionen auf verschiedenen Seiten gefunden werden. Informationen über die native Browserunterstützung der verschiedene Features in unterschiedlichen Browsern findet man hier.

indexOf(searchElement[, fromIndex]) sucht im Array nach  searchElement und gibt den Index des ersten Treffers zurück.

• var a = ['a', 'b', 'a', 'b', 'a'];
  alert(a.indexOf('b')); // Alert-Meldung: 1
  // Nun noch einmal, beginnend nach dem ersten Treffer
  alert(a.indexOf('b', 2)); // Alert-Meldung: 3
  alert(a.indexOf('z')); // Alert-Meldung: -1, weil 'z' nicht gefunden wurde
  

• lastIndexOf(searchElement[, fromIndex]) funktioniert wie indexOf, aber es wird am Ende begonnen und rückwärts gesucht.

  var a = ['a', 'b', 'c', 'd', 'a', 'b'];
  alert(a.lastIndexOf('b')); // Alert-Meldung: 5
  // Nun noch einmal, beginnend vor dem letzten Treffer
  alert(a.lastIndexOf('b', 4)); // Alert-Meldung: 1
  alert(a.lastIndexOf('z')); // Alert-Meldung: -1
  

• forEach(callback[, thisObject]) führt callback für jedes Array-Element aus.

  var a = ['a', 'b', 'c'];
  a.forEach(alert); // Alert-Meldung für jedes Element nacheinander
  

• map(callback[, thisObject]) gibt ein neues Array mit den Rückgabewerten von jedem Aufruf von callback mit den einzelnen Elementen zurück.

  var a1 = ['a', 'b', 'c'];
  var a2 = a1.map(function(item) { return item.toUpperCase(); });
  alert(a2); // Alert: A,B,C
  

• filter(callback[, thisObject]) gibt ein neues Array mit den Werten zurück, für die callback den Wert true liefert.

  var a1 = ['a', 10, 'b', 20, 'c', 30];
  var a2 = a1.filter(function(item) { return typeof item == 'number'; });
  alert(a2); // Alerts 10,20,30
  

• every(callback[, thisObject]) gibt true zurück, wenn callback für jedes Element true liefert.

  function isNumber(value){
    return typeof value == 'number';
  }
  var a1 = [1, 2, 3];
  alert(a1.every(isNumber)); // Alert: true
  var a2 = [1, '2', 3];
  alert(a2.every(isNumber)); // Alert: false
  

• some(callback[, thisObject]) gibt true zurück, wenn callback für mindestens eines der Elemente true liefert.
  

  function isNumber(value){
    return typeof value == 'number';
  }
  var a1 = [1, 2, 3];
  alert(a1.some(isNumber)); // Alert: true
  var a2 = [1, '2', 3];
  alert(a2.some(isNumber)); // Alert: true
  var a3 = ['1', '2', '3'];
  alert(a3.some(isNumber)); // Alert: false
  

Die oben beschriebenen Methoden, welche eine callback-Funktion entgegennehmen, sind als iterative Methoden bekannt, weil sie über das ganze Array iterieren. Jeder dieser Funktionen kann optional ein zweites Argument thisObject übergeben werden. Wird ein Objekt angegeben, dann steht das this-Schlüsselwort, wenn es innerhalb des Funktionsblocks der callback-Funktion verwendet wird, für das angegebene Objekt. Wenn kein Objekt angegeben wird, verweist this wie bei allen Funktionen, die außerhalb eines eigenen Objekt-Kontext definiert werden, auf das globale Objekt (window).

Die callback-Funktion wird üblicherweise mit drei Argumenten aufgerufen. Das erste Argument ist der Wert des aktuellen Elements, das zweite der Array-Index des Elements und das dritte ein Verweis auf das Objekt selbst. JavaScript-Funktionen ignorieren alle Argumente, die nicht in der Parameterliste angegeben werden. Daher ist es sicher, nur ein einzelnes Argument wie alert anzugeben.

• reduce(callback[, initialValue]) führt callback(ersterWert, zweiterWert) aus, um die Liste auf einen einzelnen Wert zu reduzieren.

  var a = [10, 20, 30];
  var total = a.reduce(function(first, second) { return first + second; }, 0);
  alert(total) // Alerts 60
  

• reduceRight(callback[, initialValue]) funktioniert wie reduce(), aber es wird von hinten angefangen.

reduce und reduceRight sind von den iterativen Array-Methoden am schwierigsten zu durchschauen. Sie sollten für Algorithmen verwendet werden, die zwei Werte rekursiv miteinander kombinieren, um eine Sequenz von Werten auf einen Einzelwert zu reduzieren.

Mehrdimensionale Arrays

Arrays können verschachtelt werden. Das bedeutet, dass ein Array ein weiteres Array als Element enthalten kann. Somit können mehrdimensionale Arrays mit JavaScript erstellt werden.

Mit folgendem Code wird ein zweidimensionaes Array erstellt:

var a = new Array(4);
for (i = 0; i < 4; i++) {
  a[i] = new Array(4);
  for (j = 0; j < 4; j++) {
    a[i][j] = "[" + i + "," + j + "]";
  }
}

Dieses Beispiel erstellt ein Array mit den folgenden Reihen:

Reihe 0: [0,0] [0,1] [0,2] [0,3]
Reihe 1: [1,0] [1,1] [1,2] [1,3]
Reihe 2: [2,0] [2,1] [2,2] [2,3]
Reihe 3: [3,0] [3,1] [3,2] [3,3]

Arrays und reguläre Ausdrücke

Wenn ein Array das Ergebnis einer Übereinstimmung eines regulären Ausdrucks und einer Zeichenkette ist, gibt das Array Eigenschaften und Elemente zurück, die Informationen zu dieser Überenstimmung liefern.  Die Rückgabewerte von RegExp.exec(), String.match(), und String.split() sind Arrays. Weitere Informationen zur Benutzung von Arrays mit regulären Ausdrücken findet man im Kapitel Reguläre Ausdrücke.

Arbeiten mit Array-ähnlichen Objekten

Manche JavaScript-Objekte, wie z. B. die NodeList, die von document.getElementsByTagName() zurückgegeben wird, oder das arguments-Objekt, das innerhalb eines Funktionskörpers verfügbar gemacht wird, verhalten sich oberflächlich wie Arrays, besitzen jedoch nicht alle für Arrays üblichen Methoden. So besitzt das arguments-Objekt zwar eine length-Eigenschaft, die forEach()-Methode ist aber z. B. nicht vorhanden.

Generische Array-Methoden, die mit JavaScript 1.6 eingeführt wurden, stellen eine Möglichkeit dar, um Array-ähnliche Methoden für andere Array-ähnliche Objekte zu verwenden. Für jede Standard-Arraymethode existiert eine korrespondierende Methode für das Array-Objekt selbst.

Zum Beispiel:

function alertArguments() {
   Array.forEach(arguments, function(item) {
     alert(item);
   });
 }

Diese generischen Methoden können für älteren Versionen von JavaScript mit etwas zusätzlichem Code und mit Hilfe der call-Methode emuliert werden:

Array.prototype.forEach.call(arguments, function(item) {
   alert(item);
 });

Generische Array-Methoden können auch für Strings eingesetzt werden, da auf die einzelnen Zeichen von Strings ebenfalls sequenziell zugegriffen werden kann:

Array.forEach("a string", function(chr) {
   alert(chr);
});

Ein paar weitere Beispiele für die Anwendung von Array-Methoden auf Strings, mit Rückgriff auf JavaScript 1.8 Expression Closures:

var str = 'abcdef';
var consonantsOnlyStr = Array.filter(str, function (c) !(/[aeiou]/i).test(c)).join(''); // 'bcdf'
var vowelsPresent = Array.some(str, function (c) (/[aeiou]/i).test(c)); // true
var allVowels = Array.every(str, function (c) (/[aeiou]/i).test(c)); // false
var interpolatedZeros = Array.map(str, function (c) c+'0').join(''); // 'a0b0c0d0e0f0'
var numerologicalValue = Array.reduce(str, function (c, c2) c+c2.toLowerCase().charCodeAt()-96, 0);
// 21 (reduce() since JS v1.8)

Achtung: Die Methoden filter und map geben nicht automatisch die Buchstaben als String zusammengefügt zurück, sondern als Array. Zur Umwandlung in einen String kommt die Methode join zum Einsatz.

Array-Comprehensions

Die mit JavaScript 1.7 eingeführten Array Comprehensions stellen eine praktische Abkürzung für die Konstruktion eines neuen Arrays, basierend auf dem Inhalt eines anderen Arrays, bereit. Die Comprehensions können oft anstelle von call() und filter() Funktionsaufrufen oder zur Kombination dieser beiden Methoden eingesetzt werden.

Die folgende comprehension nimmt ein Array numbers mit Elementen vom Typ Number entgegen und erstellt ein neues Array mit dem doppelten Wert jeder Zahl:

var numbers = [1, 2, 3, 4];
var doubled = [i * 2 for (i of numbers)];
alert(doubled); // Alert-Meldung: 2,4,6,8

Die folgende Anweisung mit map() ist equivalent:

var doubled = numbers.map(function(i){return i * 2;});

Comprehensions können ebenfalls zur Selektion von Elementen, die eine bestimmte Bedingung erfüllen, verwendet werden.

Hier ein Beispiel bei dem nur die gerade Zahlen aus dem Array numbers im Array evens gespeichert werden:

var numbers = [1, 2, 3, 21, 22, 30];
var evens = [i for (i of numbers) if (i % 2 === 0)];
alert(evens); // Alerts 2,22,30

Die Methode filter() erfüllt denselben Zweck:

var evens = numbers.filter(function(i){return i % 2 === 0;});

Comprehensions, die jeweils wie map() und filter() agieren, können zu einer einzelnen Comprehension kombiniert werden. Bei folgender Comprehension werden zuerst die gerade Zahlen gefiltert und dann ein Array mit den doppelten Werten dieser Zahlen erstellt:

var numbers = [1, 2, 3, 21, 22, 30];
var doubledEvens = [i * 2 for (i of numbers) if (i % 2 === 0)];
alert(doubledEvens); // Alerts 4,44,60

Die eckigen Klammern einer Array Comprehension leiten einen implizierten Block zum Zweck der Sichtbarkeitsabgrenzung ein. Neue Variablen (wie z. B. i im Code-Beispiel) werden so behandelt, als wären sie mit let deklariert worden. Sie sind also außerhalb der Comprehension nicht verfügbar.

Der Eingabewert einer Array-Comprehension muss nicht unbedingt ein Array sein; es können auch Iteratoren und Generatoren benutzt werden.

Sogar Strings können mit Array-Comprehensions verarbeitet werden; um dasselbe wie oben (we bei Array-ähnlichen Objekten) zu erreichen:

var str = 'abcdef';
var consonantsOnlyStr = [c for (c of str) if (!(/[aeiouAEIOU]/).test(c))  ].join(''); // 'bcdf'
var interpolatedZeros = [c+'0' for (c of str) ].join(''); // 'a0b0c0d0e0f0'

Noch einmal zur Erinnerung: Der Typ des Eingabewerts bleibt nicht erhalten. Das Array wird daher mit der Methode join() zu einem String zusammengefügt.

Boolesches Objekt

Das Boolesche Objekt ist eine Hülle um den primitiven booleschen Datentyp. Mit folgender Syntax wird ein boolesches Objekt erstellt:

var booleanObjectName = new Boolean(value);

Achtung: Die primitiven booleschen Werte true und false können leicht mit den Werten true und false des booleschen Objekts verwechselt werden. Jedes Objekt dessen Wert nicht undefined , null, 0, NaN, oder ein leerer String ist, inklusive eines booleschen Objekts mit dem Wert false, evaluieren bei Vergleichsanweisungen zu true. Siehe if...else-Anweisung für weitere Informationen.

Das Date-Objekt

Bei JavaScript gibt es keinen speziellen Datentyp für Datums- und Zeitangaben. Man kann jedoch das Date-Objekt für diesen Zweck verwenden. Dieses Objekt hat viele Methoden zum setzen, abfragen und manipulieren von Datumsangaben., besitzt jedoch keinerlei Eigenschaften.

JavaScript geht mit Datumsangaben genauso um wie Java. Beide Programmiersprachen haben viele gleiche Methoden und speichern Daten als die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00.

Die Zeitspanne des Date-Objekts reicht von -100,000,000 Tagen bis 100,000,000 Tagen relativ zum 1. Januar 1970 UTC.

Erstellung eines Date-Objekts:

var dateObjectName = new Date([parameter]);

wobei dateObjectName der Name des zu erstellenden Date-Objekts ist; es kann ein neues Objekt oder eine Eigenschaft eines bereits existierenden Objekts sein.

Wenn Date ohne das Schlüsselwort new aufgerufen wird, wird das bereitgestellte Date-Objekt zu einem String konvertiert.

Die Parameter in der oben beschriebenen Syntax können wie folgt sein:

• Nichts: Es wird ein Objekt mit heutigem Datum und Zeit erstellt. Zum Beispiel: today = new Date();.
• Eine Datumsangabe als String (Zeichenkette) in Form von: "Monat Tag, Jahr Stunden:Minutes:Sekunden". Zum Beispiel: var Xmas95 = new Date("December 25, 1995 13:30:00"). Wird die Uhrzeit nicht angegeben, wird sie auf 00:00:00 gesetzt.
• Ein Satz von Integer-Werten, die für Jahr, Monat und Tag stehen. Zum Beispiel: var Xmas95 = new Date(1995, 11, 25).
• Ein Satz von Integer-Werten, die für Jahr, Monat, Tag, Stunde, Minute und Sekunde stehen. Zum Beispiel: var Xmas95 = new Date(1995, 11, 25, 9, 30, 0);.

JavaScript 1.2 und früher
Das Date-Objekt verhält sich wie folgt:

• Datumsangaben, die vor 1970 liegen sind nicht erlaubt.
• Das Verhalten von JavaScript hängt vom plattformspezifischen Datumsverhalten ab; Das Verhalten des Date-Objekts variiert von Plattform zu Plattform.

Methoden des Date-Objekts

Die Methoden des Date-Objekts zur Behandlung von Datums- und Zeitangaben lassen sich grob kategorisieren:

• "set"-Methoden, für das setzen von Datums- und Zeitwerten in Date Objekten.
• "get"-Methoden, für das Abfragen von Datums- und Zeitwerten von Date Objekten.
• "to"-Methoden, für die Rückgabe von Datums- und Zeitwerten von Date-Objekten in Form von String-Werten.
• parse- und UTC-Methoden, für das parsen von Date-Strings.

Mit den "get"- und "set"-Methoden kann man Sekunden, Minuten, Stunden, den Tag des Monats, den Wochentag, den Monat und das Jahr seperat abfragen und setzen. Es exisitert außerdem eine Methode getDay, welche den Wochentag zurückliefert, jedoch keine korresponierende Methode setDay für das Setzen, da der Wochentag automatisch gesetzt wird. Diese Methoden benutzen Integer, welche die Werte wie folgt repräsentieren:

• Sekunden und Minuten: 0 bis 59
• Stunden: 0 bis 23
• Tag: 0 (Sonntag) to 6 (Samstag)
• Datum: 1 bis 31 (Monatstag)
• Monate: 0 (Januar) bis 11 (Dezember)
• Jahr: Jahre seit 1900

Angenommen man definiert das folgende Date-Objekt:

var Xmas95 = new Date("December 25, 1995");

Dann gibt Xmas95.getMonth() den Wert 11 und Xmas95.getFullYear() den Wert 1995 zurück.

Die Methoden getTime und setTime sind nützlich für das Vergleichen von Datumsangaben. Die Methode getTime gibt eine Zahl - die Millisekunden seit 1. Januar 1970, 00:00:00 - für das Date-Objekt zurück.

Zum Beispiel liefert der folgende Code die Anzahl der noch verbleibenden Tage im Jahr:

var today = new Date();
var endYear = new Date(1995, 11, 31, 23, 59, 59, 999); // Setze Tag und Monat
endYear.setFullYear(today.getFullYear()); // Set year to this year
var msPerDay = 24 * 60 * 60 * 1000; // Number of milliseconds per day
var daysLeft = (endYear.getTime() - today.getTime()) / msPerDay;
var daysLeft = Math.round(daysLeft); //returns days left in the year

Die Methode parse ist nützlich für die Verarbeitung von Strings, welche Datumsangaben enthalten, die einem Date-Objekt zugewiesen werden sollen. Zum Beispiel kommen bei folgendem Code die Methoden parse und setTime zum Einsatz, um dem IPOdate-Objekt einen Datumswert zuzuweisen:

var IPOdate = new Date();
IPOdate.setTime(Date.parse("Aug 9, 1995"));

Beispiel für die Benutzung des Date-Objekts

function JSClock() {
  var time = new Date();
  var hour = time.getHours();
  var minute = time.getMinutes();
  var second = time.getSeconds();
  var temp = "" + ((hour > 12) ? hour - 12 : hour);
  if (hour == 0)
    temp = "12";
  temp += ((minute < 10) ? ":0" : ":") + minute;
  temp += ((second < 10) ? ":0" : ":") + second;
  temp += (hour >= 12) ? " P.M." : " A.M.";
  return temp;
}

Zum Schluss wird mit einem bedingten Ausdruck überprüft, ob der Wert von hour 12 oder größer ist und entsprechend "P.M." oder "A.M." an den String temp angefügt.

Das Function-Objekt

Das vordefinierte Function-Objekt spezifiziert einen String mit JavaScript-Code, der als Funktion kompiliert wird.

Erstellung eines Function-Objekts:

var functionObjectName = new Function ([arg1, arg2, ... argn], functionBody);

functionObjectName ist der Name einer Variablen oder Eigenschaft eines existierenden Objekts. Es kann auch ein Objekt sein, an das ein Event-Handler (kleingeschrieben), wie z. B. window.onerror, angehängt ist.

arg1, arg2, ... argn sind Argumente, die von der Funktion als formale Argumentnamen benutzt werden. Jedes dieser Argumente muss ein String sein und konform mit den Regeln für valide JavaScript-Bezeichner; valide Bezeichner sind z.B. "x" oder "theForm".

functionBody ist ein String mit dem JavaScript-Code der als Funktionskörper der Funktion kompiliert wird.

Function-Objekte werden bei jeder Benutzung evaluiert. Das ist weniger effizient als eine Funktion zu deklarieren und diese im Code aufzurufen, weil deklarierte Funktionen kompiliert werden.

Zusätzlich zur Definition von Funktionen, wie an dieser Stelle beschrieben, kann auch die Funktionsanweisung und der Funktionsausdruck zum Einsatz kommen. In der JavaScript-Referenz findet man dazu mehr Informationen.

Der folgende Code weist der Variablen setBGColor eine Funktion zu. Diese Funktion legt die Hintergrundfarbe für die aktuelle Seite fest.

var setBGColor = new Function("document.bgColor = 'antiquewhite'");

Der Aufruf des Function-Objekts erfolgt, indem der Variablenname so angegeben wird, als würde es sich um eine Funktion handeln; mit dem folgenden Code wird die Funktion der setBGColor-Variablen ausgeführt:

var colorChoice="antiquewhite";
if (colorChoice=="antiquewhite") {setBGColor()}

Die Funktion kann mit einer der folgenden Vorgensweisen einem Event-Handler zugewiesen werden:

1. document.form1.colorButton.onclick = setBGColor;
   

2. <INPUT NAME="colorButton" TYPE="button"
     VALUE="Change background color"
     onClick="setBGColor()">
   

Die Erstellung der Variablen setBGColor wie oben ist gleichbedeutend mit der Deklaration der folgenden Funktion:

function setBGColor() {
  document.bgColor = 'antiquewhite';
}

Die Zuweisung einer Funktion an eine Variable ist ungefähr genauso wie die Deklaration einer Funktion, allerdings gibt es diverse Unterscheide:

• Wenn einer Variablen eine Funktion zugewiesen wird, ist var setBGColor = new Function("..."), setBGColor eine Variable für die der aktuelle Wert eine Referenz zur Funktion ist, die durch new Function() erstellt wurde.
• Wenn eine Funktion mit function setBGColor() {...}, setBGColor erstellt wurde, handelt es sich bei setBGColor um keine Variable, sondern den Namen der Funktion.

Funktionen können ineinander verschachtelt werden. Die innere Funktion ist dann durch den Sichtbarkeitsbereich der äußeren Funktion abgegrenzt.

• Die innere Funktion kann nur mit Anweisungen von der äußeren Funktion aus angesprochen werden.
• Die innere Funktion kann auf die Argumente und Variablen der äußeren Funktion zugreifen. Die äußere Funktion kann jedoch nicht auf die Argumente und Variablen der inneren Funktion zugreifen.

Math-Objekt

Math.PI

Ebenso besitzt das Math-Objekt Methoden für mathematische Standardfunktionen der Trigonometrie, Logarithmen, Exponentialfunktion und andere. Die trigonometrische Funktion sinus kann z. B. so benutzt werden:

Math.sin(1.56)

Achtung: Alle Argumente der trigonometrischen Funktionen werden als Radiant angegeben.

Die folgende Tabelle stellt eine Übersicht über die Methoden des Math-Objekts dar.

Anders als bei vielen anderen Objekten erstellt man niemals selbst ein Math-Objekt, sondern benutzt immer das vordefinierte.

Number-Objekt

var biggestNum = Number.MAX_VALUE;
var smallestNum = Number.MIN_VALUE;
var infiniteNum = Number.POSITIVE_INFINITY;
var negInfiniteNum = Number.NEGATIVE_INFINITY;
var notANum = Number.NaN;

Man bezieht sich immer auf eine Eigenschaft des vordefinierten Number-Objekts, wie oben gezeigt, und nicht auf Eigenschaften eines Number-Objekts, das selbst erstellt wurde.

Der Prototype von Number stellt Methoden zum Abrufen von Informationen aus Number-Objekten in verschiedenen Formaten bereit. Die folgende Tabelle fasst die Methoden von Number.prototype zusammen.

RegExp-Objekt

Das RegExp-Objekt ermöglicht das Arbeiten mit regulären Ausdrücken. Es ist im Kapitel Reguläre Ausdrücke beschrieben.

String-Objekt

Das String-Objekt ist eine Hülle um den primitiven String-Datentyp. Es sollte nicht mit einem String-Literal verwechselt werden. Der folgende Code erstellt z.B. einen String-Literal s1 und ein String-Object s2:

var s1 = "foo"; // erstellt einen String-Literal
var s2 = new String("foo"); // erstellt ein String-Objekt

Alle Methoden des String-Objekts können für String-Literale aufgerufen werden. JavaScript konvertiert den String-Literal automatisch zu einem temporären String-Objekt, ruft die Methode auf und verwirft das temporäre Objekt wieder. Auch die Methode String.length kann auf einen String-Literal angewendet werden.

String-Literale sollten verwendet werden, solange nicht unbedingt ein String-Objekt gebraucht wird, da String-Objekte ein nicht intuitives Verhalten aufweisen können. Zum Beispiel:

var s1 = "2 + 2"; // erstellt einen String-Literal
var s2 = new String("2 + 2"); // erstellt ein String-Objekt
eval(s1); // gibt 4 zurück
eval(s2); // gibt den String "2 + 2" zurück

Ein String-Object besitzt eine Eigenschaft, length, welche den Wert für die Anzahl der Zeichen des Strings angibt. Der folgende Code weist x den Wert 13 zu, weil der String "Hello, World!" aus 13 Zeichen besteht:

var mystring = "Hello, World!";
var x = mystring.length;

mystring.link("http://www.helloworld.com")

Die folgende Tabelle fasst die Methoden des String-Objekts zusammen.