Skip to main content

How to Remove the First N Characters from a String in JavaScript

Removing a specific number of characters from the beginning of a string is a common and straightforward text manipulation task. You might need to strip a prefix, remove a country code, or simply truncate a string for display. The standard, most idiomatic, and readable way to achieve this is with the String.prototype.slice() method.

This guide will teach you how to use slice() to remove the first N characters from any string, explain why it's the best tool for the job compared to substring(), and show you a conditional approach using replace() for when you only want to remove a specific prefix.

The slice() method extracts a section of a string and returns it as a new string, leaving the original unchanged. When you provide only a single argument, it is treated as the startIndex, and the slice continues to the end of the string.

Problem: you have a string and want to remove a specific number of characters from the beginning.

// Problem: How to remove the first 4 characters from this string?
let idString = 'user-12345';

Solution: call slice() with the number of characters you want to remove.

let idString = 'user-12345';

// To remove the first 5 characters ('user-'), start the slice at index 5.
let newString = idString.slice(5);

console.log(newString);   // Output: '12345'
console.log(idString);    // Output: 'user-12345' (The original is unchanged)

Output:

12345
user-12345
note

This is the most concise and modern way to solve this problem.

How slice() Works​

slice(startIndex, endIndex) is zero-based. slice(5) means "start extracting at index 5 and continue to the end." The characters at indices 0, 1, 2, 3, and 4 are skipped, which effectively removes the first 5 characters.

How to Handle Edge Cases​

The slice() method is very safe and predictable:

  • If you provide an index greater than the string's length, it returns an empty string ('').
  • If you provide 0 or a negative number (when only one argument is given), it returns the whole string.
let str = 'abc';
console.log(str.slice(100)); // Output: ''
console.log(str.slice(0));   // Output: 'abc'

Output:


abc

What About substring()?​

The String.prototype.substring() method can also be used (str.substring(5)), and for this specific task, it behaves identically to slice(). However, slice() is generally preferred in modern JavaScript because it is more powerful and predictable in other scenarios (e.g., its ability to use negative indices), making it a more consistent tool to use.

Conditional Removal with replace() and a Regular Expression​

Sometimes, you only want to remove the first N characters if they match a specific prefix. The replace() method with a regular expression is the perfect tool for this.

Problem: you want to remove https:// from a URL, but only if it's at the very beginning. You don't want to remove it if it appears elsewhere in the string.

Solution: use a regular expression with a caret (^) anchor, which means "match only at the beginning of the string."

function removeHttpPrefix(url) {
  // The regex /^https?:\/\// matches 'http://' or 'https://' at the start.
  return url.replace(/^https?:\/\//, '');
}

// Example Usage:
let url1 = 'https://example.com';
console.log(removeHttpPrefix(url1)); // Output: 'example.com'

let url2 = 'Some text about https://example.com';
// The prefix doesn't match at the start, so the string is returned unchanged.
console.log(removeHttpPrefix(url2)); // Output: 'Some text about https://example.com'

Output:

example.com
Some text about https://example.com

Conclusion​

Removing the first N characters from a string is a simple task with a clear, modern solution.

  • To unconditionally remove the first N characters, the recommended best practice is string.slice(N). It is concise, readable, and safe.
  • To conditionally remove the first N characters only if they match a specific prefix, the best tool is string.replace(/^prefix/, '') using a regular expression anchored to the start of the string.

Table of Contents