ECMAScript ist der offizielle Name für JavaScript. Ein neuer Name wurde notwendig, da es eine Marke für JavaScript gibt (ursprünglich von Sun, jetzt von Oracle gehalten). Derzeit ist Mozilla eines der wenigen Unternehmen, denen es gestattet ist, den Namen JavaScript offiziell zu verwenden, da es vor langer Zeit eine Lizenz erhalten hat. Für den allgemeinen Sprachgebrauch gelten folgende Regeln:

JavaScript-Schöpfer Brendan Eich hatte keine andere Wahl, als die Sprache sehr schnell zu entwickeln (oder andere, schlechtere Technologien wären von Netscape übernommen worden). Er borgte sich von mehreren Programmiersprachen: Java (Syntax, primitive Werte versus Objekte), Scheme und AWK (First-Class-Funktionen), Self (prototypische Vererbung) und Perl und Python (Strings, Arrays und reguläre Ausdrücke).

JavaScript hatte bis ECMAScript 3 keine Ausnahmebehandlung. Dies erklärt, warum die Sprache Werte so oft automatisch konvertiert und so oft stillschweigend fehlschlägt: Sie konnte anfangs keine Ausnahmen auslösen.

Einerseits hat JavaScript Eigenheiten und es fehlt ihm einiges an Funktionalität (blockbezogene Variablen, Module, Unterstützung für Unterklassen usw.). Andererseits verfügt es über mehrere leistungsstarke Funktionen, mit denen Sie diese Probleme umgehen können. In anderen Sprachen lernen Sie Sprachfunktionen. In JavaScript lernen Sie oft stattdessen Muster.

Angesichts seiner Einflüsse ist es keine Überraschung, dass JavaScript einen Programmierstil ermöglicht, der eine Mischung aus funktionaler Programmierung (Higher-Order-Funktionen; integrierte map, reduce usw.) und objektorientierter Programmierung (Objekte, Vererbung) ist.

Einige Beispiele für Syntax:

// Two slashes start single-line comments

var x;  // declaring a variable

x = 3 + y;  // assigning a value to the variable `x`

foo(x, y);  // calling function `foo` with parameters `x` and `y`
obj.bar(3);  // calling method `bar` of object `obj`

// A conditional statement
if (x === 0) {  // Is `x` equal to zero?
    x = 123;
}

// Defining function `baz` with parameters `a` and `b`
function baz(a, b) {
    return a + b;
}

Beachten Sie die beiden unterschiedlichen Verwendungen des Gleichheitszeichens:

Um die Syntax von JavaScript zu verstehen, sollten Sie wissen, dass sie zwei Hauptsynthesekategorien hat: Anweisungen und Ausdrücke:

Der Unterschied zwischen Anweisungen und Ausdrücken wird am besten dadurch verdeutlicht, dass JavaScript zwei verschiedene Möglichkeiten hat, if-then-else zu tun – entweder als Anweisung:

var x;
if (y >= 0) {
    x = y;
} else {
    x = -y;
}

oder als Ausdruck

var x = y >= 0 ? y : -y;

Letzteres können Sie als Funktionsargument verwenden (aber nicht ersteres)

myFunction(y >= 0 ? y : -y)

Schließlich können Sie überall dort, wo JavaScript eine Anweisung erwartet, auch einen Ausdruck verwenden; zum Beispiel

foo(7, 1);

Die gesamte Zeile ist eine Anweisung (eine sogenannte Ausdrucksanweisung), aber der Funktionsaufruf foo(7, 1) ist ein Ausdruck.

Semikolons sind in JavaScript optional. Ich empfehle jedoch, sie immer einzufügen, da JavaScript andernfalls falsch über das Ende einer Anweisung raten kann. Die Details werden in Automatischer Semikolon-Einfügung erläutert.

Semikolons beenden Anweisungen, aber keine Blöcke. Es gibt einen Fall, in dem Sie ein Semikolon nach einem Block sehen werden: Ein Funktionsausdruck ist ein Ausdruck, der mit einem Block endet. Wenn ein solcher Ausdruck zuletzt in einer Anweisung kommt, folgt ihm ein Semikolon:

// Pattern: var _ = ___;
var x = 3 * 7;
var f = function () { };  // function expr. inside var decl.

JavaScript hat zwei Arten von Kommentaren: einzeilige Kommentare und mehrzeilige Kommentare. Einzeilige Kommentare beginnen mit // und enden am Zeilenende:

