JavaScript hat nur sechs Typen, gemäß Kapitel 8 der ECMAScript-Sprachspezifikation

Daher führen Konstruktoren technisch keine neuen Typen ein, obwohl gesagt wird, dass sie Instanzen haben.

Im Kontext von Sprachsemantik und Typsystemen bedeutet statisch normalerweise „zur Kompilierzeit“ oder „ohne Ausführung eines Programms“, während dynamisch „zur Laufzeit“ bedeutet.

In einer statisch typisierten Sprache haben Variablen, Parameter und Objekteigenschaften (JavaScript nennt sie Eigenschaften) Typen, die dem Compiler zur Kompilierzeit bekannt sind. Der Compiler kann diese Informationen verwenden, um Typüberprüfungen durchzuführen und den kompilierten Code zu optimieren.

Auch in statisch typisierten Sprachen hat eine Variable auch einen dynamischen Typ, den Typ des Wertes der Variablen zu einem bestimmten Zeitpunkt zur Laufzeit. Der dynamische Typ kann vom statischen Typ abweichen. Zum Beispiel (Java)

Object foo = "abc";

Der statische Typ von foo ist Object; sein dynamischer Typ ist String.

JavaScript ist dynamisch typisiert; Typen von Variablen sind zur Kompilierzeit im Allgemeinen nicht bekannt.

Wenn Sie Typinformationen haben, können Sie prüfen, ob ein Wert, der in einer Operation verwendet wird (Aufruf einer Funktion, Anwendung eines Operators usw.), den richtigen Typ hat. Statisch typprüfte Sprachen führen diese Art von Prüfung zur Kompilierzeit durch, während dynamisch typprüfte Sprachen dies zur Laufzeit tun. Eine Sprache kann sowohl statisch als auch dynamisch typprüft sein. Wenn eine Prüfung fehlschlägt, erhalten Sie normalerweise eine Art von Fehler oder Ausnahme.

JavaScript führt eine sehr begrenzte Art der dynamischen Typprüfung durch

> var foo = null;
> foo.prop
TypeError: Cannot read property 'prop' of null

Meistens schlagen die Dinge jedoch stillschweigend fehl oder funktionieren. Wenn Sie zum Beispiel auf eine nicht vorhandene Eigenschaft zugreifen, erhalten Sie den Wert undefined

> var bar = {};
> bar.prop
undefined

In JavaScript ist der hauptsächliche Weg, mit einem Wert umzugehen, dessen Typ nicht passt, ihn in den richtigen Typ zu coercen. Coercion bedeutet implizite Typkonvertierung. Die meisten Operanden werden coercet:

> '3' * '4'
12

Die integrierten Konvertierungsmechanismen von JavaScript unterstützen nur die Typen Boolean, Number, String und Object. Es gibt keine standardmäßige Möglichkeit, eine Instanz eines Konstruktors in eine Instanz eines anderen Konstruktors zu konvertieren.

Hier überprüfen wir die verschiedenen Szenarien, in denen undefined und null vorkommen.

> var foo;
> foo
undefined

> function f(x) { return x }
> f()
undefined

> var obj = {}; // empty object
> obj.foo
undefined

> function f() {}
> f()
undefined

> function g() { return; }
> g()
undefined

In den folgenden Abschnitten überprüfen wir, wie man individuell auf undefined und null prüft oder ob eines von beiden existiert.

if (x === null) ...

if (x === undefined) ...

// Does x have a value?
if (x !== undefined && x !== null) {
    ...
}
// Is x a non-value?
if (x === undefined || x === null) {
    ...
}

// Does x have a value (is it truthy)?
if (x) {
    ...
}
// Is x falsy?
if (!x) {
    ...
}

Ein einziger Nichtwert könnte die Rollen von sowohl undefined als auch null spielen. Warum hat JavaScript zwei solche Werte? Der Grund ist historisch bedingt.

JavaScript übernahm den Ansatz von Java, Werte in Primitives und Objekte zu unterteilen. Es verwendete auch den Wert von Java für „kein Objekt“, null. Nach dem Vorbild von C (aber nicht Java) wird null zu 0, wenn es zu einer Zahl coercet wird:

> Number(null)
0
> 5 + null
5

Denken Sie daran, dass die erste Version von JavaScript keine Ausnahmebehandlung hatte. Daher mussten Ausnahmefälle wie uninitialisierte Variablen und fehlende Eigenschaften über einen Wert angezeigt werden. null wäre eine gute Wahl gewesen, aber Brendan Eich wollte zu dieser Zeit zwei Dinge vermeiden

Infolgedessen fügte Eich undefined als zusätzlichen Nichtwert zur Sprache hinzu. Es coercet zu NaN

> Number(undefined)
NaN
> 5 + undefined
NaN

undefined ist eine Eigenschaft des globalen Objekts (und somit eine globale Variable; siehe The Global Object). Unter ECMAScript 3 mussten Sie Vorkehrungen beim Lesen von undefined treffen, da es leicht war, seinen Wert versehentlich zu ändern. Unter ECMAScript 5 ist das nicht notwendig, da undefined schreibgeschützt ist.

Um gegen ein geändertes undefined zu schützen, waren zwei Techniken beliebt (sie sind für ältere JavaScript-Engines immer noch relevant)

Primitive Werte wie 'abc' unterscheiden sich grundlegend von Wrapper-Instanzen wie new String('abc'):

