Skip to main content

How to Remove the First and Last Characters from a String in JavaScript

A common string manipulation task is to remove the first and last characters, for example, to strip surrounding quotes or brackets from a string like "[data]" to get data. The most direct, modern, and readable way to do this is with the String.prototype.slice() method, which allows for negative indices.

This guide will teach you how to use slice() to perform this task, explain how its negative index feature makes it perfect for the job, and show you how to create a robust function that handles edge cases like short strings.

The slice() method extracts a section of a string and returns it as a new string without modifying the original. By providing a start index of 1 and a negative end index of -1, you can perfectly extract the "middle" of the string.

Problem: you have a string and want to remove the first and last characters.

// Problem: How to get "data" from the string "[data]"?
let originalString = '[data]';

Solution:

let originalString = '[data]';

// slice(1, -1) starts after the first character and ends before the last character.
let newString = originalString.slice(1, -1);

console.log(newString);      // Output: 'data'
console.log(originalString); // Output: '[data]' (The original is unchanged)

Output:

data
[data]
note

This is the most concise and idiomatic way to solve this problem in JavaScript.

How slice() Works with a Negative Index​

The slice(startIndex, endIndex) method takes two arguments:

  • startIndex: The index where the new string begins. 1 means we start extracting from the second character (at index 1).
  • endIndex: The index before which to end the extraction. A negative index counts from the end of the string. So, -1 refers to the last character, and slice() will stop just before it.

Combining 1 and -1 gives you the exact slice you need, without ever needing to know the string's length. This is why slice() is superior to other methods for this task.

Handling Edge Cases (Strings Shorter Than 2 Characters)​

A critical part of writing robust code is handling edge cases. What happens if the string is too short to have a "middle"?

  • An empty string (''): ('').slice(1, -1) returns ''.
  • A single-character string ('a'): ('a').slice(1, -1) returns ''.
  • A two-character string ('ab'): ('ab').slice(1, -1) returns ''.

The default behavior of slice() is safe and predictable, as it never throws an error. However, if you need specific logic, it's best to wrap this in a reusable function.

Solution: this function includes a guard clause to handle short strings explicitly.

/**
 * Removes the first and last characters from a string.
 * @param {string} str - The original string.
 * @returns {string} The sliced string, or an empty string if the original is too short.
 */
function trimFirstAndLast(str) {
  // If the string is 2 characters or less, there's nothing to return.
  if (str.length <= 2) {
    return '';
  }
  
  return str.slice(1, -1);
}

// Example Usage:
console.log(trimFirstAndLast('[data]')); // Output: 'data'
console.log(trimFirstAndLast('ab'));     // Output: ''
console.log(trimFirstAndLast(''));       // Output: ''

Output:

data


What About substring()?​

The String.prototype.substring() method can also achieve this, but it is more verbose and less intuitive because it does not accept negative indices.

Problem: to use substring(), you must manually calculate the end position based on the string's length.

Solution (Less Ideal):

let originalString = '[data]';

let newString = originalString.substring(1, originalString.length - 1);

console.log(newString); // Output: 'data'

Output:

data
note

This works, but it's more code and less readable than slice(1, -1). Because slice() so elegantly handles the "end of the string" logic with its negative index feature, it is the clear winner for this specific task.

Conclusion​

Removing the first and last characters of a string is a simple task with a clear, modern solution in JavaScript.

  • The recommended best practice is to use string.slice(1, -1). It is concise, highly readable, and perfectly suited for this operation.
  • For production code, wrap this logic in a reusable function that includes a check for the string's length to gracefully handle edge cases.
  • Avoid using substring() for this task, as it is more verbose and less intuitive than slice().

Table of Contents