mozilla
Ihre Suchergebnisse

    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 für mehr Informationen.

    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.

    Introduced in JavaScript 1.6

    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"]

    Introduced in JavaScript 1.6

    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.

    Introduced in JavaScript 1.8

    • 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

    Introduced in JavaScript 1.6

    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

    Introduced in JavaScript 1.7

    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 Statement 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
    
    Bei diesem Beispiel wird ein Date-Objekt mit dem Namen today erstellt, welches das heutige Datum enthält. Danach wird ein zweites Date-Objekt mit dem Namen EndYear erstellt und das Jahr auf das aktuelle Jahr gesetzt. Anschließend werden anhand der Millisekunden pro Tag die Tage zwischen today und EndYear berechnet, wobei die Methode getTime zum Einsatz kommt und zu ganzen Tagen aufgerundet wird.

    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

    Beim folgenden Beispiel gibt die Funktion JSClock() die aktuelle Uhrzeit im Format einer digitalen Uhr zurück.
    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;
    }
    
    Die JSClock-Funktion erstellt zunächst ein neues Date-Objekt mit dem Namen time. Da keine Argumente angegeben sind, wird es mit dem aktuellen Datum und der aktuellen Zeit erstellt. Anschließend werden die Werte der Methoden-Aufrufe von getHours, getMinutes und getSeconds den Variablen hour, minute, und second zugewiesen.
     
    Die nächsten vier Anweisungen erzeugen einen String mit der aktuellen Zeit. Die erste Anweisung erstellt eine Variable temp, der über einen bedingten Ausdruck ein Wert zugewiesen wird; wenn der Wert von hour größer als 12 ist, wird der Variablender Wert hour - 12 zugewiesen, ansonsten der Wert von hour. Falls hour gleich 0 ist, wird temp der Wert 12 zugewiesen.
     
    Die nächsten beiden Anweisungen fügen an den String von temp weiteren Text an. Wenn der Wert von minute bzw. second kleiner als 10 ist, wird ein Doppelpunkt und eine 0 angefügt, andernfalls nur ein Doppelpunkt. Anschließend wird noch der Wert von minute bzw. second angefügt.

    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

    Das vordefinierte Math-Objekt besitzt Eigenschaften und Methoden für mathematische Konstanten und Funktionen. Die Eigenschaft PI des Math-Objekts hat z.B. den Wert von Pi (3.141...) und kann wie folgt in einer Applikation verwendet werden:
    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.

    Tabelle 7.1 Methoden von Math
    Methode Beschreibung
    abs Absoluter Wert
    sin, cos, tan Trigonometrische Standardfunktionen; Das Argument ist ein Radiant
    acos, asin, atan, atan2 Inverse trigonometrische Funktionen; geben den Wert als Radiant zurück
    exp, log Exponentialfunktion e und natürlicher Logarithmus
    ceil

    Gibt die kleinste ganze Zahl zurück, die größer oder gleich dem Argument ist

    floor Gibt die größte ganze Zahl zurück, die kleiner oder gleich dem Argument ist
    min, max Gibt von zwei Argumenten, die kleinere oder größere Zahl zurück
    pow Exponentialfunktion; das erste Argumente ist die Basis, das zweite der Exponent
    random Zufälliger Wert zwischen 0 und 1
    round Rundet das Argument auf die nächstliegende ganze Zahl
    sqrt Quadratwurzel

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

    Number-Objekt

    Das Number-Objekt verfügt über Eigenschaften für numerische Konstanten, z. B. Maximalwert, not-a-number und Unendlichkeit. Die Werte dieser Eigenschaften können nicht verändert werden. Sie werden wie folgt verwendet:
    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.

    In der folgenden Tabelle sind die Eigenschaften des Number-Objekts zusammengefasst.
     
    Tabelle 7.2 Eigenschaften von Number
    Eigenschaften Beschreibung
    MAX_VALUE Die größte darstellbare Zahl
    MIN_VALUE Die kleinste darstellbare Zahl
    NaN Spezieller "not a number"-Wert
    NEGATIVE_INFINITY Spezieller negativer Unendlichkeitswert; wird bei Überschreitung zurückgegeben
    POSITIVE_INFINITY Spezieller positiver Unendlichkeitswert; wird bei Überschreitung zurückgegeben

    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.

    Tabelle 7.3 Methoden von Number.prototype
    Methode Beschreibung
    toExponential Gibt einen String mit dem numerischen Wert in exponentieller Notation zurück
    toFixed Gibt einen String mit dem numerischen Wert als Gleitkommazahl zurück
    toPrecision Gibt einen String mit dem numerischen Wert als Gleitkommazahl und mit beliebig vielen Nachkommastellen zurück
    toSource Gibt ein Objekt-Literal zurück, welches das spezifizierte Number-Objekt repräsentiert; der Wert kann zur Erstellung eines neuen Objekts benutzt werden; überschreibt die Methode Object.toSource.
    toString Gibt einen String zurück, welcher das angegebene Objekt repräsentiert; überschreibt die Methode Object.toString.
    valueOf Gibt den primitiven Wert des spezifizierten Objekts zurück; überschreibt die Methode Object.valueOf.

    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;
    
    Ein String-Objekt hat zwei Arten von Methoden: solche, die eine Variation der Zeichenfolge selbst zurückliefern, wie z. B. substring und toUpperCase; und solche, die eine HTML-formatierte Version der Zeichenfolge zurückgeben, wie bold und link.

    Beim vorigen Beispiel geben z. B. beide Methoden, mystring.toUpperCase() und "hello, world!".toUpperCase(),die Zeichenfolge "HELLO, WORLD!" zurück.

    Die substring-Methode nimmt zwei Argumente entgegen und gibt die Zeichen des Strings zurück, welche zwischen den beiden Positionen liegen. Bezogen auf das vorige Beispiel gibt mystring.substring(4, 9) die Zeichenfolge "o, Wo" zurück. In der JavaScript-Referenz findet man genauere Informationen zur Methode substring.

    Das String-Objekt besitzt auch eine Reihe von Methoden für die automatische HTML-Formatierung, wie bold für fettgedruckten Text und link zur Erstellung eines Hyperlinks. Einen Hyperlink zu einer hypothetischen URL kann man mit der Methode link z. B. wie folgt erstellen:
    mystring.link("http://www.helloworld.com")
    

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

    Tabelle 7.4 Methoden von String-Instanzen
    Methode Beschreibung
    anchor Erstellt einen HTML-Anker
    big, blink, bold, fixed, italics, small, strike, sub, sup Erstellt einen HTML-formatierten String
    charAt, charCodeAt Gibt ein Zeichen oder einen Zeichencode an einer bestimmten Position eines Strings zurück
    indexOf, lastIndexOf

    Gibt die Position eines spezifizierten Substring in einem String bzw. die Position des letzten Vorkommen des Substrings zurück

    link Erstellt einen HTML-Hyperlink
    concat Kombiniert den Text zweier Strings und gibt einen neuen String zurück
    fromCharCode Konstruiert einen String aus den übergebenen Unicode-Sequenzen; dies ist eine Methode der String-Klasse und keine Instanz.
    split Teilt ein String-Objekt in ein Array mit Strings anhand eines Trennzeichens auf
    slice Extrahiert einen Teil eines Strings und gibt einen neuen String zurück
    substring, substr Gibt einen Teil des String zurück; entweder wird der Index für Anfang und Ende oder der Start und eine Länge angegeben
    match, replace, search Methoden zum Arbeiten mit regulären Ausdrücken
    toLowerCase, toUpperCase

    Gibt den String umgewandelt in Klein- oder Großschreibweise zurück

    Schlagwörter des Dokuments und Mitwirkende

    Mitwirkende an dieser Seite: eminor, ethertank, fscholz
    Zuletzt aktualisiert von: fscholz,