Como checar se string contém outra string em JavaScript

Neste artigo você vai aprender a como checar se string contém outra string, utilizando a linguagem JavaScript!

Em JavaScript, o jeito mais direto de checar se uma string contém outra é o método includes(), que devolve true ou false:

const frase = ‘Eu amo JavaScript’

frase.includes(‘JavaScript’) // true frase.includes(‘Python’) // false

1. a busca é sensível a maiúsculas e minúsculas, então ‘Blue Whale’.includes(‘blue’) retorna false
2. quando a substring buscada é uma string vazia, o retorno é true
3. ele aceita um segundo parâmetro opcional, a posição onde a busca começa, que por padrão é 0

Se em vez de sim ou não tu precisa da POSIÇÃO, usa o indexOf(), que devolve o índice da primeira ocorrência ou -1 quando não encontra

E se o que tu procura é um padrão e não um texto fixo, aí é caso de expressão regular com test() ou search()

O includes() faz parte da especificação ECMAScript 2015, está como Baseline Widely available na MDN e existe nos navegadores desde setembro de 2015, ou seja, pode usar sem medo

Fala programador(a), beleza? Bora aprender mais sobre strings em JavaScript!

Checar se uma string contém outra string é uma tarefa comum na programação JavaScript.

É útil quando precisamos verificar se uma determinada palavra ou frase existe em uma string maior, para validar dados de entrada de usuário ou para fazer pesquisas em bancos de dados.

Neste artigo, exploraremos várias maneiras de checar se uma string contém outra string em JavaScript e discutiremos as vantagens e desvantagens de cada uma.

Usando o método includes()

Uma maneira de checar se uma string contém outra string em JavaScript é usando o método includes().

O método includes() verifica se uma string contém outra string e retorna true ou false com base no resultado da verificação.

Aqui está um exemplo de como usar o método includes():

const minhaString = 'Eu amo JavaScript';
const minhaSubString = 'JavaScript';

if (minhaString.includes(minhaSubString)) {
  console.log('A string contém a substring.');
} else {
  console.log('A string não contém a substring.');
}

Neste exemplo, o método includes() é usado para verificar se a string “Eu amo JavaScript” contém a substring “JavaScript”.

Se a substring estiver presente na string, a mensagem “A string contém a substring” será exibida no console. Caso contrário, a mensagem “A string não contém a substring” será exibida.

Usando o método indexOf()

Outra maneira de checar se uma string contém outra string em JavaScript é usando o método indexOf().

O método indexOf() retorna o índice da primeira ocorrência de uma substring em uma string. Se a substring não for encontrada, o método retorna -1.

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 120 aulas
• 4 projetos
• 9h 45min

Conhecer formação

Aqui está um exemplo de como usar o método indexOf():

const minhaString = 'Eu amo JavaScript';
const minhaSubString = 'JavaScript';

if (minhaString.indexOf(minhaSubString) !== -1) {
  console.log('A string contém a substring.');
} else {
  console.log('A string não contém a substring.');
}

Neste exemplo, o método indexOf() é usado para verificar se a string “Eu amo JavaScript” contém a substring “JavaScript”.

Se a substring estiver presente na string, o método indexOf() retornará um valor diferente de -1, e a mensagem “A string contém a substring” será exibida no console.

Caso contrário, a mensagem “A string não contém a substring” será exibida.

Usando expressões regulares

Uma terceira maneira de checar se um texto contém outro texto em JavaScript é usando expressões regulares.

As expressões regulares são padrões de pesquisa que podem ser usados para encontrar e substituir padrões de texto em uma string.

Aqui está um exemplo de como usar expressões regulares para verificar se uma string contém outra string:

const minhaString = 'Eu amo JavaScript';
const minhaSubString = 'JavaScript';
const regex = new RegExp(minhaSubString);

if (regex.test(minhaString)) {
  console.log('A string contém a substring.');
} else {
  console.log('A string não contém a substring.');
}

Neste exemplo, uma expressão regular é criada com o valor da substring que estamos procurando. Em seguida, o método test() é usado para verificar se a string “Eu amo JavaScript” contém a substring “JavaScript”.

Se a substring estiver presente na string, o método test() retornará true, e a mensagem “A string contém a substring” será exibida no console.

Quer aprender mais sobre React? Confira o vídeo abaixo:

Conclusão

Checar se um texto contém outro texto é uma tarefa comum na programação JavaScript.

