Usamos cookies para medir audiência e melhorar sua experiência. Você pode aceitar ou recusar a qualquer momento. Veja sobre o iMasters.
No desenvolvimento front-end com React, Next.js ou mesmo em scripts JavaScript mais complexos, um problema comum é identificar se uma sequência específica de elementos está presente dentro de um array maior, independentemente do offset inicial. Essa verificação é especialmente útil em cenários de validação de dados, processamento de eventos ou controle de fluxo, onde a ordem dos elementos importa, mas sua posição exata não é relevante.
Imagine que você tem um array principal e precisa checar se uma sequência de elementos aparece na mesma ordem, porém dispersa ao longo do array, podendo estar offset em posições diferentes. Por exemplo:
const masterArray = [12, 44, 22, 66, 222, 777, 22, 22, 22, 6, 77, 3]. const subArray = [777, 22, 22]. A questão é: como podemos escrever uma função que confirme a presença de subArray na masterArray, mantendo a ordem, mas permitindo offsets?
O método mais direto — usar indexOf em cada elemento — funciona, mas requer lógica adicional para garantir a sequência. Além disso, usar Array.prototype.includes não ajuda, pois não mantém a sequência nem o offset. Uma solução eficiente deve iterar pelo array principal, procurando por cada elemento subsequente de forma sequencial, sem reiniciar a procura toda vez.
Uma estratégia eficiente é usar um loop que percorre o array maior, procurando por cada elemento do subarray sequencialmente. Sempre que encontrar o elemento, passa a buscar a partir da posição seguinte. Se encontrar todos na sequência, confirma a presença. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Sem esse critério, a solução pode parecer simples no começo e cara no suporte.
function arrayContemSubarray(master, sub) {
let startIndex = 0. for (const elemento of sub) {
startIndex = master.indexOf(elemento, startIndex). if (startIndex === -1) {
return false. // elemento não encontrado na sequência
}
startIndex += 1. // segue procurando após a posição do elemento encontrado
}
return true. // todos elementos encontrados na sequência
}Exemplo de uso:
console.log(arrayContemSubarray(masterArray, subArray)). // true
console.log(arrayContemSubarray(masterArray, [777, 22, 3])). // falseApesar de simples, essa abordagem tem custo linear em relação ao tamanho do array principal para cada elemento do subarray. O desempenho é aceitável para tamanhos moderados, mas pode precisar de otimizações em arrays muito grandes ou em cenários de alta frequência. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco.
Outra questão é que a função só verifica a sequência na ordem exata. Caso precise de uma checagem mais flexível — como elementos que podem aparecer fora de ordem — seria necessário adaptar a lógica. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco.
1. Criar uma função que percorre o array maior, procurando sequencialmente pelos elementos do subarray.
2. Utilizar indexOf com o índice inicial atualizado após cada busca bem-sucedida.
3. Retornar verdadeiro ao encontrar toda a sequência ou falso caso algum elemento não seja localizado.
4. Testar com diferentes combinações para validar o comportamento.
Implementar essa lógica na sua codebase ajuda a evitar soluções mais ineficientes, além de manter o código limpo e de fácil compreensão. Para casos mais complexos, considerar estruturas de indexação ou pré-processamento pode melhorar o desempenho. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta.
Por fim, essa estratégia funciona bem na maioria das aplicações de validação de sequências e pode ser facilmente ajustada para diferentes requisitos de ordenação e offset. A decisão fica mais saudável quando o time consegue medir o impacto depois. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar.
Além do mais, se precisar verificar múltiplas subarrays ou padrões complexos, talvez uma abordagem com automatos ou expressões regulares em strings seja mais eficiente. Mas pra checagem sequencial simples, assim funciona bem.
hum, no meu time isso resolveu lindamente só quando ficou pequeno o bastante pra alguém manter sem drama.
Boa, essa implementação é prática e facilmente adaptável. Acho que o ponto de atenção é o tamanho do array, se for gigante, talvez precise de alguma otimização com índices pré-calculados.
Concordo, Daniel. No meu time, às vezes usamos uma abordagem de indexação invertida pra acelerar buscas em arrays muito grandes, mas pra casos menores essa solução funciona lindamente.
Só cuidado ao usar em cenários onde a sequência pode se repetir muitas vezes, aí a checagem pode virar um pesadelo de desempenho. Talvez valha pensar em cache ou indexação.