Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

typeof

Baseline
Weitgehend verfügbar

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.

Der Operator typeof gibt einen String zurück, der den Typ des Werts des Operanden angibt.

Probieren Sie es aus

console.log(typeof 42);
// Expected output: "number"

console.log(typeof "blubber");
// Expected output: "string"

console.log(typeof true);
// Expected output: "boolean"

console.log(typeof undeclaredVariable);
// Expected output: "undefined"

Syntax

js
typeof operand

Parameter

operand

Ein Ausdruck, der das Objekt oder den primitiven Wert darstellt, dessen Typ zurückgegeben werden soll.

Beschreibung

Die folgende Tabelle fasst die möglichen Rückgabewerte von typeof zusammen. Weitere Informationen zu Typen und primitiven Werten finden Sie auf der Seite JavaScript-Datenstrukturen.

Typ Ergebnis
Undefined "undefined"
Null "object" (Grund)
Boolean "boolean"
Number "number"
BigInt "bigint"
String "string"
Symbol "symbol"
Function (implementiert [[Call]] gemäß ECMA-262; Klassen sind ebenfalls Funktionen) "function"
Jedes andere Objekt "object"

Diese Liste der Werte ist vollständig. Es sind keine spezifikationskonformen Engines bekannt, die andere als die aufgeführten Werte zurückgeben oder früher zurückgegeben haben.

Beispiele

Grundlegende Verwendung

js
// Numbers
typeof 37 === "number";
typeof 3.14 === "number";
typeof 42 === "number";
typeof Math.LN2 === "number";
typeof Infinity === "number";
typeof NaN === "number"; // Despite being "Not-A-Number"
typeof Number("1") === "number"; // Number tries to parse things into numbers
typeof Number("shoe") === "number"; // including values that cannot be type coerced to a number

typeof 42n === "bigint";

// Strings
typeof "" === "string";
typeof "bla" === "string";
typeof `template literal` === "string";
typeof "1" === "string"; // note that a number within a string is still typeof string
typeof typeof 1 === "string"; // typeof always returns a string
typeof String(1) === "string"; // String converts anything into a string, safer than toString

// Booleans
typeof true === "boolean";
typeof false === "boolean";
typeof Boolean(1) === "boolean"; // Boolean() will convert values based on if they're truthy or falsy
typeof !!1 === "boolean"; // two calls of the ! (logical NOT) operator are equivalent to Boolean()

// Symbols
typeof Symbol() === "symbol";
typeof Symbol("foo") === "symbol";
typeof Symbol.iterator === "symbol";

// Undefined
typeof undefined === "undefined";
typeof declaredButUndefinedVariable === "undefined";
typeof undeclaredVariable === "undefined";

// Objects
typeof { a: 1 } === "object";

// use Array.isArray or Object.prototype.toString.call
// to differentiate regular objects from arrays
typeof [1, 2, 4] === "object";

typeof new Date() === "object";
typeof /regex/ === "object";

// The following are confusing, dangerous, and wasteful. Avoid them.
typeof new Boolean(true) === "object";
typeof new Number(1) === "object";
typeof new String("abc") === "object";

// Functions
typeof function () {} === "function";
typeof class C {} === "function";
typeof Math.sin === "function";

typeof null

js
// This stands since the beginning of JavaScript
typeof null === "object";

In der ersten Implementierung von JavaScript wurden JavaScript-Werte durch ein Typkennzeichen und einen Wert dargestellt. Das Typkennzeichen für Objekte war 0. null wurde als NULL-Zeiger dargestellt (0x00 auf den meisten Plattformen). Daher hatte null das Typkennzeichen 0, weshalb typeof den Wert "object" zurückgibt. (Quelle)

Für ECMAScript wurde eine Korrektur vorgeschlagen, die ausdrücklich aktiviert werden müsste, aber abgelehnt wurde. Sie hätte dazu geführt, dass typeof null === "null" gilt.

Verwendung des Operators new

Alle Konstruktorfunktionen, die mit new aufgerufen werden, geben nicht-primitive Werte zurück ("object" oder "function"). Die meisten geben Objekte zurück. Eine bemerkenswerte Ausnahme ist Function, das eine Funktion zurückgibt.

