By defaulttoString() takes no parameters. However, objects that inherit fromObject may override it with their own implementations that do take parameters. For example, theNumber.prototype.toString() andBigInt.prototype.toString() methods take an optionalradix parameter.

A string representing the object.

JavaScript calls thetoString method toconvert an object to a primitive value. You rarely need to invoke thetoString method yourself; JavaScript automatically invokes it when encountering an object where a primitive value is expected.

This method is called in priority bystring conversion, butnumeric conversion andprimitive conversion callvalueOf() in priority. However, because the basevalueOf() method returns an object, thetoString() method is usually called in the end, unless the object overridesvalueOf(). For example,+[1] returns1, because itstoString() method returns"1", which is then converted to a number.

All objects that inherit fromObject.prototype (that is, all exceptnull-prototype objects) inherit thetoString() method. When you create a custom object, you can overridetoString() to call a custom method, so that your custom object can be converted to a string value. Alternatively, you can add a[Symbol.toPrimitive]() method, which allows even more control over the conversion process, and will always be preferred overvalueOf ortoString for any type conversion.

To use the baseObject.prototype.toString() with an object that has it overridden (or to invoke it onnull orundefined), you need to callFunction.prototype.call() orFunction.prototype.apply() on it, passing the object you want to inspect as the first parameter (calledthisArg).

const arr = [1, 2, 3];arr.toString(); // "1,2,3"Object.prototype.toString.call(arr); // "[object Array]"

Object.prototype.toString() returns"[object Type]", whereType is the object type. If the object has aSymbol.toStringTag property whose value is a string, that value will be used as theType. Many built-in objects, includingMap andSymbol, have aSymbol.toStringTag. Some objects predating ES6 do not haveSymbol.toStringTag, but have a special tag nonetheless. They include (the tag is the same as the type name given below):

• Array
• Function (anything whosetypeof returns"function")
• Error
• Boolean
• Number
• String
• Date
• RegExp

Thearguments object returns"[object Arguments]". Everything else, including user-defined classes, unless with a customSymbol.toStringTag, will return"[object Object]".

Object.prototype.toString() invoked onnull andundefined returns[object Null] and[object Undefined], respectively.

You can create a function to be called in place of the defaulttoString() method. ThetoString() function you create should return a string value. If it returns an object and the method is called implicitly duringtype conversion, then its result is ignored and the value of a related method,valueOf(), is used instead, or aTypeError is thrown if none of these methods return a primitive.

The following code defines aDog class.

class Dog {  constructor(name, breed, color, sex) {    this.name = name;    this.breed = breed;    this.color = color;    this.sex = sex;  }}

If you call thetoString() method, either explicitly or implicitly, on an instance ofDog, it returns the default value inherited fromObject:

const theDog = new Dog("Gabby", "Lab", "chocolate", "female");theDog.toString(); // "[object Object]"`${theDog}`; // "[object Object]"

The following code overrides the defaulttoString() method. This method generates a string containing thename,breed,color, andsex of the object.

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}`;  }}

With the preceding code in place, any time an instance ofDog is used in a string context, JavaScript automatically calls thetoString() method.

const theDog = new Dog("Gabby", "Lab", "chocolate", "female");`${theDog}`; // "Dog Gabby is a female chocolate Lab"

toString() can be used with every object and (by default) allows you to get its class.

const toString = Object.prototype.toString;toString.call(new Date()); // [object Date]toString.call(new String()); // [object String]// Math has its Symbol.toStringTagtoString.call(Math); // [object Math]toString.call(undefined); // [object Undefined]toString.call(null); // [object Null]

UsingtoString() in this way is unreliable; objects can change the behavior ofObject.prototype.toString() by defining aSymbol.toStringTag property, leading to unexpected results. For example:

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]

• Polyfill ofObject.prototype.toString withSymbol.toStringTag support incore-js
• Object.prototype.valueOf()
• Number.prototype.toString()
• Symbol.toPrimitive
• Symbol.toStringTag