Neste artigo, exploramos três maneiras diferentes de checar se uma string contém outra string: usando o método includes(), o método indexOf() e expressões regulares.

O método includes() é uma maneira simples e direta de verificar se uma string contém outra string e retorna true ou false com base no resultado da verificação.

É uma opção fácil e rápida para verificar se uma string contém uma substring em um contexto simples.

O método indexOf() é outra opção simples e direta para checar se uma string contém outra string.

Ele retorna o índice da primeira ocorrência da substring em uma string e pode ser usado para validar dados de entrada de usuário ou fazer pesquisas em bancos de dados.

As expressões regulares são padrões de pesquisa que podem ser usados para encontrar e substituir padrões de texto em uma string.

Elas são uma opção poderosa e versátil para verificar se uma string contém outra string em JavaScript, mas exigem um pouco mais de conhecimento e prática do que as outras duas abordagens.

Independentemente da abordagem escolhida, checar se uma string contém outra string é uma tarefa importante para a validação de dados de formulários, a manipulação de texto e a pesquisa de dados em bancos de dados.

Com a prática, você pode desenvolver seu próprio estilo e preferência na escolha da melhor abordagem para cada situação.

Está buscando a sua primeira vaga como Programador? Confira o nosso treinamento completo clicando aqui.

Nosso principal objetivo é tornar você um dev no menor tempo possível, através de uma metodologia planejada nos mínimos detalhes, após formar muitos outros desenvolvedores.

Uma plataforma de cursos com projetos completos, comunidade de alunos e muito mais!

includes() diferencia maiúscula de minúscula:

Essa é a pegadinha que mais derruba gente que está começando

A busca do includes() é sensível a maiúsculas e minúsculas, ele compara do jeitinho que tu escreveu

const frase = ‘Blue Whale’

frase.includes(‘blue’) // false frase.includes(‘Blue’) // true

Sacou? pro JavaScript, ‘blue’ com b minúsculo simplesmente não existe dentro de ‘Blue Whale’ 🙂

A saída mais comum é deixar as duas strings no mesmo formato antes de comparar:

const frase = ‘Eu amo JavaScript’ const busca = ‘javascript’

frase.toLowerCase().includes(busca.toLowerCase()) // true

Beleza, mas e os acentos?

Aí o toLowerCase() não te salva, porque ‘e’ e ‘é’ continuam sendo caracteres diferentes

Pra saber se dois textos são equivalentes ignorando acento e caixa, o caminho é o localeCompare() com a opção sensitivity no valor ‘base’:

‘réservé’.localeCompare(‘RESERVE’, ‘fr’, { sensitivity: ‘base’ }) // 0

O zero aqui significa "essas duas são equivalentes"

O mesmo nível de sensitivity existe no Intl.Collator, onde ‘Congrès’ e ‘congres’ são tratadas como iguais

Tome cuidado com um detalhe: isso depende do idioma que tu passa. Em alemão o ‘ä’ e o ‘a’ são equivalentes nesse nível, já em sueco são letras base diferentes

E repara numa coisa: o localeCompare compara as strings INTEIRAS, ele não faz busca de trecho como o includes()

Buscando a partir de uma posição: includes(texto, posicao)

O includes() aceita um segundo parâmetro opcional, a posição onde a busca começa

Se tu não passa nada, ele assume 0, ou seja, do começo da string

const frase = ‘Eu amo JavaScript’

frase.includes(‘Eu’) // true frase.includes(‘Eu’, 3) // false

Útil quando tu já tratou o começo do texto e quer olhar só o resto dele

Cuidado com a string vazia:

Quando a substring buscada é uma string vazia, o includes() retorna true

const frase = ‘Eu amo JavaScript’

frase.includes(”) // true

Por isso eu checo se o termo está vazio antes de sair chamando o includes()

Como checar se a string COMEÇA ou TERMINA com um texto:

Às vezes tu não quer saber se contém em qualquer lugar, tu quer saber se contém no começo ou no fim

Pra isso existem o startsWith() e o endsWith():

const frase = ‘Eu amo JavaScript’

frase.startsWith(‘Eu’) // true frase.endsWith(‘JavaScript’) // true

Os dois entraram na especificação ECMAScript 2015 junto com o includes(), estão como Baseline Widely available na MDN e existem nos navegadores desde setembro de 2015, então pode usar tranquilo

E se liga nisso: assim como o includes(), eles checam se o primeiro argumento é uma expressão regular e lançam TypeError se for

