JavaScript String toString() Method

What You’ll Learn

String.prototype.toString() returns this string’s primitive text (same API as MDN String.prototype.toString()). Learn how it unwraps new String(...) objects, how it matches valueOf(), why wrong this throws TypeError, five examples, and try-it labs.

Introduction

Almost every string you write is already a primitive ("like this". toString() still matters when you meet a String object from new String(...), or when you want an explicit “give me the text” call.

For String values, this method overrides Object.prototype.toString. It returns the string itself (primitive) or the text wrapped by the object — the same behavior as valueOf().

This page is part of JavaScript String Methods. Related topics include toLowerCase() and localeCompare(). For numbers with a base (binary/hex), see Number toString().

Understanding the toString() Method

str.toString() returns the underlying string text. It does not take a radix — that feature belongs to Number.prototype.toString.

• Returns a string primitive.
• Same implementation as String.prototype.valueOf().
• Requires this to be a string primitive or String object.
• Throws TypeError for other this values (no coercion).

📝 Syntax

General form of String.prototype.toString:

str.toString()

Parameters

None.

Return value

A string representing the specified string value (the primitive text).

Exceptions

TypeError if this is not a string primitive or a String object.

Common patterns

"hello".toString();                 // "hello"
new String("foo").toString();       // "foo"
new String("Hi").valueOf();         // "Hi" (same text)
typeof new String("x");             // "object"
typeof new String("x").toString();  // "string"

Examples Gallery

Examples follow MDN String.toString() patterns. Use View Output or Try It Yourself for each case.

const stringObj = new String("foo");

console.log(typeof stringObj);
// "object"

console.log(stringObj.toString());
// "foo"

object
foo

const x = new String("Hello world");

console.log(x.toString());
// "Hello world"

Hello world

const literal = "hello";
const wrapped = new String("hello");

console.log(typeof literal);                 // "string"
console.log(typeof literal.toString());      // "string"
console.log(typeof wrapped);                 // "object"
console.log(typeof wrapped.toString());      // "string"
console.log(literal.toString() === wrapped.toString()); // true

string
string
object
string
true

const s = new String("CodeToFun");

console.log(s.toString());
console.log(s.valueOf());
console.log(s.toString() === s.valueOf());
// true

CodeToFun
CodeToFun
true

try {
  String.prototype.toString.call(42);
} catch (err) {
  console.log(err.name);
  // TypeError
}

console.log(String(42));
// "42" — general conversion still works

TypeError
42

🎯 Common Use Cases

• Unwrap String objects — turn new String(...) into a primitive.
• Explicit APIs — document that you need a string primitive.
• Not for numbers — use Number.prototype.toString(radix) or String(n).
• Not for general coercion — prefer String(value).
• Rare for literals — "hi".toString() is valid but usually unnecessary.

📝 Notes

• Overrides Object.prototype.toString — you do not get "[object String]" from this method.
• Identical to valueOf() for String values.
• String objects used in template literals call toString(); string primitives are already strings, so they skip that path.
• Avoid new String() in modern code unless you have a special reason.
• Do not confuse with Number.toString(radix).

💡 Best Practices