Skip to main content

How to Get the Nth Character of a String in JavaScript

Accessing a single character at a specific position (or index) within a string is a fundamental operation in JavaScript. This is essential for iterating through a string, checking a specific character, or performing other text manipulations. Modern JavaScript offers several simple and effective ways to accomplish this.

This guide will teach you the three primary methods for getting the Nth character of a string: the modern at() method, the classic bracket notation, and the older charAt() method, explaining the key differences between them so you can choose the best one for your needs.

The Core Concept: Zero-Based Indexing​

It is essential to remember that strings in JavaScript are zero-indexed. This means the first character is at index 0, the second is at index 1, and the last character is at index string.length - 1.

The String.prototype.at() method is the newest and most flexible way to get a character at a specific index. Its key feature is that it accepts negative integers, which count back from the end of the string.

For example, you want to get the character at a specific index, including counting from the end.

// Problem: How to get the 2nd character ('e') and the last character ('o')?
const myString = 'Hello';

Solution:

const myString = 'Hello';

// Get the first character (index 0)
console.log(myString.at(0));    // Output: "H"

// Get the second character (index 1)
console.log(myString.at(1));    // Output: "e"

// Get the LAST character using negative indexing
console.log(myString.at(-1));   // Output: "o"

// Get the second-to-last character
console.log(myString.at(-2));   // Output: "l"
note

This is the recommended best practice for its power and readability, especially when accessing elements from the end of the string.

The Classic Method: Bracket Notation []​

This is the most common and widely-used method for accessing a character by its index. It is simple and works in all modern JavaScript environments.

Solution:

const myString = 'Hello';

// Get the first character
console.log(myString[0]);                   // Output: "H"

// Get the second character
console.log(myString[1]);                   // Output: "e"

// To get the last character, you must calculate the index
console.log(myString[myString.length - 1]); // Output: "o"
note

While perfectly functional, bracket notation is less convenient than at() for accessing characters from the end of the string, as it does not support negative indexes.

The Older Method: string.charAt()​

The String.prototype.charAt() method is the original way to get a character at a specific index. It is functionally very similar to bracket notation.

Solution:

const myString = 'Hello';

console.log(myString.charAt(0)); // Output: "H"
console.log(myString.charAt(1)); // Output: "e"
note

The main difference between charAt() and the other methods lies in how they handle out-of-bounds indexes.

Comparison of the Three Methods​

The key difference is their behavior when you provide an index that doesn't exist.

MethodmyString[10]myString.at(10)myString.charAt(10)
Return Value (Out of Bounds)undefinedundefined'' (empty string)

Which Should You Choose?

  • at(): Use this whenever you can. Its support for negative indexing makes it the most powerful and readable option, especially for getting the last or second-to-last character.
  • Bracket Notation []: This is the most common and universally understood method for positive indexes. It is a perfectly good choice.
  • charAt(): Use this only if you have a specific reason to prefer an empty string ('') over undefined for out-of-bounds access. In most cases, undefined is a more idiomatic and expected result for a missing value.

Conclusion​

For getting the Nth character of a string, modern JavaScript provides several excellent options.

  • The string.at(index) method is the recommended best practice due to its flexibility and support for negative indexing, which simplifies accessing characters from the end of the string.
  • Bracket notation (string[index]) is the most common and a perfectly acceptable alternative for accessing characters from the beginning of the string.
  • The older string.charAt(index) method is less common in modern code but is available if you specifically need an empty string for out-of-bounds access.

Table of Contents