js
const str = new String("String");
const num = new Number(100);

typeof str; // "object"
typeof num; // "object"

const func = new Function();

typeof func; // "function"

Erforderliche Klammern in Ausdrücken

Der Operator typeof hat eine höhere Priorität als binäre Operatoren wie die Addition (+). Daher sind Klammern erforderlich, um den Typ des Ergebnisses einer Addition zu ermitteln.

js
// Parentheses can be used for determining the data type of expressions.
const someData = 99;

typeof someData + " foo"; // "number foo"
typeof (someData + " foo"); // "string"

Verhalten bei nicht deklarierten und nicht initialisierten Variablen

typeof funktioniert mit nicht deklarierten Bezeichnern und gibt "undefined" zurück, statt einen Fehler auszulösen.

js
typeof undeclaredVariable; // "undefined"

Wird typeof jedoch auf lexikalische Deklarationen (let, const, using, await using und class) im selben Block vor ihrer Deklaration angewendet, wird ein ReferenceError ausgelöst. Variablen mit Block-Scope befinden sich vom Beginn des Blocks bis zum Abschluss ihrer Initialisierung in einer Temporal Dead Zone. Ein Zugriff auf sie während dieser Zeit löst einen Fehler aus.

js
typeof newLetVariable; // ReferenceError
typeof newConstVariable; // ReferenceError
typeof newClass; // ReferenceError

let newLetVariable;
const newConstVariable = "hello";
class newClass {}

Weitere Einzelheiten finden Sie unter Operator typeof und undefined.

Sonderverhalten von document.all

Alle aktuellen Browser stellen das nicht standardisierte Host-Objekt document.all bereit, dessen Typ undefined ist.

js
typeof document.all === "undefined";

Obwohl document.all außerdem falsy ist und bei einem losen Gleichheitsvergleich undefined entspricht, ist es nicht undefined. Dass document.all den Typ "undefined" hat, wird in den Webstandards als „willful violation“ des ursprünglichen ECMAScript-Standards zugunsten der Webkompatibilität eingestuft.

Benutzerdefinierte Methode zur genaueren Typbestimmung

typeof ist sehr nützlich, aber nicht so vielseitig, wie es manchmal erforderlich ist. Beispielsweise ergibt sowohl typeof [] als auch typeof new Date() und typeof /abc/ den Wert "object".

Für eine genauere Typprüfung wird hier eine benutzerdefinierte Funktion type(value) vorgestellt. Sie ahmt das Verhalten von typeof weitgehend nach, gibt für nicht-primitive Werte (also Objekte und Funktionen) jedoch nach Möglichkeit einen genaueren Typnamen zurück.

js
function type(value) {
  if (value === null) {
    return "null";
  }
  const baseType = typeof value;
  // Primitive types
  if (!["object", "function"].includes(baseType)) {
    return baseType;
  }

  // Symbol.toStringTag often specifies the "display name" of the
  // object's class. It's used in Object.prototype.toString().
  const tag = value[Symbol.toStringTag];
  if (typeof tag === "string") {
    return tag;
  }

  // If it's a function whose source code starts with the "class" keyword
  if (
    baseType === "function" &&
    Function.prototype.toString.call(value).startsWith("class")
  ) {
    return "class";
  }

  // The name of the constructor; for example `Array`, `GeneratorFunction`,
  // `Number`, `String`, `Boolean` or `MyCustomClass`
  const className = value.constructor?.name;
  if (typeof className === "string" && className !== "") {
    return className;
  }

  // At this point there's no robust way to get the type of value,
  // so we use the base implementation.
  return baseType;
}

Verwenden Sie zur Prüfung möglicherweise nicht existierender Variablen, die andernfalls einen ReferenceError auslösen würden, typeof nonExistentVar === "undefined", da sich dieses Verhalten nicht mit benutzerdefiniertem Code nachbilden lässt.

Spezifikationen

Spezifikation
ECMAScript® 2027 Language Specification
# sec-typeof-operator

Browser-Kompatibilität

Siehe auch