Stil mit {stil}

Okt 2007

Javascript Arrays – Eigenschaften und Methoden von Arrays

constructor

enthält die Funktion, die den Prototypen des Objekts erzeugt hat.
Syntax: object.constructor

index (nur lesen)

erzeugt durch einen Treffer mit einem regulären Ausdruck; enthält den Index des Treffers beginnend bei 0.
Syntax: object.index

input (nur lesen)

erzeugt durch einen Treffer mit einem regulären Ausdruck; enthält die originale Zeichenkette, gegen die der Treffer erzielt wurde.
Syntax: object.input

length (unsigned 32 bit integer)

Anzahl der Elemente des Arrays. Kann unabhängig von der Anzahl der Elemente im Array geändert werden.
Syntax: object.length

prototype

wird benutzt, um dem Array weitere Eigenschaften hinzuzufügen.
Syntax: object.prototype

concat(elem1 [, elem2 ... elemN])

hängt neue Elemente an das Ende eines Arrays. Wenn ein neues Element ein Array ist, wird es linearisiert und seine Elemente werden am Ende des Arrays eingefügt. Das Original des angehangenen Arrays bleibt allerdings erhalten.

var myArray1 = new Array(10, 20, 30);
var elem     = 333;
var myArray2 = new Array(1000, 2000, 3000);
myArray1 = myArray1.concat(elem, myArray2); 

alert(myArray1);           // Ausgabe: 10,20,30,333,1000,2000,3000

Der Aufruf myArray1 = myArray1.concat(elem, myArray2); fügt zuerst 333, den Wert von elem an das Ende des Arrays myArray1 an und dann das linearisierte Array myArray2 – also die einzelnen Werte von myArray2: 1000, 2000, 3000.

Wenn Array2 allerdings ein verschachteltes Array ist, wird die Linearisierung nur auf der ersten Ebene durchgeführt.

var myArray1 = new Array(10, 20, 30);
var myArray2 = new Array((33, 44, 55), (66, 77, 88));
var myArray3 = myArray1.concat(myArray2);
	
alert(myArray3);           // Ausgabe: 10,20,30,55,88

join(separator)

konvertiert die Elemente des Arrays in einen String und verbindet sie zu einem langen String, getrennt durch den im Parameter angegebenen Separator (Vorgabe: Komma). Der Inhalt des Arrays wird nicht geändert.

var colors = new Array("rot", "grau", "gelb", "blau", "rosa");
var aString = colors.join(" || ");
	
alert(aString);            // Ausgabe:  rot || grau || gelb || blau || rosa

Die Anweisung var aString = colors.join(" || "); verbindet alle Elemente des Arrays colors zu einem String und setzt " || " zwischen die vormaligen Arrayelemente. Das Ergebnis wird der Variablen aString zugewiesen.

pop()

Entfernt das letzte Element aus dem Array und gibt dieses Element zurück.

var trees = new Array("Kokospalme", "Rotbuch", "Tanne", "Birke", "Ahornbaum");
var last = trees.pop();
alert ("trees " + trees + " last " + last);   
// Ausgabe trees Kokospalme,Rotbuch,Tanne,Birke last Ahornbaum

var last = trees.pop(); entfernt das letzte Element aus dem Array trees und weist das Element der Variablen last zu.

push()

Fügt ein oder mehrere elemente am Ende des Arrays an und gibt die neue Länge des Arrays zurück

var trees = new Array("Kokospalme", "Rotbuch", "Tanne", "Birke", "Ahornbaum");
var len = trees.push("Hibiskus", "Pappel");
alert ("trees " + trees + " len " + len);
// trees Kokospalme,Rotbuch,Tanne,Birke,Ahornbaum,Hibiskus,Pappel len 7

var len = trees.push("Hibiskus", "Pappel"); fügt die Elemente "Hibiskus" und "Pappel" am Ende des Arrays trees ein und weist der Variablen len die neue Länge des Arrays zu.

reverse()

kehrt die Reihenfolge der Elemente in einem Array um.

var days = new Array("Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag");
days.reverse();
	
alert(days);               // AusgabeFreitag,Donnerstag,Mittwoch,Dienstag,Montag

Der Aufruf days.reverse(); kehrt die Reihenfolge der Arrayelemente um, so dass das letzte Element zum ersten Element wird.

shift()

entfernt das erste Element des Arrays und läßt die folgenden Elemente um einen Index nach vorn rutschen – die Elemente des Arrays werden nach links verschoben und das erste Element fällt dabei aus dem Array heraus.

var colors = new Array("rot", "grau", "gelb", "blau", "rosa");
var elem = colors.shift();
	
alert("colors " + colors + " elem " + elem);
// Ausgabe colors grau,gelb,blau,rosa elem rot

var elem = colors.shift(); weist den Wert des ersten Elements der Variablen elem zu und entfernt das erste Element aus dem Array colors.

slice(start[, end])

schneidet einen Bereich aus einem Array aus und gibt den ausgeschnittenen Bereich zurück. start ist die Anfangsposition und end die Position nach dem ausgeschnittenen Bereich. Wenn eine der beiden Zahlen negativ ist, wird vom Ende des Arrays aus gezählt. Das Originalarray bleibt erhalten.

                          0        1       2        3        4
var names = new Array("Anna", "Benno", "Emma", "Lasse", "Molly");

var a = names.slice(0,3);
var b = names.slice(4);
var c = names.slice(0, -2);

alert(a + "\n" + b + "\n" + c);

// gibt aus: 
// Anna,Benno,Emma
// Molly
// Anna,Benno,Emma

names.slice(0,3); schneidet die Elemente vom Index 0 bis zum Index vor 3 aus, names.slice(4); schneidet das Element mit dem Index 4 aus, names.slice(0, -2); schneidet die Elemente vom Index 0 bis zum Index 4-2=2 aus.