x++; // single-line comment

Mehrzeilige Kommentare werden durch /* und */ abgegrenzt:

/* This is
   a multiline
   comment.
 */

Sie können eine Variable deklarieren und ihr gleichzeitig einen Wert zuweisen:

var foo = 6;

Sie können auch einer vorhandenen Variablen einen Wert zuweisen

foo = 4;  // change variable `foo`

Es gibt zusammengesetzte Zuweisungsoperatoren wie +=. Die folgenden beiden Zuweisungen sind äquivalent:

x += 1;
x = x + 1;

Bezeichner sind Namen, die in JavaScript verschiedene syntaktische Rollen spielen. Zum Beispiel ist der Name einer Variablen ein Bezeichner. Bezeichner sind Groß- und Kleinschreibungsempfindlich.

Ungefähr kann das erste Zeichen eines Bezeichners ein beliebiges Unicode-Buchstabe, ein Dollarzeichen ($) oder ein Unterstrich (_) sein. Nachfolgende Zeichen können zusätzlich jede Unicode-Ziffer sein. Daher sind die folgenden alle gültige Bezeichner

arg0
_tmp
$elem
π

Die folgenden Bezeichner sind reservierte Wörter – sie sind Teil der Syntax und können nicht als Variablenamen (einschließlich Funktionsnamen und Parameternamen) verwendet werden:

Die folgenden drei Bezeichner sind keine reservierten Wörter, aber Sie sollten sie so behandeln, als wären sie es

Schließlich sollten Sie auch die Namen von Standard-Globalvariablen meiden (siehe Kapitel 23). Sie können sie für lokale Variablen verwenden, ohne etwas kaputt zu machen, aber Ihr Code wird trotzdem verwirrend.

JavaScript trifft eine etwas willkürliche Unterscheidung zwischen Werten:

Ein Hauptunterschied zwischen den beiden besteht darin, wie sie verglichen werden; jedes Objekt hat eine eindeutige Identität und ist nur (strikt) gleich sich selbst:

> var obj1 = {};  // an empty object
> var obj2 = {};  // another empty object
> obj1 === obj2
false
> obj1 === obj1
true

Im Gegensatz dazu gelten alle primitiven Werte, die denselben Wert kodieren, als gleich

> var prim1 = 123;
> var prim2 = 123;
> prim1 === prim2
true

Die nächsten beiden Abschnitte erklären primitive Werte und Objekte im Detail.

Die folgenden sind alle primitiven Werte (oder kurz Primitives):

Primitives haben die folgenden Merkmale:

Alle nicht-primitiven Werte sind Objekte. Die gängigsten Arten von Objekten sind:

Objekte haben die folgenden Merkmale:

Die meisten Programmiersprachen haben Werte, die fehlende Informationen bezeichnen. JavaScript hat zwei solche „Nicht-Werte“, undefined und null:

if (x === undefined || x === null) {
    ...
}

if (!x) {
    ...
}

Es gibt zwei Operatoren zur Kategorisierung von Werten: typeof wird hauptsächlich für primitive Werte verwendet, während instanceof für Objekte verwendet wird.

typeof sieht so aus

typeof value

Es gibt einen String zurück, der den „Typ“ von value beschreibt. Hier sind einige Beispiele

> typeof true
'boolean'
> typeof 'abc'
'string'
> typeof {} // empty object literal
'object'
> typeof [] // empty array literal
'object'

Die folgende Tabelle listet alle Ergebnisse von typeof auf

typeof null gibt 'object' zurück, was ein Fehler ist, der nicht behoben werden kann, da er bestehenden Code brechen würde. Es bedeutet nicht, dass null ein Objekt ist.

instanceof sieht so aus

value instanceof Constr

Es gibt true zurück, wenn value ein Objekt ist, das vom Konstruktor Constr erstellt wurde (siehe Konstruktoren: Fabriken für Objekte). Hier sind einige Beispiele

> var b = new Bar();  // object created by constructor Bar
> b instanceof Bar
true

> {} instanceof Object
true
> [] instanceof Array
true
> [] instanceof Object  // Array is a subconstructor of Object
true

> undefined instanceof Object
false
> null instanceof Object
false

Immer wenn JavaScript einen booleschen Wert erwartet (z. B. für die Bedingung einer if-Anweisung), kann jeder Wert verwendet werden. Er wird als true oder false interpretiert. Die folgenden Werte werden als false interpretiert

