How to Check Whether a String Starts With Another String in JavaScript

By the end of this page, you will understand how to test whether a string begins with another string in JavaScript. You will learn the modern startsWith() method, older fallback techniques such as indexOf() and slice(), when to use each approach, and the common mistakes beginners make when comparing string prefixes.

In JavaScript, checking whether a string starts with another string means testing whether the beginning of one string matches a smaller string exactly.

For example, does 'hello world' begin with 'he'? Yes.

This is a very common string operation. It is used in many kinds of programs:

• validating user input
• checking URL paths
• filtering filenames
• detecting command prefixes
• parsing text-based data

Modern JavaScript provides a built-in method for this:

'hello world'.startsWith('he'); // true

Before this method became widely available, developers often used alternatives such as:

• indexOf(...) === 0
• slice(...) === ...
• regular expressions

Why this matters:

• It makes your code easier to read.
• It avoids manual character-by-character checks.
• It helps express intent clearly: you want a prefix match, not a general substring search.

A prefix check is stricter than asking whether a string merely contains another string somewhere in the middle. For example:

'hello world'.includes();   
.(); 

Think of a string like a line of text on a label.

If you want to know whether the label starts with a word, you only look at the first few characters, not the whole label.

• haystack = the full label
• needle = the prefix you want to check

Example:

• Full label: hello world
• Prefix to test: he

You compare the first 2 characters of the label with he.

If they match exactly, the answer is true.

So startsWith() is like asking:

“Does this text begin with these exact characters?”

Not:

“Does this text contain these characters anywhere?”

The modern syntax is:

string.startsWith(searchString)

You can also provide a starting position:

string.startsWith(searchString, position)

Basic example

const haystack = 'hello world';
const needle = 'he';

console.log(haystack.startsWith(needle)); // true

This checks whether haystack begins with needle.

Example with a different result

console.log('hello world'.startsWith('lo')); // false

'lo' exists in the string, but not at the beginning.

Using a starting position

 text = ;

.(text.(, )); 

Consider this example:

const haystack = 'hello world';
const needle = 'he';

const result = haystack.startsWith(needle);
console.log(result);

Here is what happens step by step:

1. haystack is assigned the value 'hello world'.
2. needle is assigned the value 'he'.
3. haystack.startsWith(needle) checks whether 'hello world' begins with 'he'.
4. JavaScript compares the first 2 characters of 'hello world' with 'he'.
5. The first 2 characters are 'he'.
6. They match exactly, so the expression returns true.
7. result stores true.
8. console.log(result) prints .

Checking string prefixes appears in many practical situations.

URL routing

if (path.startsWith('/api/')) {
  // handle API route
}

This helps separate API requests from normal page requests.

File type checks

if (fileName.startsWith('draft_')) {
  console.log('This is a draft file');
}

Useful for naming conventions in scripts or build tools.

Command parsing

if (message.startsWith('/help')) {
  showHelp();
}

Chat apps and bots often use prefixes to detect commands.

Input validation

if (!email.startsWith('admin@')) {
  console.log('Not an admin email');
}

This can support simple checks before deeper validation.

In real projects, developers often use prefix checks in combination with broader patterns.

Guard clauses

A guard clause exits early when the input does not match an expected prefix.

function handleRoute(path) {
  if (!path.startsWith('/admin')) {
    return 'Not an admin route';
  }

  return 'Admin route';
}

This keeps code flatter and easier to read.

Validation

function isInternalId(id) {
  return id.startsWith('INT-');
}

Prefix checks are often a first validation step.

Configuration-driven logic

const privatePrefix = 'private_';

function isPrivateKey(key) {
  return key.startsWith(privatePrefix);
}

Instead of hardcoding values in many places, developers often store the prefix in configuration.

Fallback support for older environments

Here are common beginner mistakes when checking string prefixes.

Mistake 1: Using indexOf() without checking for 0

Broken code:

if ('hello world'.indexOf('he')) {
  console.log('Starts with he');
}

Why this is wrong:

• indexOf('he') returns 0
• 0 is falsy in JavaScript
• so the if block does not run

Correct version:

if ('hello world'.indexOf('he') === 0) {
  console.log('Starts with he');
}

Mistake 2: Confusing includes() with startsWith()

Broken logic:

Here is how common prefix-checking approaches compare:

Quick reference

Modern method

str.startsWith(prefix)
str.startsWith(prefix, position)

Fallbacks

str.indexOf(prefix) === 0
str.slice(0, prefix.length) === prefix

Examples

'hello world'.startsWith('he'); // true
'hello world'.startsWith('lo'); // false
'JavaScript'.startsWith('Script', 4); // true

Case-sensitive

'Hello'.startsWith('he'); // false

Case-insensitive check

'Hello'.().(); 

How do I check if a string starts with another string in JavaScript?

Use startsWith():

'hello world'.startsWith('he'); // true

What can I use instead of startsWith() in older JavaScript?

Use either:

str.indexOf(prefix) === 0

or:

str.slice(0, prefix.length) === prefix

Is startsWith() case-sensitive in JavaScript?

Yes. 'Hello'.startsWith('he') is false because uppercase and lowercase letters are different.

What is the difference between includes() and startsWith()?

• includes() checks whether a string appears anywhere.
• checks only the beginning.

String.includes()

Related because it checks whether text exists anywhere in a string, not just at the beginning.

String.endsWith()

Related because it checks whether a string finishes with a given suffix.

String.indexOf()

Related because it is a common older alternative for prefix checking.

String.slice()

Related because it can be used to extract the beginning of a string for manual comparison.

Regular expressions

Related because they can match prefixes using the ^ start anchor.

Case sensitivity

Related because string prefix checks depend on exact character matching unless you normalize case.

Type conversion

Related because values must be strings before using string methods like startsWith().