Javascript typeof

Wenn sich der Datentyp ändern kann: typeof

In Javascript wird der Typ einer Variablen nicht ausdrücklich vereinbart, sondern der Datentyp wird dynamisch im Laufe des Programms zugewiesen. typeof stellt fest, ob ein Operator vom Typ number oder string, object oder boolean ist.

let x = 5; let num = "4.5";
if (typeof x === "number") {
	console.log ("number");
}
console.log (typeof num);

typeof ist keine Methode, sondern ein Operator (wie z.B. ein "+"). Das Ergebnis von typeof ist ein String.

C und Java: Streng typisiert

Programmiersprachen, die bei der Definition einer Variablen den Datentyp erzwingen, gelten als streng typisiert. In Programmiersprachen wie C und Java muss der Typ der Variablen genannt werden. Um eine Variable zum Speichern ganzzahliger Werte oder von Fließkommazahlen zu vereinbaren, muss der Typ ausdrücklich angegeben werden:

int num = 5;  oder   float fnum = 44.5;

Javascript ist eine dynamische oder locker typisierte Sprache:

let x = 5;   oder    let y = "44.5"; 
    ^                          ^
    |                          |
    +-- number                 +-- string

Javascript: Locker typisiert

Javascript verlangt keine Typangabe, sondern findet selber heraus, welcher Datentyp in x und y gespeichert wird. Wir dürfen einer Variablen zunächst einen String zuweisen und später einen numerischen Wert. Bei der Ausführung des Programms wird der Javascript-Interpreter die Daten in den korrekten Typ konvertieren. In jeder der folgenden Anweisungen wird Javascript den Typ der Variablen konvertieren:

Für die Operationen auf Variablen muss das Programm etwas über den Typ der Variablen wissen, sonst könnte das Programm diese Anweisung nicht auflösen:

let x = 100 + "Apple";

Was dabei herauskommt? Javascript würde »100Apple« mit type of als Typ string interpretieren:

let x = "100" + "px";

Das ist zunächst einmal schön bequem. Aber was passiert hier:

let x = 100 + 50 + "px";

Javascript liest die Anweisung von links nach rechts. Das Ergebnis ist der String "150px".

let x = "height:" + 100 + 50 + "px";

Das liefert "height:10050px". Wenn der Datentyp bei einer Operation nicht bekannt ist, hilft typeof.

Number.isInteger, Number.isNaN

ES6 hat die Abfrage, ob eine Variable einen Integer enthält, mitgebracht. Dem Himmel sei Dank!

const zweiundvierzig = 42;
const einhalb = 0.5;
console.log(Number.isInteger(zweiundvierzig)); // true
console.log(Number.isInteger(einhalb));        // false
console.log(Number.isInteger([17,42,49]));     // false

Number.isNaN() ist eine weitere Erleichterung im Kampf der Typabfragen.

console.log (Number.isNaN(17.5));       // false
console.log (Number.isNaN(0/0));        // true
console.log (Number.isNaN(undefined));  // false

Die immergrünen Browser (Chrome, EDGE, Safari, Firefox) unterstützen Number.isInteger und Number.isNaN, nicht aber IE22.

Der typeof-Operator

typeof gibt einen String zurück, der den Typ des Operanden identifiziert. Der (nicht entwickelte) Operand kann ein String, eine Variable, ein Schlüsselwort oder ein Objekt sein. type of kann z.B. prüfen, ob eine Variable definiert wurde: Wenn kein Wert mit einer Variablen verbunden werden kann, liefert der typeof-Operator immer undefined.

typeof kann auf zweierlei Weise aufgerufen werden:

1. typeof operand
2. typeof (operand)

Die Klammern sind optional.

let fn    = new Function("…")
let height  = 100 + 50; 
let size  = height + "px";
let today = new Date();

Der typeof-Operator gibt bei diesen Beispielen die folgenden Ergebnisse zurück:

typeof fn            function
typeof height        number
typeof size          string
typeof today         object
typeof foo           undefined

Ein Blick in die Browserconsole:

[Log] typeof 123                   = number
[Log] typeof 'abs'                 = string
[Log] typeof document.lastModified = string
[Log] typeof true                  = boolean
[Log] typeof {a:1}                 = object
[Log] typeof (function foo() {})   = function
[Log] typeof Date                  = function
[Log] typeof Math                  = function
[Log] typeof undefined             = undefined
[Log] typeof (Symbol('foo'))       = symbol
[Log] typeof null                  = object
[Log] typeof [1,2,3]               = object
[Log] typeof NaN                   = number

Das Fiasko beginnt, wenn der typeof-Operand null ist: typeof(null) antwortet mit object. Das ist einfach falsch, oder? Nun, ECMAScript definiert null als primitiven Wert, der die absichtliche Abwesenheit des Werts eines Objekts wiederspiegelt (ECMA-262, 4.3.12 The typeof Operator null value ). Muss man einfach schlucken.

Ein lichter Moment von type of: Wird eine nicht definierte Variable mit typeof abgefragt, liefert typeof "undefined".

Um Arrays besser von Objekten zu unterscheiden, gibt es heute Array.isArray([1,2,3]).

Wo typeof nichts Brauchbares liefert

Glücklich werden wir mit typeof nicht immer. Fragen wir nach einem Array mit typeof [a,b,c], kommt object zurück und fragen wir nach einem Objekt typeof (myobj), ist die Antwort ebenfalls object. Arrays sind nicht anderes als Objekte mit besonderer Ausstattung, aber kein Datentyp. Da kann typeof nicht weiterhelfen.

Um herauszufinden, ob ein Objekt ein Array ist, hat EcmaScript 5 eine Sonderlösung ausgeworfen: Array.isArray(obj). isArray ist eine sogen. statische Array-Methode und gibt true zurück, wenn das Objekt ein Array ist und ansonsten false.

let month = ["Januar", "Februar", "März", "April"];
console.log ("*** ein Array? " + Array.isArray(month));

Typecheck mit toString

toString wandelt Javascript-Objekte in Strings [object Object] um und kann als Erweiterung von typeof für eingebaute Objekte wie Array, Date, RegExp, Error … und als Alternative zu instanceof eingesetzt werden.

let today = new Date();
console.log ("today " + today);
console.log ("today.toString() " + today.toString());

let objToString = Object.prototype.toString;
let arr = ["Elefant", "Hase", "Igel"];
console.log (objToString.call(arr));
console.log (objToString.call(today));

typeof oder instanceof

typeof ist die Abfrage für primitive Datentypen, instanceof checkt, ob ein Objekt zu einem bestimmten Objekt oder einer Klasse gehört oder von einem übergeordneten Objekt / Klasse geerbt hat.

var today = new Date(); 

if (today instanceof Date) {
	console.log ("Der Typ von today ist Date");
}