> typeof 'abc'  // a primitive value
'string'
> typeof new String('abc')  // an object
'object'
> 'abc' instanceof String  // never true for primitives
false
> 'abc' === new String('abc')
false

Wrapper-Instanzen sind Objekte, und es gibt keine Möglichkeit, Objekte in JavaScript zu vergleichen, nicht einmal über den nachgiebigen Gleichheitsoperator == (siehe Equality Operators: === Versus ==)

> var a = new String('abc');
> var b = new String('abc');
> a == b
false

Es gibt einen Anwendungsfall für Wrapper-Objekte: Sie möchten einer primitiven Wert Eigenschaft hinzufügen. Dann wrappen Sie das Primitive und fügen dem Wrapper-Objekt Eigenschaften hinzu. Sie müssen den Wert unwrappen, bevor Sie damit arbeiten können.

Wrappen Sie ein Primitive, indem Sie einen Wrapper-Konstruktor aufrufen

new Boolean(true)
new Number(123)
new String('abc')

Entpacken Sie ein Primitive durch Aufrufen der Methode valueOf(). Alle Objekte haben diese Methode (wie in Conversion to Primitive) besprochen

> new Boolean(true).valueOf()
true
> new Number(123).valueOf()
123
> new String('abc').valueOf()
'abc'

Das richtige Konvertieren von Wrapper-Objekten in Primitives extrahiert Zahlen und Zeichenketten, aber keine Booleans:

> Boolean(new Boolean(false))  // does not unwrap
true
> Number(new Number(123))  // unwraps
123
> String(new String('abc'))  // unwraps
'abc'

Der Grund dafür wird in Converting to Boolean erklärt.

Primitives haben keine eigenen Methoden und leihen sie sich von Wrappern

> 'abc'.charAt === String.prototype.charAt
true

Sloppy Mode und Strict Mode behandeln dieses Ausleihen unterschiedlich. Im Sloppy Mode werden Primitives on the fly in Wrapper konvertiert

String.prototype.sloppyMethod = function () {
    console.log(typeof this); // object
    console.log(this instanceof String); // true
};
''.sloppyMethod(); // call the above method

Im Strict Mode werden Methoden vom Wrapper-Prototyp transparent verwendet

String.prototype.strictMethod = function () {
    'use strict';
    console.log(typeof this); // string
    console.log(this instanceof String); // false
};
''.strictMethod(); // call the above method

Daher beschwert sich JavaScript selten über einen falschen Typ eines Wertes. Programme erhalten zum Beispiel normalerweise Benutzereingaben (von Online-Formularen oder GUI-Widgets) als Zeichenketten, auch wenn der Benutzer eine Zahl eingegeben hat. Wenn Sie eine Zahl-als-Zeichenkette wie eine Zahl behandeln, erhalten Sie keine Warnung, nur unerwartete Ergebnisse. Zum Beispiel

var formData = { width: '100' };

// You think formData.width is a number
// and get unexpected results
var w = formData.width;
var outer = w + 20;

// You expect outer to be 120, but it’s not
console.log(outer === 120);  // false
console.log(outer === '10020');  // true

In Fällen wie dem vorherigen sollten Sie frühzeitig in den entsprechenden Typ konvertieren

var w = Number(formData.width);

Die folgenden Funktionen sind die bevorzugte Methode, umeinen Wert in einen Boolean, eine Zahl, eine Zeichenkette oder ein Objekt zu konvertieren:

Beachten Sie, dass Boolean(), Number(), String() und Object() als Funktionen aufgerufen werden. Sie verwenden sie normalerweise nicht als Konstruktoren. Dann erstellen sie Instanzen von sich selbst (siehe Wrapper Objects for Primitives).

Um einen Wert in eine Zahl oder eine Zeichenkette zu konvertieren, wird er zuerst in einen beliebigen primitiven Wert konvertiert, der dann in den endgültigen Typ konvertiert wird (wie in Functions for Converting to Boolean, Number, String, and Object) besprochen).

Die ECMAScript-Spezifikation hat eine interne Funktion, ToPrimitive() (die von JavaScript aus nicht zugänglich ist), die diese Konvertierung durchführt. Das Verständnis von ToPrimitive() ermöglicht es Ihnen zu konfigurieren, wie Objekte in Zahlen und Zeichenketten konvertiert werden. Sie hat die folgende Signatur

ToPrimitive(input, PreferredType?)

Der optionale Parameter PreferredType gibt den endgültigen Typ der Konvertierung an: er ist entweder Number oder String, je nachdem, ob das Ergebnis von ToPrimitive() in eine Zahl oder eine Zeichenkette konvertiert wird.

Wenn PreferredType Number ist, führen Sie die folgenden Schritte aus

Wenn PreferredType String ist, werden Schritt 2 und 3 vertauscht. PreferredType kann auch weggelassen werden; es wird dann für Daten als String und für alle anderen Werte als Number betrachtet. Dies ist, wie die Operatoren + und == ToPrimitive() aufrufen.

> var empty = {};
> empty.valueOf() === empty
true
> empty.toString()
'[object Object]'

> Number({})
NaN

> var n = { valueOf: function () { return 123 } };
> Number(n)
123
> String(n)
'[object Object]'

> var s = { toString: function () { return '7'; } };
> String(s)
'7'
> Number(s)
7