splice(start, c [, elem1, elem, …, elemC])

splice() fügt c Elemente, die als Parameter elem1, elem2, … elemC aufgeführt sind, in ein Array array ab Position start ein und überschreibt dabei vorhandene Elemente. Werden die optionalen Parameter elem1, elem2, … , elemC nicht benutzt, löscht splice() delcount Elemente ab Position start. IE ab Version 5.5.

//                        0       1       2       3       4       5
var colors = new Array("rot", "grün", "blau", "gelb", "oliv", "grau");

colors.splice(0, 3, "lila", "braun", "ocker");
alert( colors );           // Ausgabe: lila,braun,ocker,gelb,oliv,grau

colors.splice(2, 4);
alert( colors );           // Ausgabe: lila,braun

Die Anweisung colors.splice(0, 3, "lila", "braun", "ocker"); schneidet ab Position 0 drei Elemente aus colors und setzt drei neue Elemente lila, braun und ocker hinzu. Also enthält das Array colors am Ende der Anweisung lila, braun, ocker, gelb, oliv, grau. colors.splice(2, 4); schneidet ab Position 2 vier Elemente aus colors aus, so dass lila und braun bleiben.

Die Methode verändert das Array. Alles was aus dem Array herausgeschnitten wurde, kann einer Variablen übergeben werden.

Einzelnes Element aus Array entfernen

Javascript bietet keine direkte Methode, um ein einzelnes Element aus einem Array zu entfernen. Da hilft man sich mit den Methoden slice und concat.

var vdw = new Array(
    	'Hans',    // 0
    	'Emil',    // 1
    	'Georg',   // 2
    	'Karl',    // 3
    	'Hugo',    // 4
    	'Berhard', // 5
    	'August',  // 6
    	'Friedrich'// 7
    	);
    	
var arr = [];
arr = vdw.slice(0,4).concat( vdw.slice(4+1) );

array.sort([compare])

sortiert die Elemente eines Arrays in lexikalische Folge (wobei 30 vor 4 rangiert), und zwar abhängig von Groß- und Kleinschreibung. Andere Sortierfolgen werden durch den optionalen Parameter compare als Funktion implementiert. Die Methode ändert den Inhalt des Arrays.

var colors = new Array("rote Haare", "Grünton", "gelb", "Oliv", "Grauzone");
var numbers = new Array (600, 204, 13, 2.4, 7, -15,3, -2.3e3);
var bool = new Array (true, false, true, true, false);
var mixed = new Array (100, "King Kong", 205, true);
colors.sort();
bool.sort();
mixed.sort();
numbers.sort();
	
alert(colors + "\n" + bool + "\n" + mixed + "\n" + numbers);    
   // Ausgabe    Grauzone,Grünton,Oliv,gelb,rote Haare
   //            false,false,true,true,true
   //            100,205,King Kong,true
   //            -15,-2300,13,2.4,204,3,600,7

Wenn eine andere Sortierfunktion gefordert ist, kann eine Funktion als Argument übergeben werden. Diese Funktion soll zwei Werte vergleichen und einen Wert zurückgeben, der die Sortierreihenfolge feststellt:

• -1, wenn das erste Element vor dem folgenden stehen soll,
• 1, wenn das zweite Element vor dem ersten rangieren soll,
• 0, wenn die beiden Elemente gleich sind und in beliebiger Folge stehen können.

Wenn Zahlen miteinander verglichen werden, braucht die Vergleichsfunktion nur die zweite von der ersten Zahl subtrahieren:

var numbers = new Array (600, 204, 13, 2.4, 7, -15,3, -2.3e3);
function numSort(a, b) { 
   return (a - b);
} 
numbers.sort(numSort);
alert(numbers);              // Ausgabe -2300,-15,2.4,3,7,13,204,600

var trees = new Array("Kokospalme", "Rotbuch", "Tanne", "Birke", "Ahornbaum");

function len(a, b) {
   var sort = (a.length < b.length) ? -1 : (b.length < a.length) ? 1 : 0;
   return sort;
}

trees.sort(len);
alert(trees);              // Ausgabe: Tanne,Birke,Rotbuch,Ahornbaum,Kokospalme

Die Funktion len(a, b) vergleicht die Länge zweier Strings und gibt -1 zurück, wenn a länger als b ist, 1, wenn b länger als a ist und 0 sonst. trees.sort(len) sortiert das Array trees nach der Länge der Strings.

toSource

Gibt ein Array-Literal zurück, das das angegebene Array darstellt und kann benutzt werden, um ein neues Array zu erzeugen. Überschreibt die Methode Object.toSource()

toString

Arrays erben die Methode toString vom Objekt Object. toString gibt einen String mit dem spezifizierten Array und seinen Elementen zurück. Überschreibt die Methode Object.toString().
Syntax: Array.toString()

toLocaleString

unshift([item])

fügt ein oder mehrere Element am Anfang des Arrays ein und gibt die neue Länge zurück.

var trees = new Array("Kokospalme", "Rotbuch", "Tanne", "Birke");
var len = trees.unshift("Weide", "Pappel");
alert("trees " + trees + " len " + len);
// Ausgabe: trees Weide,Pappel,Kokospalme,Rotbuch,Tanne,Birke len 7

var len = trees.unshift("Weide", "Pappel"); fügt die Elemente mit dem Wert "Weide" und "Pappel" am Anfang des Arrays trees ein und speicher die neue Anzahl der Arrayelement in der Variablen len.

valueOf

Array erben die Methode valueOf vom Objekt Object. valueOf gibt einen primitiven Wert für das angegebene Array zurück. Überschreibt die Methode Object.valueOf().
Syntax: Array.valueOf()