JavaScript String Constructor

What You’ll Learn

The global String function creates text in JavaScript—either as lightweight primitives or as wrapper objects (same API as MDN String() constructor). Call it as a function for conversion; avoid new String() in everyday code. This tutorial covers coercion rules, Symbol stringifying, equality traps, five examples, and try-it labs.

Introduction

Almost every string you write in JavaScript is a primitive typeof "string" value — for example "Hello", `Hi ${name}`, or String(99).

Calling new String(value) instead wraps that text in a String object. Objects are heavier, fail some === checks against primitives, and are almost never what you want. MDN’s guidance is clear: you should rarely use String as a constructor.

Continue with length, toString(), and the String methods hub after you understand conversion.

Understanding the String Constructor

When String runs as a function, it applies ToString-style coercion: numbers and booleans become text, null becomes "null", undefined becomes "undefined", and objects use toString(). Symbols convert to "Symbol(description)" instead of throwing — that special case is unique to String().

• String(value) → string primitive.
• new String(value) → String object (avoid).
• No argument: String() returns "".
• Symbols: only String(sym) stringifies safely without throwing.

📝 Syntax

Two forms of the global String function (from MDN):

String(thing)        // returns a string primitive
new String(thing)    // returns a String object

Parameters

• thing (optional) — anything to convert or wrap. If omitted, the function returns ""; with new you get a String object wrapping "".

Return value

• String(thing) — thing coerced to a string primitive. Symbols become "Symbol(description)" instead of throwing. Missing argument → "".
• new String(thing) — a String object wrapping that coerced text (not a primitive).

Common patterns

String(123);            // "123"
String(true);           // "true"
String(null);           // "null"
String(undefined);      // "undefined"
String();               // ""
String(Symbol("x"));    // "Symbol(x)"  — safe path

const a = new String("Hello world");
const b = String("Hello world");
a === "Hello world";    // false
b === "Hello world";    // true
typeof a;               // "object"
typeof b;               // "string"

Examples Gallery

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

const a = new String("Hello world"); // a === "Hello world" is false
const b = String("Hello world");     // b === "Hello world" is true

a instanceof String;  // true
b instanceof String;  // false
typeof a;             // "object"
typeof b;             // "string"

false
true
true
false
object
string

String();           // ""
String(123);        // "123"
String(true);       // "true"
String(null);       // "null"
String(undefined);  // "undefined"
String({});         // "[object Object]"

""
"123"
"true"
"null"
"undefined"
"[object Object]"

const sym = Symbol("example");

String(sym);  // "Symbol(example)"

Symbol(example)

const sym = Symbol("example");

String(sym);       // "Symbol(example)"

// "" + sym;       // TypeError
// `${sym}`;       // TypeError
// "".concat(sym); // TypeError

Symbol(example)
TypeError
TypeError

const wrapped = new String("hi");
const primitive = String("hi");

wrapped === "hi";                 // false
primitive === "hi";               // true
wrapped.valueOf() === "hi";       // true
String(wrapped) === "hi";         // true

false
true
true
true

🚀 Common Use Cases

• Normalize mixed types — turn numbers, booleans, or nullish values into text for display or logging.
• Form / API output — String(id) before concatenating into URLs or messages.
• Safe Symbol labels — String(sym) when debugging keys that must become text.
• Default empty text — String() when missing input should mean "".
• Teaching types — show why new String breaks ===.
• Not a substitute for formatting — prefer template literals for readable multi-part strings.

📝 Notes

• Prefer literals and String(value) — not new String().
• String(null) is "null"; empty string only comes from String() or String("").
• Template literals and + throw on Symbols — String() does not.
• String objects still work with methods via auto-unboxing, but stay with primitives.
• Related: length, toString(), valueOf().
• Instance methods live under the String methods hub.

💡 Best Practices