JavaScript String substring() Method

What You’ll Learn

String.prototype.substring() extracts characters from a start index up to (but not including) an end index (same API as MDN String.prototype.substring()). Learn argument swapping, how negatives become 0, how it compares to slice() and substr(), five examples, and try-it labs.

Introduction

Need characters between two indexes? substring(start, end) copies that window into a new string. The end index is exclusive — just like slice().

Two quirks to remember: if start is greater than end, the arguments are swapped; and negative numbers are treated as 0 (they do not count from the end). For end-relative indexes, prefer slice().

This page is part of JavaScript String Methods. Related topics include slice() and substr().

Understanding the substring() Method

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

• Creates a new string; the original is unchanged.
• indexEnd is optional — omit it to extract to the end.
• If start > end, the two arguments are swapped.
• Values below 0 or NaN are treated as 0.

📝 Syntax

General form of String.prototype.substring:

str.substring(indexStart)
str.substring(indexStart, indexEnd)

Parameters

• indexStart — index of the first character to include. Values < 0 or NaN become 0. Values > str.length become str.length.
• indexEnd (optional) — index of the first character to exclude. Same clamping rules. Omit to go to the end.

Return value

A string with the extracted section:

Common patterns

"Mozilla".substring(1, 3);  // "oz"
"Mozilla".substring(2);     // "zilla"
"Mozilla".substring(5, 2);  // "zil" (swapped)
"Mozilla".substring(-5, 2); // "Mo"  (negatives → 0)

Examples Gallery

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

const str = "Mozilla";

str.substring(1, 3);
// "oz"

str.substring(2);
// "zilla"

oz
zilla

const anyString = "Mozilla";

anyString.substring(0, 1);  // "M"
anyString.substring(1, 0);  // "M"  (swapped)
anyString.substring(4, 7);  // "lla"
anyString.substring(7, 4);  // "lla" (swapped)
anyString.substring(0, 10); // "Mozilla"

M
M
lla
lla
Mozilla

const text = "Mozilla";

text.substring(text.length - 4); // "illa"
text.substring(text.length - 5); // "zilla"

// Cleaner with slice:
text.slice(-4); // "illa"
text.slice(-5); // "zilla"

illa
zilla
illa
zilla

const text = "Mozilla";

text.substring(5, 2); // "zil"
text.slice(5, 2);     // ""

text.substring(-5, 2); // "Mo"
text.substring(-5, -2); // ""

text.slice(-5, -2); // "zil"

zil
""
Mo
""
zil

function replaceString(oldS, newS, fullS) {
  return fullS.split(oldS).join(newS);
}

replaceString("World", "Web", "Brave New World");
// "Brave New Web"

"Mozilla".substring(0, 3);
// "Moz"

Brave New Web
Moz

🚀 Common Use Cases

• Take a prefix / mid-section — substring(0, n) or substring(a, b).
• Drop a known prefix length — substring(prefix.length).
• Last n chars without negatives — substring(str.length - n).
• Order-independent windows — when you want swap behavior if start > end.
• Prefer slice for suffixes — slice(-n) is clearer than length math.
• Not for delimiter cuts — use split() for CSV / words.

📝 Notes

• The end index is exclusive.
• If start > end, the arguments are swapped (unlike slice).
• Negative values and NaN are treated as 0.
• Do not confuse with deprecated substr() (length-based).
• Prefer slice(-n) for suffixes instead of length - n math.
• Always capture the return value — the original string is unchanged.

💡 Best Practices