# every(), some(), find() e includes() em JavaScript

> Domine every(), some(), find() e includes() em JavaScript completamente. Guia completo sobre métodos de arrays para busca e validação eficiente. Aprenda!

URL: https://dpw.dev/javascript/every-some-find-includes-javascript/  
Publicado em: 2020-01-20  
Categoria: javascript  
Tags: basico-da-web  
Autor: Tárcio Zemel

A **programação funcional** já não é uma grande novidade em JavaScript. Métodos JS para manipulação de arrays, como `map()`, `filter()` e `reduce()`, são muito conhecidos e usados, mas seus irmãos `every()`, `some()`, `find()` e `includes()` também merecem ser citados.

Para um melhor entendimento e explicação de algumas vantagens de uma abordagem mais funcional, leia nosso artig [map(), filter() e reduce()](https://desenvolvimentoparaweb.com/javascript/map-filter-reduce-javascript/). Mas, basicamente, optar por este tipo de programação traz vantagens ao código como menos complexidade, menos efeitos colaterais e, se tiver sorte, maior legibilidade. :)

## `every()`

[Vídeo no YouTube](https://www.youtube.com/watch?v=QCqPixrujp4)

O método `every()` testa se todos os elementos do array passam por um teste implementado por uma função fornecida. Ele retorna `true` ou `false` baseado na condição especificada. Funciona mais ou menos como `filter()` (veja o artigo indicado acima), mas, ao invés de retornar um valor ou objeto, retorna um _boolean_.

**Use `every()` quando:** é preciso testar se todos os elementos de um array passam por um teste específico (que é uma função). Em outras palavras, use `every()` para testar se se tudo dentro de um array corresponde a um critério determinado.

Exemplo: testar se todos os elementos de um array são maiores que 10.

```javascript
// currentValue (obrigatório): O elemento atual sendo processado no array
// index (opcional): O índice do elemento atual sendo processado no array
// arr (opcional): O array de origem
function isBigEnough(currentValue, index, arr) {
  return currentValue >= 10;
}

[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true
```

| **Parâmetro** | **Significado** |
| --- | --- |
| `callback` | A função a ser testada. |
| `thisArg` | (opcional) Valor a ser usado como `this` quando o `callback` é executado. |

O método `every()` não modifica o array/objeto original.

## `some()`

[Vídeo no YouTube](https://www.youtube.com/watch?v=ReBK-5i66VY)

O método `some()` testa se pelo menos algum dos elementos de um array passa no teste implementado por uma função atribuída.

Funciona exatamente como `every()`, mas se pelo menos 1 elemento passa no teste, ele já retorna `true`.

**Use `some()` quando:** é preciso testar se pelo menos 1 elemento de um array passa por um teste específico (que é uma função). Em outras palavras, use `some()` para testar se algum elemento dentro de um array corresponde a um critério determinado.

Exemplo: testar se algum elemento de um array é maior que 10.

```javascript
// currentValue (obrigatório): O elemento atual sendo processado no array
// index (opcional): O índice do elemento atual sendo processado no array
// arr (opcional): O array de origem
function isBiggerThan10(currentValue, index, arr) {
  return currentValue > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true
```

| **Parâmetro** | **Significado** |
| --- | --- |
| `callback` | A função a ser testada. |
| `thisArg` | (opcional) Valor a ser usado como `this` quando o `callback` é executado. |

`some()` não altera o array/objeto dentro do qual ele é chamado.

## `find()`

[Vídeo no YouTube](https://www.youtube.com/watch?v=szXPNFjVKzI)

O método `find()` retorna o valor do primeiro elemento de um array que retornar `true` para uma função de teste fornecida. Se não houver alguma, retorna `undefined`.

Para ficar fácil de entender, pense que é como `filter()`, mas, ao invés de retornar outro array/objeto com os correspondentes, retorna somente o primeiro valor/objeto que passe no teste (que é uma função).

**Use `find()` quando:** é preciso procurar/verificar por um valor dentro de um array/objeto. Em outras palavras, use `find()` para criar um novo array/objeto baseado na função-teste fornecida.

Exemplo: encontrar um objeto em um array através de uma de suas propriedades.

```javascript
var inventory = [
    {name: 'jaca', quantity: 2},
    {name: 'banana', quantity: 0},
    {name: 'cereja', quantity: 5}
];

// currentValue (obrigatório): O elemento atual sendo processado no array
// index (opcional): O índice do elemento atual sendo processado no array
// arr (opcional): O array de origem
function isCherries(fruit, index, arr) { 
    return fruit.name === 'cereja';
}

// { name: 'cereja', quantity: 5 }
console.log(inventory.find(isCherries)); 
```

| **Parâmetro** | **Significado** |
| --- | --- |
| `callback` | A função a ser testada. |
| `thisArg` | (opcional) Valor a ser usado como `this` quando o `callback` é executado. |

## `includes()`

[Vídeo no YouTube](https://www.youtube.com/watch?v=\_FE5PDkycyI)

O método `includes()` determina se um array/objeto contém um determinado elemento ou não, retornando `true` ou `false`, respectivamente. Em outras palavras, `includes()` retornará `true` se o elemento existir no array/objeto.

A diferença para o `find()` é que `includes()` somente determina se o elemento existe ou não, retornando um boolean.

**Use `includes()` quando:** é preciso saber se um array/objeto possui determinado valor/elemento.

Exemplo: saber se determinado número consta em um array.

```javascript
[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
```

| **Parâmetro** | **Significado** |
| --- | --- |
| `searchElement` | O elemento que se quer buscar |
| `fromIndex` | (opcional) Posição no array de onde a busca por `searchElement` se iniciará (padrão `0`). |

## Conclusão sobre `every()`, `some()`, `find()` e `includes()` em JavaScript

Antes de partirmos para as conclusões, assista a nosso vídeo especial em que mostramos como trabalhar com uma API real usando alguns dos métodos de array JavaScript:

[Vídeo no YouTube](https://www.youtube.com/watch?v=rMek7Gtsros)

Tal como seus irmãos mais conhecidos [map(), filter() e reduce()](https://desenvolvimentoparaweb.com/javascript/map-filter-reduce-javascript/), os métodos `every()`, `some()`, `find()` e `includes()` também têm seu lugar de importância e são muito úteis em diversas situações de código JavaScript do dia-a-dia, ajudando a resolver problemas especialmente quando combinados.

Importante ressaltar, também, que métodos "funcionais" como `every()`, `some()`, `find()` e `includes()` não vieram para substituir loops tradicionais completamente, já que [podem apresentar diferentes performances a depender do tamanho do array/objeto que se está trabalhando](https://github.com/dg92/Performance-Analysis-JS).

Com este artigo, a apresentação dos 7 principais métodos (ou, pelo menos, os mais conhecidos) para se trabalhar com arrays/objetos usando JavaScript moderno se completa.

Se comparado a como se chegava aos mesmos resultados há não muito tempo atrás, fica evidente que o poder que JS oferece e o que é possível fazer ao usá-los, especialmente combinando e encadeando seus efeitos, é realmente algo espantoso.

---

Fonte: [dpw - desenvolvimento para web](https://dpw.dev/) (pt-BR).
Guia para agentes: https://dpw.dev/llms.txt
Índice completo: https://dpw.dev/sitemap-index.xml
Feed: https://dpw.dev/rss.xml