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)
Top comments (0)