Làm thế nào để có được các yếu tố độc đáo từ một mảng băm trong Ruby?

Question

Tôi có một mảng băm, và tôi muốn các giá trị duy nhất của nó. Gọi số Array.uniq không cho tôi những gì tôi mong đợi.

a = [{:a => 1},{:a => 2}, {:a => 1}] 
a.uniq # => [{:a => 1}, {:a => 2}, {:a => 1}] 

đâu tôi mong đợi:

[{:a => 1}, {:a => 2}] 

Trong việc tìm kiếm xung quanh trên mạng, tôi không đưa ra một giải pháp mà tôi đang hài lòng với. Folks đã đề xuất xác định lại Hash.eql? và Hash.hash, vì đó là những gì Array.uniq đang truy vấn.

Chỉnh sửa: Nơi tôi gặp phải điều này trong thế giới thực, các băm hơi phức tạp hơn một chút. Chúng là kết quả của JSON được phân tích cú pháp có nhiều trường, một số trong đó các giá trị là băm. Tôi đã có một loạt các kết quả mà tôi muốn lọc ra các giá trị duy nhất.

Tôi không thích định nghĩa lại các giải pháp Hash.eql? và Hash.hash, vì tôi sẽ phải xác định lại Hash trên toàn cầu hoặc xác định lại nó cho mỗi mục nhập trong mảng của tôi. Thay đổi định nghĩa của Hash cho mỗi mục nhập sẽ rất cồng kềnh, đặc biệt là vì có thể có băm lồng nhau bên trong mỗi mục nhập.

Thay đổi Hash trên toàn cầu có một số tiềm năng, đặc biệt nếu nó được thực hiện tạm thời. Tôi muốn xây dựng một lớp hoặc chức năng trợ giúp khác bao bọc việc lưu các định nghĩa cũ và khôi phục chúng, nhưng tôi nghĩ điều này làm tăng thêm sự phức tạp hơn là thực sự cần thiết.

Sử dụng inject có vẻ như là một lựa chọn tốt để xác định lại Hash.

Answer 1

tôi có thể có được những gì tôi muốn bằng cách gọi inject

a = [{:a => 1},{:a => 2}, {:a => 1}] 
a.inject([]) { |result,h| result << h unless result.include?(h); result } 

này sẽ trở lại:

[{:a=>1}, {:a=>2}] 

Answer 2

Câu trả lời bạn đưa ra cũng tương tự như một trong những thảo luận here. Nó ghi đè các phương pháp hash và eql? trên các băm sẽ xuất hiện trong mảng mà sau đó làm cho uniq hoạt động chính xác.

Answer 3

Giả sử băm của bạn luôn luôn đơn cặp khóa-giá trị, điều này sẽ làm việc:

a.map {|h| h.to_a[0]}.uniq.map {|k,v| {k => v}} 

Hash.to_a tạo ra một mảng của mảng quan trọng có giá trị, vì vậy bản đồ đầu tiên giúp bạn:

[[:a, 1], [:a, 2], [:a, 1]] 

uniq trên Mảng làm những gì bạn muốn, cho bạn:

[[:a, 1], [:a, 2]] 

và sau đó bản đồ thứ hai đặt chúng trở lại togeth er như băm một lần nữa.

Answer 4

tìm thấy trên google http://mikeburnscoder.wordpress.com/2008/01/18/uniquify-an-array-of-hashes-in-ruby/

Answer 5

Tôi đã có một tình huống tương tự, nhưng băm có khóa. Tôi đã sử dụng phương pháp sắp xếp.

Những gì tôi có nghĩa là:

bạn có một mảng:

[{:x=>1},{:x=>2},{:x=>3},{:x=>2},{:x=>1}] 

bạn sắp xếp nó (#sort_by {|t| t[:x]}) và có được điều này:

[{:x=>1}, {:x=>1}, {:x=>2}, {:x=>2}, {:x=>3}] 

bây giờ là một phiên bản sửa đổi chút câu trả lời bằng Aaaron Hinni:

your_array.inject([]) do |result,item| 
    result << item if !result.last||result.last[:x]!=item[:x] 
    result 
end 

Tôi cũng đã thử:

test.inject([]) {|r,h| r<<h unless r.find {|t| t[:x]==h[:x]}; r}.sort_by {|t| t[:x]} 

nhưng nó rất chậm. đây là điểm chuẩn của tôi:

test=[] 
1000.times {test<<{:x=>rand}} 

Benchmark.bmbm do |bm| 
    bm.report("sorting: ") do 
    test.sort_by {|t| t[:x]}.inject([]) {|r,h| r<<h if !r.last||r.last[:x]!=h[:x]; r} 
    end 
    bm.report("inject: ") {test.inject([]) {|r,h| r<<h unless r.find {|t| t[:x]==h[:x]}; r}.sort_by {|t| t[:x]} } 
end 

kết quả:

Rehearsal --------------------------------------------- 
sorting: 0.010000 0.000000 0.010000 ( 0.005633) 
inject:  0.470000 0.140000 0.610000 ( 0.621973) 
------------------------------------ total: 0.620000sec 

       user  system  total  real 
sorting: 0.010000 0.000000 0.010000 ( 0.003839) 
inject:  0.480000 0.130000 0.610000 ( 0.612438) 

Answer 6

của Ruby 1.8.7+ sẽ trả lại chỉ là những gì bạn đã mong đợi:

[{:a=>1}, {:a=>2}, {:a=>1}].uniq 
#=> [{:a=>1}, {:a=>2}] 

Answer 7

Phương pháp ống trên mảng (có sẵn từ 1.8 .6) thực hiện công đoàn thiết lập (trả về mảng), vì vậy sau đây là một cách có thể khác để lấy các phần tử duy nhất của bất kỳ mảng nào a:

[] | a

Answer 8

Bạn có thể sử dụng (thử nghiệm trong ruby ​​1.9.3),

[{a: 1},{a: 2},{a:1}].uniq => [{a:1},{a: 2}] 
[{a: 1,b: 2},{a: 2, b: 2},{a: 1, b: 3}].uniq_by {|v| v[:a]} => [{a: 1,b: 2},{a: 2, b: 2}]