Alle anderen Werte (einschließlich aller Objekte!) werden als true betrachtet. Werte, die als false interpretiert werden, werden falsy genannt, und Werte, die als true interpretiert werden, werden truthy genannt. Boolean(), als Funktion aufgerufen, konvertiert seinen Parameter in einen Boolean. Sie können es verwenden, um zu testen, wie ein Wert interpretiert wird

> Boolean(undefined)
false
> Boolean(0)
false
> Boolean(3)
true
> Boolean({}) // empty object
true
> Boolean([]) // empty array
true

Binäre logische Operatoren in JavaScript sind short-circuiting. Das heißt, wenn der erste Operand ausreicht, um das Ergebnis zu bestimmen, wird der zweite Operand nicht ausgewertet. Zum Beispiel werden in den folgenden Ausdrücken die Funktion foo() niemals aufgerufen:

false && foo()
true  || foo()

Darüber hinaus geben binäre logische Operatoren entweder einen ihrer Operanden zurück – der ein Boolean sein kann oder nicht. Eine Prüfung auf Wahrheit wird verwendet, um zu bestimmen, welcher

JavaScript hat zwei Arten von Gleichheit:

Normale Gleichheit betrachtet (zu) viele Werte als gleich (die Details werden in Normale (nachgiebige) Gleichheit (==, !=) erklärt), was Fehler verbergen kann. Daher wird immer die Verwendung von strikter Gleichheit empfohlen.

Zeichenketten werden über den Plusoperator (+) verkettet, der den anderen Operanden in eine Zeichenkette umwandelt, wenn einer der Operanden eine Zeichenkette ist:

> var messageCount = 3;
> 'You have ' + messageCount + ' messages'
'You have 3 messages'

Um Zeichenketten in mehreren Schritten zu verketten, verwenden Sie den Operator +=:

> var str = '';
> str += 'Multiple ';
> str += 'pieces ';
> str += 'are concatenated.';
> str
'Multiple pieces are concatenated.'

Zeichenketten haben viele nützliche Methoden (siehe String-Prototyp-Methoden). Hier sind einige Beispiele

> 'abc'.slice(1)  // copy a substring
'bc'
> 'abc'.slice(1, 2)
'b'

> '\t xyz  '.trim()  // trim whitespace
'xyz'

> 'mjölnir'.toUpperCase()
'MJÖLNIR'

> 'abc'.indexOf('b')  // find a string
1
> 'abc'.indexOf('x')
-1

Die Anweisung if hat eine then-Klausel und eine optionale else-Klausel, die je nach boolescher Bedingung ausgeführt werden:

if (myvar === 0) {
    // then
}

if (myvar === 0) {
    // then
} else {
    // else
}

if (myvar === 0) {
    // then
} else if (myvar === 1) {
    // else-if
} else if (myvar === 2) {
    // else-if
} else {
    // else
}

Ich empfehle, immer geschweifte Klammern zu verwenden (sie bezeichnen Blöcke von null oder mehr Anweisungen). Sie müssen dies jedoch nicht tun, wenn eine Klausel nur eine einzige Anweisung ist (dasselbe gilt für die Kontrollflussanweisungen for und while):

if (x < 0) return -x;

Das Folgende ist eine switch-Anweisung. Der Wert von fruit bestimmt, welcher case ausgeführt wird:

switch (fruit) {
    case 'banana':
        // ...
        break;
    case 'apple':
        // ...
        break;
    default:  // all other cases
        // ...
}

Der „Operand“ nach case kann jeder Ausdruck sein; er wird über === mit dem Parameter von switch verglichen.

Die for-Schleife hat das folgende Format:

for (⟦«init»⟧; ⟦«condition»⟧; ⟦«post_iteration»⟧)
    «statement»

init wird am Anfang der Schleife ausgeführt. condition wird vor jeder Schleifeniteration überprüft; wenn sie false wird, wird die Schleife beendet. post_iteration wird nach jeder Schleifeniteration ausgeführt.

Dieses Beispiel gibt alle Elemente des Arrays arr auf der Konsole aus

for (var i=0; i < arr.length; i++) {
    console.log(arr[i]);
}

Die while-Schleife führt ihren Körper weiter aus, solange ihre Bedingung gilt:

// Same as for loop above:
var i = 0;
while (i < arr.length) {
    console.log(arr[i]);
    i++;
}

