Object.prototype.toString()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Die toString()
-Methode von Object
-Instanzen gibt eine Zeichenkette zurück, die dieses Objekt repräsentiert. Diese Methode ist dazu gedacht, von abgeleiteten Objekten für benutzerdefinierte Typkonvertierungslogik überschrieben zu werden.
Probieren Sie es aus
function Dog(name) {
this.name = name;
}
const dog1 = new Dog("Gabby");
Dog.prototype.toString = function dogToString() {
return `${this.name}`;
};
console.log(dog1.toString());
// Expected output: "Gabby"
Syntax
toString()
Parameter
Standardmäßig nimmt toString()
keine Parameter entgegen. Allerdings können Objekte, die von Object
erben, sie mit eigenen Implementierungen überschreiben, die Parameter entgegennehmen. Zum Beispiel akzeptieren die Methoden Number.prototype.toString()
und BigInt.prototype.toString()
einen optionalen radix
-Parameter.
Rückgabewert
Eine Zeichenkette, die das Objekt repräsentiert.
Beschreibung
JavaScript ruft die Methode toString
auf, um ein Objekt in einen primitiven Wert zu konvertieren. Sie müssen die Methode toString
selten selbst aufrufen; JavaScript ruft sie automatisch auf, wenn ein Objekt in einem Kontext verwendet wird, in dem ein primitiver Wert erwartet wird.
Diese Methode wird bei der Zeichenkettenkonvertierung priorisiert aufgerufen, während numerische Konvertierung und primitive Konvertierung zuerst valueOf()
aufrufen. Da die Basis-Methode valueOf()
jedoch ein Objekt zurückgibt, wird meist die Methode toString()
aufgerufen, es sei denn, das Objekt überschreibt valueOf()
. Zum Beispiel gibt +[1]
den Wert 1
zurück, da die Methode toString()
"1"
zurückgibt, das dann in eine Zahl umgewandelt wird.
Alle Objekte, die von Object.prototype
erben (das heißt, alle außer null
-Prototyp-Objekten), erben die Methode toString()
. Wenn Sie ein benutzerdefiniertes Objekt erstellen, können Sie toString()
überschreiben, um eine benutzerdefinierte Methode aufzurufen, sodass Ihr benutzerdefiniertes Objekt in einen Zeichenkettenwert konvertiert werden kann. Alternativ können Sie eine Methode [Symbol.toPrimitive]()
hinzufügen, die noch mehr Kontrolle über den Konvertierungsprozess bietet und bei jeder Typkonvertierung gegenüber valueOf
oder toString
bevorzugt wird.
Um die Basis-Methode Object.prototype.toString()
mit einem Objekt zu verwenden, das sie überschrieben hat (oder um sie auf null
oder undefined
anzuwenden), müssen Sie Function.prototype.call()
oder Function.prototype.apply()
aufrufen und das zu untersuchende Objekt als ersten Parameter (genannt thisArg
) übergeben.
const arr = [1, 2, 3];
arr.toString(); // "1,2,3"
Object.prototype.toString.call(arr); // "[object Array]"
Object.prototype.toString()
gibt "[object Type]"
zurück, wobei Type
dem Objekttyp entspricht. Falls das Objekt eine Symbol.toStringTag
-Eigenschaft hat, deren Wert eine Zeichenkette ist, wird dieser Wert als Type
verwendet. Viele eingebaute Objekte, einschließlich Map
und Symbol
, verfügen über ein Symbol.toStringTag
. Einige Objekte, die vor ES6 definiert wurden, besitzen kein Symbol.toStringTag
, haben aber trotzdem einen speziellen Tag. Dazu gehören (der Tag ist derselbe wie der unten angegebene Typname):
Das arguments
-Objekt gibt "[object Arguments]"
zurück. Alles andere, einschließlich benutzerdefinierter Klassen, gibt "[object Object]"
zurück, es sei denn, es besitzt ein benutzerdefiniertes Symbol.toStringTag
.
Object.prototype.toString()
, angewendet auf null
und undefined
, gibt [object Null]
bzw. [object Undefined]
zurück.
Beispiele
Überschreiben von toString für benutzerdefinierte Objekte
Sie können eine Funktion erstellen, die anstelle der Standard-toString()
-Methode aufgerufen wird. Die von Ihnen erstellte toString()
-Funktion sollte eine Zeichenkette zurückgeben. Wenn sie ein Objekt zurückgibt und die Methode implizit während einer Typkonvertierung aufgerufen wird, wird das Ergebnis ignoriert, und der Wert einer verwandten Methode, valueOf()
, wird verwendet, oder ein TypeError
wird ausgelöst, wenn keine dieser Methoden einen primitiven Wert zurückgibt.
Der folgende Code definiert eine Dog
-Klasse.
class Dog {
constructor(name, breed, color, sex) {
this.name = name;
this.breed = breed;
this.color = color;
this.sex = sex;
}
}
Ruft man die toString()
-Methode auf einer Instanz von Dog
auf, entweder explizit oder implizit, gibt sie den Standardwert zurück, der von Object
geerbt wurde:
const theDog = new Dog("Gabby", "Lab", "chocolate", "female");
theDog.toString(); // "[object Object]"
`${theDog}`; // "[object Object]"
Der folgende Code überschreibt die Standard-toString()
-Methode. Diese Methode generiert eine Zeichenkette, die den name
, breed
, color
und sex
des Objekts enthält.
class Dog {
constructor(name, breed, color, sex) {
this.name = name;
this.breed = breed;
this.color = color;
this.sex = sex;
}
toString() {
return `Dog ${this.name} is a ${this.sex} ${this.color} ${this.breed}`;
}
}
Mit dem oben genannten Code ruft JavaScript jedes Mal, wenn eine Dog
-Instanz in einem Zeichenketten-Kontext verwendet wird, automatisch die toString()
-Methode auf.
const theDog = new Dog("Gabby", "Lab", "chocolate", "female");
`${theDog}`; // "Dog Gabby is a female chocolate Lab"
Verwendung von toString() zur Erkennung der Objektklasse
toString()
kann mit jedem Objekt verwendet werden und erlaubt es standardmäßig, dessen Klasse zu bestimmen.
const toString = Object.prototype.toString;
toString.call(new Date()); // [object Date]
toString.call(new String()); // [object String]
// Math has its Symbol.toStringTag
toString.call(Math); // [object Math]
toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]
Die Verwendung von toString()
auf diese Weise ist unzuverlässig; Objekte können das Verhalten von Object.prototype.toString()
durch die Definition einer Symbol.toStringTag
-Eigenschaft ändern, was zu unerwarteten Ergebnissen führen kann. Zum Beispiel:
const myDate = new Date();
Object.prototype.toString.call(myDate); // [object Date]
myDate[Symbol.toStringTag] = "myDate";
Object.prototype.toString.call(myDate); // [object myDate]
Date.prototype[Symbol.toStringTag] = "prototype polluted";
Object.prototype.toString.call(new Date()); // [object prototype polluted]
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-object.prototype.tostring |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
toString() |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support