Favorite Ruby Methods#1
Tags: ruby, beginners, braziliandevs, codenewbie
Published: 2023-03-24 09:52:58

Olá rubystas, primeiramente gostaria de avisar que estou escrevendo esse texto como uma forma de me expor mais e consequentemente ver se consigo me livrar um pouco da síndrome do impostor, me forçando a escrever sobre as coisas que aprendo diariamente com o mundo da programação.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/42u13x9jqgecoq5n8arf.gif)

Em segundo lugar gostaria de fazer um agradecimento ao podcast [Ruby for All](https://www.rubyforall.com/) apresentado pelos maravilhosos [Andrew](https://www.rubyforall.com/people/andrew-mason) e [Julie](https://www.rubyforall.com/people/julie-j)
Esse texto tem como objetivo apresentar o podcast para a comunidade Ruby Brasileira e para isso gostaria de discorrer um pouco mais sobre uma série de 4 episódios bem legais na qual os apresentadores falaram sobre alguns de seus métodos favoritos, e irei começar com o [primeiro episódio](https://www.rubyforall.com/28) onde eles dão ênfase em métodos do módulo Array, nos próximos artigos outros módulos serão abordados, então vamos lá 🤓. 

**Obs1**: Escrevi a "difinição" de alguns métodos da forma mais resumida possível para ser fácil de digerir para pessoas estão começando a programar em Ruby.
Para aqueles que querem uma definição mais formal e com alguns comentários interessantes temos a própria [apidock](https://apidock.com/ruby/) da linguagem.

**Obs2**: Diversos desses métodos ilustrados nesse artigo possuem _aliases_ e podem ser acessados a partir de outra palavra chave, gostaria de dar um destaque principal ao método #filter que só se tornou um _alias_ do método #select a partir das versões mais do Ruby (>= 2.6.1).

Qualquer erro de definição, exemplos e outros, me avisem que estarei melhorando cada vez mais a qualidade dos meus posts.

Começando pelos mais famosos...

## Array#each 

Itera sobre cada elemento presente no array e retorna o array original fornecido.

```ruby
[true, false].each do |el| do 
  if el == true
    puts 'verdadeiro' 
  else 
    puts 'falso'
  end
end
# verdadeiro
# falso
# => [true, false]
```

## Array#map { |item| block } → new_array

Retorna um novo array com o resultado daquele bloco para cada iteração.
 
```ruby
[1,2,3].map do |el| { el >= 2 }
# => [false, true, true]
```

Podemos também utilizar uma notação abreviada _Symbol#to_proc_, essa notação simplificada também pode ser empregada em alguns dos outros métodos abaixo.
Um bom artigo que sugiro para entender mais a fundo sobre os detalhes e funcionamento desse tipo de sintaxe é o [map(&:method) syntax - meaning & usag](https://womanonrails.com/one-line-map-ruby).

O seguinte exemplo mostra uma possível aplicação desta notação:
 
Um Post pode ter vários objetos Message ou nenhum, e ele acessa as mesmas de acordo com alguma associação tal qual o método Post.messages retorna um array de objetos Message que pertencem aquele Post.

```ruby
[Post1, Post2, Post3].map(&:messages)
# => [[Msg1_1,Msg1_2],[Msg2_1], []]
```

Perceba que o map neste caso retorna um Array de arrays tendo em vista que o resultado de uma instância de Post#messages é um novo array, o resultado final acaba sendo um array de  dimensão 2. Podemos utilizar o método **Array#flat_map** que resumidamente utiliza o método #flatten!(1) recursivamente em cada elemento, retornando um array com um nível a menos. 

```ruby
[Post1, Post2, Post3].flat_map(&:messages)
# => [Msg1_1,Msg1_2,Msg2_1]
```

_(**obs**: Nesse caso o #flat_map passou um array de dimensão 2 para dimensão 1, caso a primeira saída possuísse um array de dimensão 3, ao utilizar o #flat_map o retorno seria um array de dimensão 2)_

```ruby
[[[2]],[[2]]].flat_map.to_a
# => [[2], [2]]
```

## Array#flatten(level) → new_array

Como dito anteriormente esse método itera sobre cada elemento do array e extrai o mesmo para um novo array externo, o parâmetro _level_ é o nível de recursão aplicado.

 ```ruby
[1,[2,[3]]].flatten(1)
# => [1,2,[3]]

```
## Array#uniq { |item| block } → array

Retorna um novo array removendo valores duplicados especificados por um bloco, quando o parâmetro não é passado ele utiliza itera sobre o próprio elemento.

 ```ruby
[1,2,2].uniq
# => [1,2]
```

O array retornado retêm a primeira ocorrência do elemento. Seja dois objetos que possuam um atributo em comum e outro distinto, se escolhermos o atributo comum como condição de unicidade, a primeira ocorrência do objeto é retornada. Em outras palavras podemos dizer que código implementado neste método é um algoritmo de ordenação estável, ou seja, se preserva a ordem de registros de chaves iguais. Isto é, se tais registros aparecem na sequência ordenada na mesma ordem em que estão na sequência inicial.

 ```ruby
[{name: 'bar', age: 10}, {name: 'bar', age: 12}].uniq { |x| x[:name] }
# => [{name: 'bar', age: 10}]
```

## Array#shuffle → new_array

Embaralha um determinado array

```ruby
[1,2,3]
# [2,3,1]
```
## Array#sample → obj

Escolhe um elemento aleatório do array.

```ruby
[1,2,3]
# => 2
```
## Array#count { |item| block } → int

Retorna o número de elementos presente no array, o parâmetro de bloco é opcional, caso contrário ele itera sobre o próprio elemento.

```ruby
[1,2,3]
# => 3
```

_(**Obs**: Este método está presente em diversos módulos. no Rails por exemplo temos um módulo bem conhecido chamado **ActiveRecord::Relation**, algo para se atentar é que caso o objeto seja dessa classe o método #count executará uma consulta SQL que retornará o quantidade de linhas daquela relação)_

```ruby
User.count
# SELECT COUNT(*) FROM "users"
# => 50
```
_(Um padrão que gosto de seguir é sempre usar #size para contar elementos de um array e #count para SQL, pois assim melhoramos a legibilidade do código)_

## Array#minmax {|a, b| ... } → [minimum, maximum]

Retorna um novo array de tamanho 2 com o menor elemento e o maior elemento. Quando não especificamos o bloco, os elementos são comparados entre si.
O bloco passado possui dois parâmetros tal qual utilizam o _spaceship operator_ para fim comparativo entre os valores da esquerda e da direita.

Ex:
```ruby
[2,3,1].minmax
# [1,3]
['fo','bar','lorem'].minmax { |a,b| a.length <=> b.length }
# => ['fo','lorem'] 
```

## Array#select {|element| ... } → array

Retorna um novo array contendo apenas elementos selecionados pelo bloco, ou seja, elementos cujo a condição aplicada retorna true.

```ruby
(0..9).select {|element| element % 3 == 0 }
# => [0, 3, 6, 9]
```

Observação Final:

Para os métodos: #map, #each, #flat_map, #select
caso o bloco não seja passado ele retorna um **Enumerator**
que é basicamente uma classe que permite iteração com ela internamente e externamente.
(https://ruby-doc.org/core-2.6/Enumerator.html)