Die do-while-Schleife führt ihren Körper weiter aus, solange ihre Bedingung gilt. Da die Bedingung dem Körper folgt, wird der Körper immer mindestens einmal ausgeführt:

do {
    // ...
} while (condition);

In allen Schleifen:

Funktionsdeklarationen werden gehoben – d. h. ihre Gesamtheit wird an den Anfang des aktuellen Geltungsbereichs verschoben. Das erlaubt Ihnen, auf später deklarierte Funktionen zu verweisen:

function foo() {
    bar();  // OK, bar is hoisted
    function bar() {
        ...
    }
}

Beachten Sie, dass var-Deklarationen zwar ebenfalls gehoben werden (siehe Variablen werden gehoben), aber die Zuweisungen, die sie vornehmen, nicht

function foo() {
    bar();  // Not OK, bar is still undefined
    var bar = function () {
        // ...
    };
}

Sie können jede Funktion in JavaScript mit einer beliebigen Anzahl von Argumenten aufrufen; die Sprache wird nie klagen. Sie wird jedoch alle Parameter über die spezielle Variable arguments verfügbar machen. arguments sieht aus wie ein Array, hat aber keine der Array-Methoden:

> function f() { return arguments }
> var args = f('a', 'b', 'c');
> args.length
3
> args[0]  // read element at index 0
'a'

Verwenden wir die folgende Funktion, um zu untersuchen, wie zu viele oder zu wenige Parameter in JavaScript behandelt werden (die Funktion toArray() wird in Argumente in ein Array konvertieren gezeigt)

function f(x, y) {
    console.log(x, y);
    return toArray(arguments);
}

Zusätzliche Parameter werden ignoriert (außer von arguments)

> f('a', 'b', 'c')
a b
[ 'a', 'b', 'c' ]

Fehlende Parameter erhalten den Wert undefined:

> f('a')
a undefined
[ 'a' ]
> f()
undefined undefined
[]

Das Folgende ist ein gängiges Muster zum Zuweisen von Standardwerten zu Parametern:

function pair(x, y) {
    x = x || 0;  // (1)
    y = y || 0;
    return [ x, y ];
}

In Zeile (1) gibt der Operator || x zurück, wenn er truthy ist (nicht null, undefined usw.). Andernfalls gibt er den zweiten Operanden zurück

> pair()
[ 0, 0 ]
> pair(3)
[ 3, 0 ]
> pair(3, 5)
[ 3, 5 ]

Wenn Sie eine Arity (eine bestimmte Anzahl von Parametern) erzwingen möchten, können Sie arguments.length überprüfen:

function pair(x, y) {
    if (arguments.length !== 2) {
        throw new Error('Need exactly 2 arguments');
    }
    ...
}

arguments ist kein Array, es ist nur array-ähnlich (siehe Array-ähnliche Objekte und generische Methoden). Es hat eine Eigenschaft length, und Sie können über Indizes in eckigen Klammern auf seine Elemente zugreifen. Sie können jedoch keine Elemente entfernen oder eine der Array-Methoden darauf aufrufen. Daher müssen Sie manchmal arguments in ein Array konvertieren, was die folgende Funktion tut (sie wird in Array-ähnliche Objekte und generische Methoden erklärt)

function toArray(arrayLikeObject) {
    return Array.prototype.slice.call(arrayLikeObject);
}

Der Geltungsbereich einer Variablen ist immer die vollständige Funktion (im Gegensatz zum aktuellen Block). Zum Beispiel:

function foo() {
    var x = -512;
    if (x < 0) {  // (1)
        var tmp = -x;
        ...
    }
    console.log(tmp);  // 512
}

Wir sehen, dass die Variable tmp nicht auf den Block beschränkt ist, der in Zeile (1) beginnt; sie existiert bis zum Ende der Funktion.

Jede Variablendeklaration wird gehoben: Die Deklaration wird an den Anfang der Funktion verschoben, aber Zuweisungen, die sie vornimmt, bleiben an ihrem Platz. Als Beispiel betrachten wir die Variablendeklaration in Zeile (1) in der folgenden Funktion:

function foo() {
    console.log(tmp); // undefined
    if (false) {
        var tmp = 3;  // (1)
    }
}

Intern wird die vorherige Funktion wie folgt ausgeführt

function foo() {
    var tmp;  // hoisted declaration
    console.log(tmp);
    if (false) {
        tmp = 3;  // assignment stays put
    }
}

