Manipulando Arrays…
Tags: javascript, beginners, node, reactnative
Published: 2020-07-26 03:56:24

Existem várias formas de percorrer um array e que pode chegar a confundir um pouco as vezes, e hoje eu vou mostrar alguns métodos para podermos percorrer um array.



# Array.forEach()

o método `forEach()` executa uma função para cada elemento do array.
No exemplo abaixo pra cada elemento do array será somado 1 ao valor original

```javascript
const arr = [1, 3, 5, 7, 9];
arr.forEach(num => console.log(num+1))

// output: 2, 4, 6, 8, 10
```



# Array.map()

o método `map()` ele retorna um novo array como resultado da função.

Exemplo, digamos que eu queira saber a potência dos números dentro do array, o map irá percorrer cada item do array efetuando a conta da potência de cada valor e gerando um novo array com o resultado.

```javascript
const arr = [1, 2, 4, 7];
const potencia = arr.map(num => Math.pow(num, 2))

console.log(potencia) //output: [ 1, 4, 16, 49 ]
```



# Array.filter()

o método `filter()` como o próprio nome já diz, ele filtrará o array, retornando um novo array contendo apenas os valores coincidentes com a condição

```javascript
const arr = [2, 4, 7, 6, 9];
const par = arr.filter(num => num % 2 === 0)

console.log(par) //output: [ 2, 4, 6 ]
```



# Array.find()

O método `find()` irá retornar o valor do primeiro elemento que satisfazer a condição
caso não ache, retornará undefined

```javascript
const arr = [10, 18, 14, 16, 20];
const maior = arr.find(num => num > 15 )

console.log(maior) //output: 18

console.log(arr.find(num => num > 100 ))
//output: undefined
```



# Array.some()

o método `some()` retorna um booleano, parando sempre na primeira condição satisfatória e caso seja, retornará true, se não false

```javascript
const arr = [
  { nome: 'Enrique', idade: 21 },
  { nome: 'Isa', idade: 10 },
  { nome: 'Eloah', idade: 16 },
]

const maiorIdade = arr.some(pessoa => pessoa.idade > 15)
console.log(maiorIdade) //true
```



# Array.every()

O método `every()` igual que o `some()` também retorna um booleano porém ele irá verificar em TODOS os objetos para ver se a condição é satisfeita

pegando o array do exemplo do `some()`, verificamos se as pessoas tem a idade superior a 15 anos sendo assim ele só para quando verificar em todos os objetos.

No exemplo abaixo ele retornará false porque nem todos os objetos de pessoa tem a idade maior do que 15.

```javascript 
const maiorIdade = arr.every(pessoa => pessoa.idade > 15)
console.log(maiorIdade) //false
```
Porém, se modificarmos a idade de Isa para 17
```javascript
const arr = [
  { nome: "Enrique", idade: 21 },
  { nome: "Isa", idade: 17 },
  { nome: "Eloah", idade: 16 },
];
```
nós temos como resultado

```javascript
const maiorIdade = arr.every(pessoa => pessoa.idade > 15)
console.log(maiorIdade) //true
```



# Array.sort()

O método `sort()` ordena os elementos do array e retorna o mesmo.

```javascript
  const arr = [ 9, 10, 3, 7, 8 ]
  const arr2 = [ 'f', 'j', 'a', 'e', 'z' ]
  
  const asc = arr2.sort((indx, val) => indx > val ? 1 : -1)
  const desc = arr.sort((indx, val) => indx > val ? -1 : 1)
  
  console.log(asc) //output: ["a", "e", "f", "j", "z"]
  console.log(desc) //output: [10, 9, 8, 7, 3]
```



# Array.join()

o método `join()` juntará todos os elementos de um array e retornará como string. 

```javascript
const arr = ['uni', 'duni', 'tê']

console.log(arr.join()) //output: 'uni,duni,tê'
console.log(arr.join('')) //output: 'unidunitê'
console.log(arr.join('-')) //output: 'uni-duni-tê
```

mas caso seja passado um valor `undefined` ou `null` retornará uma string vazia
```javascript
const arr = ['uni', null, 'tê']

console.log(arr.join()) //output: 'uni,,tê'
console.log(arr.join('')) //output: 'unitê'
console.log(arr.join('-')) //output: 'uni--tê'
```



# Array.includes()

O método `includes()` verifica se um array contem um determinado elemento, retornando `true` ou `false`

```javascript
const arr = [2, 4, 6, 8, 10]

console.log(arr.includes(8)) //output: true
console.log(arr.includes(0)) //output: false
```

# Array.concat()
O método `concat()` retorna um novo array com todos os array/valores passados como parâmetro

```javascript
const arr1 = [1, 2, 3, 4, 5]
const arr2 = [6, 7, 8, 9, 10]

const newArr = arr1.concat(arr2)

console.log(newArr) //output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

---

# Fim!
E ai curtiu ? Então passa la no meu perfil, e da uma olhada nos demais artigos :smile:

![fim](https://dev-to-uploads.s3.amazonaws.com/i/nfb55xi3ccxalq4botd9.png)