Favorite Ruby Methods#1

Pedro Aniceto — Fri, 24 Mar 2023 09:52:58 +0000

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.

Em segundo lugar gostaria de fazer um agradecimento ao podcast Ruby for All apresentado pelos maravilhosos Andrew e Julie
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 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 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.

[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.

[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.

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.

[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.

[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)

[[[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.

[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.

[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.

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

Array#shuffle → new_array

Embaralha um determinado array

[1,2,3]
# [2,3,1]

Array#sample → obj

Escolhe um elemento aleatório do array.

[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.

[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)

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:

[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.

(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)

Forem: Pedro Aniceto