Jede Funktion bleibt mit den Variablen der sie umgebenden Funktionen verbunden, auch nachdem sie den Geltungsbereich verlassen hat, in dem sie erstellt wurde. Zum Beispiel:

function createIncrementor(start) {
    return function () {  // (1)
        start++;
        return start;
    }
}

Die Funktion, die in Zeile (1) beginnt, verlässt den Kontext, in dem sie erstellt wurde, aber sie bleibt mit einer Live-Version von start verbunden

> var inc = createIncrementor(5);
> inc()
6
> inc()
7
> inc()
8

Ein Closure ist eine Funktion plus die Verbindung zu den Variablen ihrer umgebenden Geltungsbereiche. Daher ist das, was createIncrementor() zurückgibt, ein Closure.

Manchmal möchten Sie einen neuen Variablen-Geltungsbereich einführen – zum Beispiel, um zu verhindern, dass eine Variable global wird. In JavaScript können Sie keinen Block dafür verwenden; Sie müssen eine Funktion verwenden. Aber es gibt ein Muster, um eine Funktion blockähnlich zu verwenden. Es heißt IIFE (immediately invoked function expression, ausgesprochen „iffy“)

(function () {  // open IIFE
    var tmp = ...;  // not a global variable
}());  // close IIFE

Stellen Sie sicher, dass Sie das vorherige Beispiel genau so eingeben, wie es gezeigt wird (abgesehen von den Kommentaren). Ein IIFE ist ein Funktionsausdruck, der sofort nach seiner Definition aufgerufen wird. Innerhalb der Funktion existiert ein neuer Geltungsbereich, der verhindert, dass tmp global wird. Konsultieren Sie Einführung eines neuen Geltungsbereichs über ein IIFE für Details zu IIFEs.

var result = [];
for (var i=0; i < 5; i++) {
    result.push(function () { return i });  // (1)
}
console.log(result[1]()); // 5 (not 1)
console.log(result[3]()); // 5 (not 3)

for (var i=0; i < 5; i++) {
    (function () {
        var i2 = i; // copy current i
        result.push(function () { return i2 });
    }());
}

Wie alle Werte haben Objekte Eigenschaften. Tatsächlich kann man ein Objekt als eine Menge von Eigenschaften betrachten, wobei jede Eigenschaft ein (Schlüssel, Wert)-Paar ist. Der Schlüssel ist eine Zeichenkette, und der Wert ist ein beliebiger JavaScript-Wert.

In JavaScript können Sie einfache Objekte direkt über Objekt-Literale erstellen.

'use strict';
var jane = {
    name: 'Jane',

    describe: function () {
        return 'Person named '+this.name;
    }
};

Das vorhergehende Objekt hat die Eigenschaften name und describe. Sie können Eigenschaften lesen („holen“) und schreiben („setzen“).

> jane.name  // get
'Jane'
> jane.name = 'John';  // set
> jane.newProperty = 'abc';  // property created automatically

Funktionswertige Eigenschaften wie describe werden als Methoden bezeichnet. Sie verwenden this, um auf das Objekt zu verweisen, das zur Aufrufung verwendet wurde:

> jane.describe()  // call method
'Person named John'
> jane.name = 'Jane';
> jane.describe()
'Person named Jane'

Der Operator in prüft, ob eine Eigenschaft existiert:

> 'newProperty' in jane
true
> 'foo' in jane
false

Wenn Sie eine nicht existierende Eigenschaft lesen, erhalten Sie den Wert undefined. Daher könnten die beiden vorherigen Prüfungen auch so durchgeführt werden:^[2]

> jane.newProperty !== undefined
true
> jane.foo !== undefined
false

Der Operator delete entfernt eine Eigenschaft:

> delete jane.newProperty
true
> 'newProperty' in jane
false

Ein Eigenschaftsschlüssel kann eine beliebige Zeichenkette sein. Bisher haben wir Eigenschaftsschlüssel in Objekt-Literalen und nach dem Punkt-Operator gesehen. Sie können sie jedoch nur auf diese Weise verwenden, wenn sie Bezeichner sind (siehe Bezeichner und Variablennamen). Wenn Sie andere Zeichenketten als Schlüssel verwenden möchten, müssen Sie sie in einem Objekt-Literal in Anführungszeichen setzen und eckige Klammern verwenden, um die Eigenschaft zu holen und zu setzen:

> var obj = { 'not an identifier': 123 };
> obj['not an identifier']
123
> obj['not an identifier'] = 456;

Eckige Klammern ermöglichen es Ihnen auch, den Schlüssel einer Eigenschaft zu berechnen:

> var obj = { hello: 'world' };
> var x = 'hello';

> obj[x]
'world'
> obj['hel'+'lo']
'world'

Wenn Sie eine Methode extrahieren, verliert sie ihre Verbindung zum Objekt. Alleinstehend ist die Funktion keine Methode mehr, und this hat den Wert undefined (im Strict Mode).

Als Beispiel kehren wir zum früheren Objekt jane zurück.

'use strict';
var jane = {
    name: 'Jane',

    describe: function () {
        return 'Person named '+this.name;
    }
};

Wir möchten die Methode describe von jane extrahieren, sie in eine Variable func legen und aufrufen. Das funktioniert jedoch nicht.

> var func = jane.describe;
> func()
TypeError: Cannot read property 'name' of undefined

Die Lösung besteht darin, die Methode bind() zu verwenden, die alle Funktionen haben. Sie erstellt eine neue Funktion, deren this immer den angegebenen Wert hat:

> var func2 = jane.describe.bind(jane);
> func2()
'Person named Jane'

Jede Funktion hatihre eigene spezielle Variable this. Dies ist unbequem, wenn Sie eine Funktion innerhalb einer Methode verschachteln, da Sie von der Funktion aus nicht auf this der Methode zugreifen können. Das Folgende ist ein Beispiel, bei dem wir forEach mit einer Funktion aufrufen, um ein Array zu durchlaufen:

var jane = {
    name: 'Jane',
    friends: [ 'Tarzan', 'Cheeta' ],
    logHiToFriends: function () {
        'use strict';
        this.friends.forEach(function (friend) {
            // `this` is undefined here
            console.log(this.name+' says hi to '+friend);
        });
    }
}

Der Aufruf von logHiToFriends führt zu einem Fehler.

> jane.logHiToFriends()
TypeError: Cannot read property 'name' of undefined

Schauen wir uns zwei Möglichkeiten an, dies zu beheben. Erstens könnten wir this in einer anderen Variablen speichern.

logHiToFriends: function () {
    'use strict';
    var that = this;
    this.friends.forEach(function (friend) {
        console.log(that.name+' says hi to '+friend);
    });
}

Oder forEach hat einen zweiten Parameter, mit dem Sie einen Wert für this angeben können.

logHiToFriends: function () {
    'use strict';
    this.friends.forEach(function (friend) {
        console.log(this.name+' says hi to '+friend);
    }, this);
}

Funktionsausdrücke werden häufig als Argumente in Funktionsaufrufen in JavaScript verwendet. Seien Sie immer vorsichtig, wenn Sie von einem dieser Funktionsausdrücke auf this verweisen.

Bis jetzt denken Sie vielleicht, dass JavaScript-Objekte nur Abbildungen von Zeichenketten zu Werten sind, eine Vorstellung, die durch die Objekt-Literale von JavaScript nahegelegt wird, die wie die Map/Dictionary-Literale anderer Sprachen aussehen. JavaScript-Objekte unterstützen jedoch auch ein Merkmal, das wirklich objektorientiert ist: Vererbung. Dieser Abschnitt erklärt nicht vollständig, wie die Vererbung in JavaScript funktioniert, aber er zeigt ein einfaches Muster, um Ihnen den Einstieg zu erleichtern. Konsultieren SieKapitel 17, wenn Sie mehr erfahren möchten.

Neben der Tatsache, dass sie „echte“ Funktionen und Methoden sind, spielen Funktionen eine weitere Rolle in JavaScript: Sie werden zu Konstruktoren — Fabriken für Objekte —, wenn sie über den Operator new aufgerufen werden. Konstruktoren sind somit ein grobes Analogon zu Klassen in anderen Sprachen. Gemäß Konvention beginnen die Namen von Konstruktoren mit Großbuchstaben. Zum Beispiel:

// Set up instance data
function Point(x, y) {
    this.x = x;
    this.y = y;
}
// Methods
Point.prototype.dist = function () {
    return Math.sqrt(this.x*this.x + this.y*this.y);
};

