JavaScript String at() Method

What You’ll Learn

String.prototype.at() reads one UTF-16 code unit at a given index (same API as MDN String.prototype.at()). Positive indexes count from the start; negative indexes count from the end — so str.at(-1) is the last character. This tutorial covers comparisons with charAt, out-of-range undefined, five examples, and try-it labs.

Introduction

For years, beginners wrote str.charAt(str.length - 1) or str.slice(-1) to grab the last character. at() makes that obvious: str.at(-1).

Indexes are zero-based from the left. A negative index means “count back from the end,” where -1 is the last character, -2 the second-to-last, and so on.

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

Understanding the at() Method

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

• Positive index — count from the start (0 is first).
• Negative index — count from the end (-1 is last).
• Missing position — returns undefined.
• Same idea as Array.prototype.at() for arrays.

📝 Syntax

General form of String.prototype.at:

str.at(index)

Parameters

• index — integer position of the character. Negative values count from the end of the string.

Return value

A string with the single UTF-16 code unit at that position, or undefined if the index is out of range.

Common patterns

"Hello".at(0);     // "H"
"Hello".at(-1);    // "o"
"Hello".at(10);    // undefined

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

Examples Gallery

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

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

`An index of ${index} returns the character ${sentence.at(index)}`;
// "An index of 5 returns the character u"

An index of 5 returns the character u

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

`An index of ${index} returns the character ${sentence.at(index)}`;
// "An index of -4 returns the character d"

An index of -4 returns the character d

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

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

1
2

const myString = "Every green bus drives fast.";

myString.charAt(myString.length - 2);  // "t"
myString.slice(-2, -1);                // "t"
myString.at(-2);                       // "t"

t
t
t

"abc".at(10);       // undefined
"abc".charAt(10);   // ""

"abc".at(-1);       // "c"
"abc".charAt(-1);   // ""

undefined
""
c
""

🚀 Common Use Cases

• Last character checks — file extensions, invoice suffixes, trailing punctuation.
• Readable relative indexing — at(-2) instead of length - 2.
• Validation — detect missing positions with === undefined.
• Teaching indexes — pair with length for beginners.
• Array twin — same mental model as array.at(-1).
• Not for full emoji — use code points / segmenters when graphemes matter.

📝 Notes

• at() returns one UTF-16 code unit, not always one visible emoji.
• Out-of-range indexes return undefined, not "".
• charAt(-1) is not the last character — use at(-1).
• Fractional indexes are truncated toward zero (like other string index methods).
• Empty string: "".at(0) and "".at(-1) are both undefined.
• Prefer at for new code when you need relative indexing.

💡 Best Practices