JavaScript String fromCharCode() Method

What You’ll Learn

String.fromCharCode() is a static helper (same API as MDN String.fromCharCode()). It builds a string from UTF-16 code unit numbers — the reverse of charCodeAt(). Learn multi-argument calls, truncation, surrogate pairs, and when fromCodePoint() is easier — with five examples and try-it labs.

Introduction

Most String methods run on text you already have: "Hello".toUpperCase(). fromCharCode() is different — it lives on the String constructor and creates text from numbers.

Those numbers are UTF-16 code units (0–65535), the same values charCodeAt() returns. For characters above U+FFFF (many emoji), you either pass a surrogate pair or use String.fromCodePoint() with the full Unicode value.

This page is part of JavaScript String Methods under Static Methods. Related topics include charCodeAt() and codePointAt().

Understanding the fromCharCode() Method

Each argument becomes one UTF-16 code unit in the result string. Pass several numbers to build longer text in one call.

• Valid units are integers from 0 to 65535 (0xFFFF).
• Larger numbers are truncated to the lowest 16 bits (no error is thrown).
• No validity checks — invalid combinations can still produce a string.
• Supplementary characters need two units (a surrogate pair) or fromCodePoint().

📝 Syntax

General form of the static String.fromCharCode method:

String.fromCharCode()
String.fromCharCode(num1)
String.fromCharCode(num1, num2)
String.fromCharCode(num1, num2, /* …, */ numN)

Parameters

• num1, …, numN — numbers between 0 and 65535 representing UTF-16 code units. Values above 0xFFFF are truncated to 16 bits.

Return value

A string whose length equals the number of arguments (0 arguments → "").

Common patterns

String.fromCharCode(65, 66, 67);   // "ABC"
String.fromCharCode(0x2014);       // "—"
String.fromCharCode(8212);         // "—"  (decimal for 0x2014)
String.fromCharCode(0x12014);      // "—"  (truncated to 0x2014)

// Round-trip with charCodeAt:
String.fromCharCode("A".charCodeAt(0)); // "A"

// Emoji needs a surrogate pair (or use fromCodePoint):
String.fromCharCode(0xd83c, 0xdf03); // "🌃"
String.fromCodePoint(0x1f303);       // "🌃"  (easier)

Examples Gallery

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

String.fromCharCode(189, 43, 190, 61);
// "½+¾="

½+¾=

String.fromCharCode(65, 66, 67);  // "ABC"
String.fromCharCode(0x2014);      // "—"
String.fromCharCode(8212);        // "—"  (decimal form of 0x2014)

ABC
—
—

// Code point U+1F303 "Night with Stars"
String.fromCharCode(0xd83c, 0xdf03);  // "🌃"
String.fromCharCode(55356, 57091);    // "🌃"  (decimal pair)

// Easier with the full code point:
String.fromCodePoint(0x1f303);        // "🌃"

🌃
🌃
🌃

"A".charCodeAt(0);                         // 65
String.fromCharCode("A".charCodeAt(0));    // "A"

const codes = [..."Hi"].map((c) => c.charCodeAt(0));
String.fromCharCode(...codes);             // "Hi"

65
A
Hi

String.fromCharCode();                 // ""
String.fromCharCode(0x12014);          // "—"  (same as 0x2014)
String.fromCharCode(65 + 65536);       // "A"  (65 after truncate)
String.fromCharCode(65) === String.fromCharCode(65 + 65536); // true

""
—
A
true

🚀 Common Use Cases

• ASCII / letter math — build alphabets with loops over 65–90.
• Round-trip encoding — store code units, rebuild with fromCharCode.
• Legacy protocols — APIs that still speak in 16-bit character codes.
• Teaching UTF-16 — show how emoji need two units.
• Prefer fromCodePoint for emoji — pass 0x1f303 instead of looking up surrogates.
• Not for HTML escaping — use proper encode/escape helpers for markup safety.

📝 Notes

• Always call String.fromCharCode(...) — it is static.
• Pair with charCodeAt() for BMP round-trips.
• For full Unicode values, prefer String.fromCodePoint().
• Oversized numbers truncate silently — they do not throw.
• Surrogate pairs are valid input; lone surrogates produce unpaired units.
• Related: codePointAt(), String constructor.

💡 Best Practices