JavaScript String charAt() Method

What You’ll Learn

String.prototype.charAt() returns one UTF-16 code unit at a zero-based index (same API as MDN String.prototype.charAt()). It is a classic, legacy-friendly way to read a character. This tutorial covers out-of-range "", why negatives do not work, comparisons with at() and brackets, five examples, and try-it labs.

Introduction

charAt() is one of the oldest ways to read a character from a string. You pass a zero-based index and get back a one-character string — or "" when that index does not exist.

It is still widely used in tutorials and older code. For new apps that need “last character” access, prefer at(-1). Keep charAt() when you want a predictable empty string for bad indexes, or when matching legacy examples.

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

Understanding the charAt() Method

charAt(index) returns a new string with a single UTF-16 code unit from the chosen position. It does not change the original string.

• Indexes are zero-based — 0 is the first character.
• The last character is at str.length - 1.
• Missing position — returns "".
• Negative indexes are not supported — use at(-1) instead.

📝 Syntax

General form of String.prototype.charAt:

str.charAt(index)

Parameters

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

Return value

A string with the single UTF-16 code unit at that position, or an empty string "" if the index is outside 0 … str.length - 1.

Common patterns

"Hello".charAt(0);              // "H"
"Hello".charAt(4);              // "o"
"Hello".charAt(10);             // ""
"Hello".charAt("Hello".length - 1); // "o"

// Prefer at(-1) for last-character access in new code:
"Hello".at(-1);                 // "o"

Examples Gallery

Examples follow MDN String.charAt() 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;

`The character at index ${index} is ${sentence.charAt(index)}`;
// "The character at index 4 is q"

The character at index 4 is q

const anyString = "Brave new world";

anyString.charAt();     // "B"  (no index → 0)
anyString.charAt(0);    // "B"
anyString.charAt(1);    // "r"
anyString.charAt(2);    // "a"
anyString.charAt(3);    // "v"
anyString.charAt(4);    // "e"
anyString.charAt(999);  // ""

B
B
r
a
v
e

function returnLast(str) {
  return str.charAt(str.length - 1);
}

returnLast("my-invoice01");  // "1"
returnLast("my-invoice02");  // "2"
returnLast("");              // ""

1
2

const s = "abc";

s.charAt(1);   // "b"
s.at(1);       // "b"
s[1];          // "b"

s.charAt(10);  // ""
s.at(10);      // undefined
s[10];         // undefined

s.charAt(-1);  // ""
s.at(-1);      // "c"
s[-1];         // undefined

b
b
b
""
undefined
undefined
""
c
undefined

const str = "𠮷𠮾";

str.charAt(0);  // "\ud842"  (lone surrogate — not a full character)
str.charAt(1);  // "\udfb7"

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

\ud842
\udfb7
𠮷
𠮷

🚀 Common Use Cases

• Reading a known index — first letter, digit at position n.
• Legacy last character — charAt(str.length - 1) in older samples.
• Empty-string misses — when you prefer "" over undefined.
• Teaching indexes — pair with length for beginners.
• Migrating to at() — replace end-access patterns with at(-1).
• Not for full emoji — use code points / segmenters when graphemes matter.

📝 Notes

• charAt() returns one UTF-16 code unit, not always one visible emoji.
• Out-of-range indexes return "", not undefined.
• charAt(-1) is not the last character — use at(-1) or charAt(length - 1).
• Calling charAt() with no argument is the same as charAt(0).
• Fractional indexes are truncated toward zero (like other string index methods).
• Prefer at() for new code when you need relative indexing from the end.

💡 Best Practices