JavaScript String charCodeAt() Method

What You’ll Learn

String.prototype.charCodeAt() returns an integer between 0 and 65535 for the UTF-16 code unit at a zero-based index (same API as MDN String.prototype.charCodeAt()). Learn out-of-range NaN, how it differs from codePointAt(), the link to fromCharCode(), five examples, and try-it labs.

Introduction

charAt() gives you the character as text. charCodeAt() gives you the same position as a number — the UTF-16 code unit stored at that index.

For everyday ASCII letters this number is the familiar Unicode value ("A" → 65, "q" → 113. For many emoji and rare characters, JavaScript stores two code units (a surrogate pair), so charCodeAt() may return only half of the character. Prefer codePointAt() when you need the full Unicode value.

This page is part of JavaScript String Methods. Related topics include charAt() and at().

Understanding the charCodeAt() Method

charCodeAt(index) looks at the string as a sequence of UTF-16 code units and returns the integer value of the unit at that position.

• Indexes are zero-based — 0 is the first code unit.
• Valid results are integers from 0 to 65535 (0xFFFF).
• Missing position — returns NaN.
• May return a lone surrogate for characters above U+FFFF.

📝 Syntax

General form of String.prototype.charCodeAt:

str.charCodeAt(index)

Parameters

• index — zero-based position of the code unit. Converted to an integer (undefined becomes 0).

Return value

A number for the UTF-16 code unit at that index. Special cases:

Common patterns

"ABC".charCodeAt(0);              // 65
"Hello".charCodeAt(4);            // 111  ("o")
"Hello".charCodeAt(10);           // NaN

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

// Full Unicode for emoji / rare chars:
"𠮷".codePointAt(0);               // 134071

Examples Gallery

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

const sentence = "The quick brown fox jumps over the lazy dog.";
const index = 4;

`Character code ${sentence.charCodeAt(index)} is equal to ${sentence.charAt(index)}`;
// "Character code 113 is equal to q"

Character code 113 is equal to q

"ABC".charCodeAt(0);  // 65
"ABC".charCodeAt(1);  // 66
"ABC".charCodeAt(2);  // 67

"a".charCodeAt(0);    // 97
"0".charCodeAt(0);    // 48
" ".charCodeAt(0);    // 32

65
66
67
97
48
32

const s = "Hi";

s.charCodeAt();     // 72  (no index → 0 → "H")
s.charCodeAt(0);    // 72
s.charCodeAt(1);    // 105
s.charCodeAt(2);    // NaN
s.charCodeAt(-1);   // NaN
s.charCodeAt(999);  // NaN

Number.isNaN(s.charCodeAt(2));  // true

72
72
105
NaN
NaN
NaN
true

const code = "Z".charCodeAt(0);           // 90
String.fromCharCode(code);                // "Z"

String.fromCharCode(72, 105);             // "Hi"

// Caesar-style shift by 1 (ASCII letters only):
function nextLetter(ch) {
  return String.fromCharCode(ch.charCodeAt(0) + 1);
}
nextLetter("A");  // "B"
nextLetter("y");  // "z"

90
Z
Hi
B
z

const str = "𠮷𠮾";

str.charCodeAt(0);   // 55362  (0xD842 — high surrogate)
str.charCodeAt(1);   // 57271  (0xDFB7 — low surrogate)
str.length;          // 4      (two characters, four code units)

// Prefer code-point APIs for the full character:
str.codePointAt(0);  // 134071
String.fromCodePoint(str.codePointAt(0));  // "𠮷"

55362
57271
4
134071
𠮷

🚀 Common Use Cases

• Letter math — shift ASCII letters with fromCharCode(code ± n).
• Digit / case checks — compare numeric ranges (48–57 digits, 65–90 A–Z).
• Checksums & hashes — fold code units into a simple number.
• Debugging encodings — inspect exact UTF-16 units in a string.
• Pair with charAt — show both the glyph and its code in tutorials.
• Not for full emoji — use codePointAt() / fromCodePoint().

📝 Notes

• charCodeAt() always indexes UTF-16 code units, not grapheme clusters.
• Out-of-range indexes return NaN, not undefined or "".
• charCodeAt(-1) is not the last unit — use charCodeAt(length - 1).
• Calling charCodeAt() with no argument is the same as charCodeAt(0).
• Values are always < 65536; larger Unicode needs codePointAt().
• Do not re-implement codePointAt() by combining surrogate pairs yourself.

💡 Best Practices