Checking for a String in a TypeScript Array: Optimization and Speed

Online Python Trainer for Beginners

Learn Python easily without overwhelming theory. Solve practical tasks with automatic checking, get hints in Russian, and write code directly in your browser — no installation required.

Start Course

Introduction: "Is my string in there?" — The eternal developer question

You're writing code in TypeScript, and suddenly the question arises: "How do I check if a specific string exists in an array?" It seems like a small thing, but the functionality of filters, form validation, list searches, and hundreds of other scenarios depend on it. This question on Stack Overflow has thousands of views — meaning it plagues not only beginners but also experienced developers.

Today, we'll break down all the legitimate ways to check for a string in a TypeScript array. But we won't just list methods — we'll look under the hood at performance, find out which option is faster, and when to use advanced data structures. You'll learn how to write not just working code, but fast and elegant code.

Let's go! 🚀

The includes() Method: Simplicity and Readability

The most obvious and modern way is the includes() method. It was introduced in ES2016 and is natively supported by TypeScript. All you need to do is call it on the array and pass the string you're looking for.

const fruits: string[] = ['apple', 'banana', 'orange', 'kiwi'];const searchTerm: string = 'banana';

if (fruits.includes(searchTerm)) {  console.log('Fruit found! 🍌');} else {  console.log('No such fruit.');}

Pros:

Maximum code readability — it's immediately clear what you're doing.
Returns a boolean — ideal for conditions.
Supports strict TypeScript typing.

Cons:

Linear search O(n) — can be slow for huge arrays (tens of thousands of elements).
Doesn't work with NaN (but this is rare for strings).

For 90% of tasks, includes() is your choice. Simple, reliable, fast.

The indexOf() Method: Old but Proven

Before includes() existed, everyone used indexOf(). It also returns the index of the element, but if the element is not found, it returns -1. Checking for -1 has become a classic.

const languages: string[] = ['JavaScript', 'TypeScript', 'Python', 'Go'];const target: string = 'TypeScript';

if (languages.indexOf(target) !== -1) {  console.log('Language found!');} else {  console.log('Language not in the list.');}

Pros:

Works in all environments, even older browsers (if that matters).
You can get the position of the element for further actions.

Cons:

Less readable — you need to remember about -1.
Same O(n) complexity.
TypeScript may complain about implicit comparison; it's better to explicitly specify the type.

Tip: if you don't need the index, use includes(). But knowing indexOf() is useful — it appears in legacy code.

The find() Method: When You Need More Than Just true/false

The find() method returns the first element that satisfies the condition, or undefined if nothing is found. This is a powerful tool when you're searching not just for a string, but for an object with a specific field.

interface User {  id: number;  name: string;}

const users: User[] = [  { id: 1, name: 'Anna' },  { id: 2, name: 'Boris' },  { id: 3, name: 'Victor' }];

const foundUser = users.find(user => user.name === 'Boris');

if (foundUser) {  console.log(`User found: ${foundUser.name}`);}

For simple string arrays, find() is overkill, but if you need to get the element itself or check a complex condition, it's the best choice.

Performance: also O(n), but slightly slower than includes() due to the callback being called on each iteration.