Wir können sehen, dass ein Konstruktor zwei Teile hat. Erstens richtet die Funktion Point die Instanzdaten ein. Zweitens enthält die Eigenschaft Point.prototype ein Objekt mit den Methoden. Die erstgenannten Daten sind spezifisch für jede Instanz, während die letztgenannten Daten von allen Instanzen gemeinsam genutzt werden.

Um Point zu verwenden, rufen wir es über den Operator new auf:

> var p = new Point(3, 5);
> p.x
3
> p.dist()
5.830951894845301

p ist eine Instanz von Point.

> p instanceof Point
true

Array-Literale sind praktisch für das Erstellen von Arrays:

> var arr = [ 'a', 'b', 'c' ];

Das vorhergehende Array hat drei Elemente: die Zeichenketten 'a', 'b' und 'c'. Sie können über ganzzahlige Indizes darauf zugreifen.

> arr[0]
'a'
> arr[0] = 'x';
> arr
[ 'x', 'b', 'c' ]

Die Eigenschaft length gibt an, wie viele Elemente ein Array hat. Sie können sie zum Anhängen von Elementen und zum Entfernen von Elementen verwenden:

> var arr = ['a', 'b'];
> arr.length
2

> arr[arr.length] = 'c';
> arr
[ 'a', 'b', 'c' ]
> arr.length
3

> arr.length = 1;
> arr
[ 'a' ]

Der Operator in funktioniert auch für Arrays:

> var arr = [ 'a', 'b', 'c' ];
> 1 in arr // is there an element at index 1?
true
> 5 in arr // is there an element at index 5?
false

Beachten Sie, dass Arrays Objekte sind und somit Objekteigenschaften haben können:

> var arr = [];
> arr.foo = 123;
> arr.foo
123

Arrays haben viele Methoden (siehe Array-Prototypmethoden). Hier sind einige Beispiele.

> var arr = [ 'a', 'b', 'c' ];

> arr.slice(1, 2)  // copy elements
[ 'b' ]
> arr.slice(1)
[ 'b', 'c' ]

> arr.push('x')  // append an element
4
> arr
[ 'a', 'b', 'c', 'x' ]

> arr.pop()  // remove last element
'x'
> arr
[ 'a', 'b', 'c' ]

> arr.shift()  // remove first element
'a'
> arr
[ 'b', 'c' ]

> arr.unshift('x')  // prepend an element
3
> arr
[ 'x', 'b', 'c' ]

> arr.indexOf('b')  // find the index of an element
1
> arr.indexOf('y')
-1

> arr.join('-')  // all elements in a single string
'x-b-c'
> arr.join('')
'xbc'
> arr.join()
'x,b,c'

Es gibt mehrere Array-Methoden zum Iterieren über Elemente (siehe Array-Iteration). Die beiden wichtigsten sind forEach und map.

forEach iteriert über ein Array und übergibt das aktuelle Element und seinen Index an eine Funktion.

[ 'a', 'b', 'c' ].forEach(
    function (elem, index) {  // (1)
        console.log(index + '. ' + elem);
    });

Der vorhergehende Code erzeugt die folgende Ausgabe.

0. a
1. b
2. c

Beachten Sie, dass die Funktion in Zeile (1) Argumente frei ignorieren kann. Sie könnte zum Beispiel nur den Parameter elem haben.

map erstellt ein neues Array, indem es eine Funktion auf jedes Element eines vorhandenen Arrays anwendet:

> [1,2,3].map(function (x) { return x*x })
[ 1, 4, 9 ]

> /^a+b+$/.test('aaab')
true
> /^a+b+$/.test('aaa')
false

> /a(b+)a/.exec('_abbba_aba_')
[ 'abbba', 'bbb' ]

Das zurückgegebene Array enthält die vollständige Übereinstimmung an Index 0, die Erfassung der ersten Gruppe an Index 1 und so weiter. Es gibt eine Möglichkeit (diskutiert in RegExp.prototype.exec: Erfassungsgruppen), diese Methode wiederholt aufzurufen, um alle Übereinstimmungen zu erhalten.

> '<a> <bbb>'.replace(/<(.*?)>/g, '[$1]')
'[a] [bbb]'

Der erste Parameter von replace muss ein regulärer Ausdruck mit einem /g-Flag sein; andernfalls wird nur das erste Vorkommen ersetzt. Es gibt auch eine Möglichkeit (wie in String.prototype.replace: Suchen und Ersetzen) eine Funktion zu verwenden, um den Ersatz zu berechnen.