Em Ruby, existe um método Array que combina 'select' e 'map'?

Eu tenho uma matriz Ruby contendo alguns valores de string. Eu preciso:

1. Encontre todos os elementos que correspondem a algum predicado
2. Execute os elementos correspondentes por meio de uma transformação
3. Retorna os resultados como uma matriz

No momento, minha solução é assim:

def example
  matchingLines = @lines.select{ |line| ... }
  results = matchingLines.map{ |line| ... }
  return results.uniq.sort
end

Existe um método Array ou Enumerable que combina selecionar e mapear em uma única instrução lógica?

Eu geralmente uso mape compactjunto com meus critérios de seleção como um postfix if. compactse livrar dos nils.

jruby-1.5.0 > [1,1,1,2,3,4].map{|n| n*3 if n==1}    
 => [3, 3, 3, nil, nil, nil] 


jruby-1.5.0 > [1,1,1,2,3,4].map{|n| n*3 if n==1}.compact
 => [3, 3, 3] 

Você pode usar reducepara isso, o que requer apenas uma passagem:

[1,1,1,2,3,4].reduce([]) { |a, n| a.push(n*3) if n==1; a }
=> [3, 3, 3] 

Em outras palavras, inicialize o estado para ser o que você deseja (no nosso caso, uma lista vazia para preencher: [] , então sempre certifique-se de retornar este valor com modificações para cada elemento na lista original (no nosso caso, o elemento modificado empurrado para a lista).

Este é o mais eficiente uma vez que só faz um loop na lista com uma passagem ( map+ selectoucompact requer duas passagens).

No seu caso:

def example
  results = @lines.reduce([]) do |lines, line|
    lines.push( ...(line) ) if ...
    lines
  end
  return results.uniq.sort
end

Ruby 2.7+

Existe agora!

Ruby 2.7 está apresentando filter_mapexatamente para esse propósito. É idiomático e de alto desempenho, e espero que se torne a norma em breve.

Por exemplo:

numbers = [1, 2, 5, 8, 10, 13]
enum.filter_map { |i| i * 2 if i.even? }
# => [4, 16, 20]

Aqui está uma boa leitura sobre o assunto .

Espero que seja útil para alguém!

Outra maneira diferente de abordar isso é usando o novo (em relação a esta questão) Enumerator::Lazy:

def example
  @lines.lazy
        .select { |line| line.property == requirement }
        .map    { |line| transforming_method(line) }
        .uniq
        .sort
end

O .lazymétodo retorna um enumerador preguiçoso. Chamar .selectou .mapem um enumerador preguiçoso retorna outro enumerador preguiçoso. Somente quando você chama .uniq, ele realmente força o enumerador e retorna um array. Então, o que efetivamente acontece é a sua .selecte .mapas chamadas são combinados em um único - você só iterar @linesuma vez para fazer as duas coisas .selecte.map .

Meu instinto é que o reducemétodo de Adam será um pouco mais rápido, mas acho que isso é muito mais legível.

A principal consequência disso é que nenhum objeto de array intermediário é criado para cada chamada de método subsequente. Em uma @lines.select.mapsituação normal , selectretorna uma matriz que é então modificada por map, novamente retornando uma matriz. Em comparação, a avaliação preguiçosa cria um array apenas uma vez. Isso é útil quando o objeto da coleção inicial é grande. Ele também permite que você trabalhe com recenseadores infinitas - eg random_number_generator.lazy.select(&:odd?).take(10).

Se você tem um selectque pode usar o caseoperador ( ===), grepé uma boa alternativa:

p [1,2,'not_a_number',3].grep(Integer){|x| -x } #=> [-1, -2, -3]

p ['1','2','not_a_number','3'].grep(/\D/, &:upcase) #=> ["NOT_A_NUMBER"]

Se precisarmos de uma lógica mais complexa, podemos criar lambdas:

my_favourite_numbers = [1,4,6]

is_a_favourite_number = -> x { my_favourite_numbers.include? x }

make_awesome = -> x { "***#{x}***" }

my_data = [1,2,3,4]

p my_data.grep(is_a_favourite_number, &make_awesome) #=> ["***1***", "***4***"]

Não tenho certeza se há um. O módulo Enumerable , que adiciona selecte map, não mostra um.

Você teria que passar dois blocos para o select_and_transformmétodo, o que seria um IMHO um pouco não intuitivo.

Obviamente, você pode apenas encadea-los, o que é mais legível:

transformed_list = lines.select{|line| ...}.map{|line| ... }

Resposta simples:

Se você tiver n registros e quiser selecte com mapbase na condição, então

records.map { |record| record.attribute if condition }.compact

Aqui, o atributo é o que você quiser do registro e a condição você pode colocar qualquer verificação.

compacto é limpar os nulos desnecessários que saíram dessa condição se

Não, mas você pode fazer assim:

lines.map { |line| do_some_action if check_some_property  }.reject(&:nil?)

Ou melhor ainda:

lines.inject([]) { |all, line| all << line if check_some_property; all }

Acho que dessa forma é mais legível, porque divide as condições do filtro e o valor mapeado, mantendo claro que as ações estão conectadas:

results = @lines.select { |line|
  line.should_include?
}.map do |line|
  line.value_to_map
end

E, no seu caso específico, elimine a resultvariável completamente:

def example
  @lines.select { |line|
    line.should_include?
  }.map { |line|
    line.value_to_map
  }.uniq.sort
end

def example
  @lines.select {|line| ... }.map {|line| ... }.uniq.sort
end

No Ruby 1.9 e 1.8.7, você também pode encadear e agrupar iteradores simplesmente não passando um bloco para eles:

enum.select.map {|bla| ... }

Mas não é realmente possível neste caso, uma vez que os tipos de bloco retornam valores de selecte mapnão coincidem. Faz mais sentido para algo assim:

enum.inject.with_index {|(acc, el), idx| ... }

AFAICS, o melhor que você pode fazer é o primeiro exemplo.

Aqui está um pequeno exemplo:

%w[a b 1 2 c d].map.select {|e| if /[0-9]/ =~ e then false else e.upcase end }
# => ["a", "b", "c", "d"]

%w[a b 1 2 c d].select.map {|e| if /[0-9]/ =~ e then false else e.upcase end }
# => ["A", "B", false, false, "C", "D"]

Mas o que você realmente quer é ["A", "B", "C", "D"].

Você deve tentar usar minha biblioteca Rearmed Ruby na qual adicionei o método Enumerable#select_map. Aqui está um exemplo:

items = [{version: "1.1"}, {version: nil}, {version: false}]

items.select_map{|x| x[:version]} #=> [{version: "1.1"}]
# or without enumerable monkey patch
Rearmed.select_map(items){|x| x[:version]}

Se você não quiser criar dois arrays diferentes, pode usar, compact!mas tenha cuidado com isso.

array = [1,1,1,2,3,4]
new_array = map{|n| n*3 if n==1}
new_array.compact!

Curiosamente, compact!faz uma remoção de nada no local. O valor de retorno de compact!é o mesmo array se houver alterações, mas nulo se não houver nulos.

array = [1,1,1,2,3,4]
new_array = map{|n| n*3 if n==1}.tap { |array| array.compact! }

Seria um forro.

Sua versão:

def example
  matchingLines = @lines.select{ |line| ... }
  results = matchingLines.map{ |line| ... }
  return results.uniq.sort
end

Minha versão:

def example
  results = {}
  @lines.each{ |line| results[line] = true if ... }
  return results.keys.sort
end

Isso fará 1 iteração (exceto a classificação) e tem o bônus adicional de manter a exclusividade (se você não se importa com o uniq, então apenas faça dos resultados uma matriz e results.push(line) if ...

Aqui está um exemplo. Não é o mesmo que o seu problema, mas pode ser o que você deseja, ou pode dar uma pista para sua solução:

def example
  lines.each do |x|
    new_value = do_transform(x)
    if new_value == some_thing
      return new_value    # here jump out example method directly.
    else
      next                # continue next iterate.
    end
  end
end