JavaScript String slice() Method

What You’ll Learn

String.prototype.slice() extracts part of a string into a new string without changing the original (same API as MDN String.prototype.slice()). Learn start/end indexes, exclusive ends, negative indexes, how it compares to substring(), five examples, and try-it labs.

Introduction

Need the middle of a sentence, the last few characters, or everything after an index? slice() copies that section into a new string.

Pass a start index, and optionally an end index. The end is exclusive — characters from start up to (but not including) end are kept. Negative numbers count backward from the end of the string.

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

Understanding the slice() Method

str.slice(indexStart, indexEnd) returns the characters from indexStart until indexEnd (exclusive).

• Creates a new string; the original is unchanged.
• indexEnd is optional — omit it to slice to the end.
• Negative indexes count from the end of the string.
• If start is past end (after normalizing), the result is "".
• If start is beyond str.length, the result is "".

📝 Syntax

General forms of String.prototype.slice:

str.slice(indexStart)
str.slice(indexStart, indexEnd)

Parameters

• indexStart — index of the first character to include. Negatives count from the end. Omitted / invalid values are treated as 0.
• indexEnd (optional) — index of the first character to exclude. Omit to go to the end. Negatives count from the end.

Return value

A string with the extracted section:

Common patterns

"Mozilla".slice(1, 5);   // "ozil"
"Mozilla".slice(2);      // "zilla"
"Mozilla".slice(-3);     // "lla"
"Mozilla".slice(0, -1);  // "Mozill"
"Mozilla".slice(5, 1);   // ""

Examples Gallery

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

const str = "The quick brown fox jumps over the lazy dog.";

str.slice(31);
// "the lazy dog."

str.slice(4, 19);
// "quick brown fox"

str.slice(-4);
// "dog."

str.slice(-9, -5);
// "lazy"

the lazy dog.
quick brown fox
dog.
lazy

const str1 = "The morning is upon us."; // length 23

str1.slice(1, 8);   // "he morn"
str1.slice(4, -2);  // "morning is upon u"
str1.slice(12);     // "is upon us."
str1.slice(30);     // ""

he morn
morning is upon u
is upon us.
""

const str = "The morning is upon us.";

str.slice(-3);      // "us."
str.slice(-3, -1);  // "us"
str.slice(0, -1);   // "The morning is upon us"
str.slice(4, -1);   // "morning is upon us"
str.slice(-11, 16); // "is u"
str.slice(11, -7);  // " is u"

us.
us
The morning is upon us
morning is upon us
is u
 is u

"Mozilla".slice(5, 1);   // ""  (start after end)
"Mozilla".slice(10);     // ""  (start past length)
"Mozilla".slice();       // "Mozilla" (start treated as 0)
"Mozilla".slice(0, 100); // "Mozilla" (end clamped to length)

""
""
Mozilla
Mozilla

function firstN(str, n) {
  return str.slice(0, n);
}

function lastN(str, n) {
  return str.slice(-n);
}

function truncate(str, max) {
  if (str.length <= max) return str;
  return str.slice(0, max - 1) + "…";
}

firstN("CodeToFun", 4);           // "Code"
lastN("report.pdf", 3);           // "pdf"
truncate("Learn JavaScript slice", 12);
// "Learn Java…"

Code
pdf
Learn Java…

🚀 Common Use Cases

• Take a prefix / suffix — slice(0, n) or slice(-n).
• Drop edges — slice(1, -1) to remove first and last characters.
• Preview text — truncate long strings for UI cards.
• Parse fixed formats — pull year/month pieces from known layouts.
• Not for regex cuts — combine with search / indexOf when the start is dynamic.
• Not for splitting lists — use split() for delimiter-based pieces.

📝 Notes

• The end index is exclusive.
• Negative indexes count from the end of the string.
• If start ≥ end after normalizing, the result is "" (no swap).
• Prefer slice() over legacy substr().
• Indexes are UTF-16 code-unit positions (same as length / charAt).
• Always capture the return value — the original string is unchanged.

💡 Best Practices