JavaScript String startsWith() Method

What You’ll Learn

String.prototype.startsWith() is a case-sensitive prefix check that returns true or false (same API as MDN String.prototype.startsWith()). Learn the optional position, empty-string behavior, why regex is not allowed, how it compares to endsWith() and includes(), five examples, and try-it labs.

Introduction

Need to know whether a string begins with a certain prefix — a protocol, a filename stem, or a command keyword? startsWith() answers with a clear boolean.

The check is always case-sensitive. An optional position lets you treat a later index as the new “start.” Regular expressions are not allowed — pass a string (or a value that coerces to a string).

This page is part of JavaScript String Methods. Related topics include includes() and indexOf().

Understanding the startsWith() Method

str.startsWith(searchString, position) checks whether searchString appears at the beginning of the string (or at position if you provide one).

• Returns a boolean — ideal for if checks.
• Case-sensitive; empty searchString always matches.
• Throws TypeError if searchString is a regex.
• Does not change the original string.

📝 Syntax

General form of String.prototype.startsWith:

str.startsWith(searchString)
str.startsWith(searchString, position)

Parameters

• searchString — the prefix to look for. Cannot be a regex. Other values are coerced to strings (omitting it searches for "undefined" — rarely useful).
• position (optional) — index where the prefix is expected to start. Defaults to 0.

Return value

true if the characters are found at the start (including when searchString is ""); otherwise false.

Exceptions

TypeError if searchString is a regular expression.

Common patterns

"Hello".startsWith("He");      // true
"Hello".startsWith("he");      // false (case-sensitive)
"Hello".startsWith("llo", 2);  // true
"Hello".startsWith("");        // true
"https://x.com".startsWith("https://"); // true

Examples Gallery

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

const str = "Saturday night plans";

str.startsWith("Sat");
// true

str.startsWith("Sat", 3);
// false

true
false

const str = "To be, or not to be, that is the question.";

str.startsWith("To be");      // true
str.startsWith("not to be");  // false
str.startsWith("not to be", 10); // true

true
false
true

"File.PDF".startsWith("file");  // false
"File.PDF".toLowerCase().startsWith("file"); // true

"Hello".startsWith("");  // true
"".startsWith("");       // true

false
true
true
true

try {
  "hello".startsWith(/he/);
} catch (err) {
  console.log(err.name); // TypeError
}

// Pattern check instead:
/^he/i.test("Hello"); // true

TypeError
true

function isSecureUrl(url) {
  return url.startsWith("https://");
}

function isJsFile(path) {
  const name = path.split("/").pop();
  return name.startsWith("index") || name.endsWith(".js");
}

isSecureUrl("https://codetofun.com"); // true
isSecureUrl("http://example.com");    // false
"npm run build".startsWith("npm ");   // true

true
false
true

🚀 Common Use Cases

• URL / protocol checks — startsWith("https://").
• Command routing — detect prefixes like "/help" or "npm ".
• Path filters — keep files under a folder prefix.
• Feature flags / tags — strings that begin with a known marker.
• Not for “contains” — use includes() when the text can appear anywhere.
• Not for regex prefixes — use /^pattern/ with test().

📝 Notes

• The search is case-sensitive.
• position sets where the prefix must start — it does not scan forward.
• Empty searchString always returns true.
• Passing a regex throws TypeError.
• Omitting searchString searches for the literal "undefined".
• Pair with endsWith() for suffix checks and includes() for “anywhere.”

💡 Best Practices