Trong Ruby, có phương thức Array nào kết hợp giữa 'select' và 'map' không?

Tôi có một mảng Ruby chứa một số giá trị chuỗi. Tôi cần phải:

1. Tìm tất cả các phần tử phù hợp với một số vị ngữ
2. Chạy các phần tử phù hợp thông qua một phép chuyển đổi
3. Trả về kết quả dưới dạng một mảng

Ngay bây giờ giải pháp của tôi trông như thế này:

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

Có phương thức Array hoặc Enumerable nào kết hợp lựa chọn và ánh xạ vào một câu lệnh logic duy nhất không?

Tôi thường sử dụng mapvà compactcùng với các tiêu chí lựa chọn của tôi như một hậu tố if. compactthoát khỏi 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] 

Bạn có thể sử dụng reducecho việc này, chỉ yêu cầu một thẻ:

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

Nói cách khác, hãy khởi tạo trạng thái thành những gì bạn muốn (trong trường hợp của chúng tôi, một danh sách trống để điền: [] :), sau đó luôn đảm bảo trả về giá trị này với các sửa đổi cho từng phần tử trong danh sách ban đầu (trong trường hợp của chúng tôi là phần tử đã sửa đổi đẩy lên danh sách).

Đây là cách hiệu quả nhất vì nó chỉ lặp lại danh sách với một lần vượt qua ( map+ selecthoặccompact yêu cầu hai lần vượt qua).

Trong trường hợp của bạn:

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

Ruby 2.7+

Hiện có!

Ruby 2.7 đang giới thiệu filter_map cho mục đích chính xác này. Nó mang tính thành ngữ và biểu diễn, và tôi hy vọng nó sẽ sớm trở thành tiêu chuẩn.

Ví dụ:

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

Đây là một bài đọc hay về chủ đề này .

Hy vọng điều đó hữu ích cho ai đó!

Một cách khác để tiếp cận vấn đề này là sử dụng câu hỏi mới (liên quan đến câu hỏi này) Enumerator::Lazy:

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

Các .lazyphương thức trả về một Enumerator lười biếng. Gọi .selecthoặc .maptrên một điều tra viên lười biếng trả về một điều tra viên lười biếng khác. Chỉ một khi bạn gọi .uniq, nó thực sự buộc người điều tra và trả về một mảng. Vì vậy, điều hiệu quả xảy ra là của bạn .selectvà .mapcác cuộc gọi được kết hợp thành một - bạn chỉ lặp lại @linesmột lần để thực hiện cả hai .selectvà.map .

Bản năng của tôi là reducephương pháp của Adam sẽ nhanh hơn một chút, nhưng tôi nghĩ điều này dễ đọc hơn nhiều.

Hệ quả chính của việc này là không có đối tượng mảng trung gian nào được tạo cho mỗi lần gọi phương thức tiếp theo. Trong @lines.select.maptrường hợp bình thường , selecttrả về một mảng sau đó được sửa đổi bởi map, một lần nữa trả về một mảng. Để so sánh, đánh giá lười biếng chỉ tạo mảng một lần. Điều này hữu ích khi đối tượng bộ sưu tập ban đầu của bạn lớn. Thiết bị cho phép bạn làm việc với điều tra viên vô hạn - ví dụ random_number_generator.lazy.select(&:odd?).take(10).

Nếu bạn có một selectcó thể sử dụng casetoán tử ( ===), greplà một lựa chọn thay thế tốt:

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

Nếu chúng ta cần logic phức tạp hơn, chúng ta có thể tạo 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***"]

Tôi không chắc là có. Các mô-đun Enumerable , mà thêm selectvàmap , không hiển thị một.

Bạn sẽ được yêu cầu vượt qua hai khối để select_and_transform phương thức, điều này sẽ khiến IMHO hơi không trực quan.

Rõ ràng, bạn có thể chuỗi chúng lại với nhau, dễ đọc hơn:

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

Câu trả lời đơn giản:

Nếu bạn có n bản ghi, và bạn muốn selectvà mapdựa trên điều kiện thì

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

Ở đây, thuộc tính là bất kỳ thứ gì bạn muốn từ bản ghi và điều kiện bạn có thể đặt bất kỳ kiểm tra nào.

nhỏ gọn là để loại bỏ số không không cần thiết ra khỏi điều kiện đó nếu

Không, nhưng bạn có thể làm như thế này:

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

Hoặc thậm chí tốt hơn:

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

Tôi nghĩ rằng cách này dễ đọc hơn, vì chia nhỏ các điều kiện bộ lọc và giá trị được ánh xạ trong khi vẫn rõ ràng rằng các hành động được kết nối với nhau:

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

Và, trong trường hợp cụ thể của bạn, hãy loại bỏ resulttất cả các biến cùng nhau:

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

Trong Ruby 1.9 và 1.8.7, bạn cũng có thể xâu chuỗi và quấn các trình vòng lặp bằng cách không truyền khối cho chúng:

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

Nhưng nó không thực sự khả thi trong trường hợp này, vì các loại khối trả về giá trị của selectvà mapkhông khớp với nhau. Nó có ý nghĩa hơn cho một cái gì đó như thế này:

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

AFAICS, điều tốt nhất bạn có thể làm là ví dụ đầu tiên.

Đây là một ví dụ nhỏ:

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

Nhưng những gì bạn thực sự muốn là ["A", "B", "C", "D"].

Bạn nên thử sử dụng thư viện Rearmed Ruby của tôi, trong đó tôi đã thêm phương thức Enumerable#select_map. Đây là một ví dụ:

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

Nếu bạn không muốn tạo hai mảng khác nhau, bạn có thể sử dụng compact!nhưng hãy cẩn thận về nó.

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

Thật thú vị, compact!có một loại bỏ nil tại chỗ. Giá trị trả về của compact!là cùng một mảng nếu có thay đổi nhưng nil nếu không có nils.

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

Sẽ là một lớp lót.

Phiên bản của bạn:

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

Phiên bản của tôi:

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

Điều này sẽ thực hiện 1 lần lặp (ngoại trừ sắp xếp) và có thêm phần thưởng là giữ tính duy nhất (nếu bạn không quan tâm đến uniq, thì chỉ cần tạo kết quả là một mảng và results.push(line) if ...

Đây là một ví dụ. Nó không giống với vấn đề của bạn, nhưng có thể là những gì bạn muốn hoặc có thể đưa ra manh mối cho giải pháp của bạn:

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