TypeError: First argument to String.prototype.includes must not be a regular expression

Ou seja, regex ali dentro não rola, tem que ser texto

Tome cuidado ao montar a regex com texto do usuário:

No exemplo acima a gente jogou a substring direto dentro do new RegExp()

Funciona enquanto o texto é simples

Caracteres como + . * ( ) e [ têm significado especial dentro de uma expressão regular, então a tua busca deixa de procurar o texto literal e passa a procurar outra coisa

Pra resolver isso existe o RegExp.escape(), um método estático que escapa os caracteres de sintaxe e devolve uma string segura pra usar como padrão literal no construtor:

const busca = RegExp.escape(textoDoUsuario) const regex = new RegExp(busca)

Sobre compatibilidade: a proposta de RegExp escaping chegou ao stage 4 em 18 de fevereiro de 2025 e faz parte do ECMAScript 2025

Na MDN ele aparece como Baseline 2025, disponível nos navegadores mais recentes desde maio de 2025, então em navegador ou dispositivo antigo ele pode simplesmente não existir

A pegadinha do lastIndex com a flag g:

Se a tua expressão regular tem a flag global (g) ou sticky (y), o objeto vira stateful

O test() avança a propriedade lastIndex e a chamada seguinte retoma a busca a partir dela, inclusive quando tu testa outra string

Quando o test() retorna false, o lastIndex volta pra 0

Na prática dá nisso aqui:

const regex = /JavaScript/g

regex.test(‘Eu amo JavaScript’) // true regex.test(‘Eu amo JavaScript’) // false

Mesma string, mesma regex, resultado diferente. Já me ferrei uma vez por causa disso 😛

Se tu só quer saber se contém, não bota a flag g aqui, ou volta pro includes() e vive feliz

E o método search(), serve pra quê?

O search() é tipo o indexOf das expressões regulares

Ele recebe uma expressão regular e devolve o índice da primeira correspondência, ou -1 quando não encontra nada

const frase = ‘Eu amo JavaScript’

frase.search(/Java/) // 7

E se tu passar pro search() algo que não é um objeto RegExp nem tem o método Symbol.search, o JavaScript converte implicitamente com new RegExp(regexp)

Quer dizer: aquela string inocente que tu passou vira padrão de regex, com todos os caracteres especiais valendo

Ele também está como Baseline Widely available na MDN, disponível nos navegadores desde julho de 2015

Dá pra usar tudo isso hoje? Compatibilidade:

É a pergunta que sempre aparece, então bora resolver de uma vez

includes(), startsWith() e endsWith() entraram na especificação ECMAScript 2015, estão classificados como Baseline Widely available na MDN e existem nos navegadores desde setembro de 2015

O indexOf() também está como Baseline Widely available

O search() está como Baseline Widely available e disponível nos navegadores desde julho de 2015

A única exceção da lista é o RegExp.escape(), que é Baseline 2025, disponível nos navegadores mais recentes desde maio de 2025, e pode não funcionar em navegador ou dispositivo antigo

includes(), indexOf() ou regex: qual usar em cada caso?

Dica rápida pra tu não travar na hora de escolher:

includes() quando tu só quer um true ou false, é o mais direto e o que deixa o código mais legível

indexOf() quando tu precisa da POSIÇÃO da ocorrência, e não só saber se existe, já que ele devolve o índice da primeira ocorrência ou -1

startsWith() e endsWith() quando o que importa é começo ou fim do texto

expressão regular com test() ou search() quando tu não procura um texto fixo e sim um PADRÃO (um formato de e-mail, um número, várias palavras de uma vez)

E não vou te vender qual é o mais rápido, porque isso depende de engine e de volume, e cravar benchmark por achismo é papo furado

Um detalhe que eu aprendi checando string VAZIA:

Aqui no canal eu já gravei um vídeo checando se uma string está vazia em JavaScript

Nele eu mostro os dois caminhos que uso na prática: comparar direto com a string vazia (str === ”) e jogar o operador not na frente da variável (!str), que inverte o booleano e te dá true justamente quando não tem nada dentro

Trago isso pra cá porque as duas coisas se encontram

Então o passo que eu faço antes de sair chamando o includes() é exatamente o do vídeo: checo se o termo está vazio e só depois busco

Uma coisa que eu ainda não medi e por isso não vou cravar aqui: comparação de desempenho entre includes(), indexOf() e expressão regular em volume grande de texto. Sem medição na mão, qualquer número seria chute, e chute eu não escrevo