在Ruby中，是否存在结合“选择”和“映射”的Array方法？

我有一个包含一些字符串值的Ruby数组。我需要：

1. 查找与某些谓词匹配的所有元素
2. 通过转换运行匹配的元素
3. 以数组形式返回结果

现在，我的解决方案如下所示：

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

是否存在将select和map组合为单个逻辑语句的Array或Enumerable方法？

我通常将map和compact以及选择标准一起用作后缀if。compact摆脱指甲。

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] 

您可以使用reduce此方法，只需一遍：

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

换句话说，将状态初始化为您想要的状态（在本例中为空列表，以填充：）[]，然后始终确保对原始列表中的每个元素进行修改后返回此值（在本例中，为修改后的元素）推送到列表）。

这是最有效的方法，因为它只循环遍历列表一次（map+ select或compact需要两次）。

在您的情况下：

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

Ruby 2.7以上

现在有！

Ruby 2.7即将推出 filter_map为此目的的。它是惯用语言和高性能，我希望它很快会成为标准。

例如：

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

这是一个很好的主题读物。

希望对某人有用！

解决此问题的另一种方法是使用new（相对于此问题）Enumerator::Lazy：

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

该.lazy方法返回一个惰性枚举器。在惰性枚举器上调用.select或会.map返回另一个惰性枚举器。只有调用一次.uniq，它实际上会强制枚举器并返回一个数组。所以有效的发生就是您.select和您的.map呼叫被合并为一个-您只需重复@lines一次即可完成.select和.map。

我的直觉是，亚当的reduce方法会更快一些，但我认为这更具可读性。

这样做的主要结果是，没有为每个后续方法调用创建中间数组对象。在正常@lines.select.map情况下，select返回一个数组，然后通过对其进行修改map，再次返回一个数组。相比之下，惰性求值仅创建一次数组。当您的初始收集对象很大时，这很有用。它还使您能够使用无限枚举器-例如random_number_generator.lazy.select(&:odd?).take(10)。

如果您select可以使用case运算符（===），grep则是一个不错的选择：

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"]

如果我们需要更复杂的逻辑，则可以创建lambda：

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***"]

我不确定是否有一个。可枚举模块，它添加select和map没有显示一个。

您需要将两个区块传递给 select_and_transform方法，这有点不直观。

显然，您可以将它们链接在一起，这更具可读性：

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

简单答案：

如果你有N条记录，并且要select和map根据病情再

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

在这里，属性是您想要从记录和条件中获得的任何条件，可以进行任何检查。

紧凑是冲洗如果条件产生的不必要的零

不，但是您可以这样做：

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

甚至更好：

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

我认为这种方式更具可读性，因为拆分了过滤条件和映射值，同时又清楚地知道动作已连接：

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

并且，在您的特定情况下，请result一起消除该变量：

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

在Ruby 1.9和1.8.7中，您也可以通过不向其传递块来链接和包装迭代器：

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

但是在这种情况下实际上是不可能的，因为块的类型返回select和的值map不匹配。对于这样的事情更有意义：

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

AFAICS，您能做的最好的就是第一个例子。

这是一个小例子：

%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"]

但是你真正想要的是["A", "B", "C", "D"]。

您应该尝试使用在其中添加了方法的库Rearmed RubyEnumerable#select_map。这里是一个例子：

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]}

如果不想创建两个不同的数组，可以使用compact!但要小心。

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

有趣的是，compact!就地清除了nil。compact!如果有更改，则返回值是相同的数组，如果没有nil，则返回nil。

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

将是一个班轮。

您的版本：

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

我的版本：

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

这将进行1次迭代（排序除外），并具有保持唯一性的额外好处（如果您不关心uniq，则只需将结果制成数组并 results.push(line) if ...

这是一个例子。它与您的问题不同，但可能是您想要的，或者可以为您提供解决方案的线索：

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