Trong Ruby, làm cách nào để tạo một hàm băm từ một mảng?

Tôi có một mảng đơn giản:

arr = ["apples", "bananas", "coconuts", "watermelons"]

Tôi cũng có một hàm fsẽ thực hiện thao tác trên một đầu vào chuỗi đơn và trả về một giá trị. Thao tác này rất tốn kém, vì vậy tôi muốn ghi nhớ kết quả trong hàm băm.

Tôi biết mình có thể tạo hàm băm mong muốn bằng một thứ như sau:

h = {}
arr.each { |a| h[a] = f(a) }

Những gì tôi muốn làm là không phải khởi tạo h, vì vậy tôi có thể viết một cái gì đó như sau:

h = arr.(???) { |a| a => f(a) }

Điều đó có thể được thực hiện?

Giả sử bạn có một hàm có tên linh hoạt: "f"

def f(fruit)
   fruit + "!"
end

arr = ["apples", "bananas", "coconuts", "watermelons"]
h = Hash[ *arr.collect { |v| [ v, f(v) ] }.flatten ]

sẽ cung cấp cho bạn:

{"watermelons"=>"watermelons!", "bananas"=>"bananas!", "apples"=>"apples!", "coconuts"=>"coconuts!"}

Đã cập nhật:

Như đã đề cập trong các bình luận, Ruby 1.8.7 giới thiệu một cú pháp đẹp hơn cho điều này:

h = Hash[arr.collect { |v| [v, f(v)] }]

Đã làm một số điểm chuẩn nhanh, bẩn trên một số câu trả lời đã cho. (Những phát hiện này có thể không hoàn toàn giống với của bạn dựa trên phiên bản Ruby, bộ nhớ đệm lạ, v.v. nhưng kết quả chung sẽ tương tự.)

arr là một tập hợp các đối tượng ActiveRecord.

Benchmark.measure {
    100000.times {
        Hash[arr.map{ |a| [a.id, a] }]
    }
}

Điểm chuẩn @ real = 0,860651, @ cstime = 0,0, @ cutime = 0,0, @ stime = 0,0, @ utime = 0,8500000000000005, @ tổng = 0,8500000000000005

Benchmark.measure { 
    100000.times {
        h = Hash[arr.collect { |v| [v.id, v] }]
    }
}

Điểm chuẩn @ real = 0,74612, @ cstime = 0,0, @ cutime = 0,0, @ stime = 0,010000000000000009, @ utime = 0,740000000000002, @ tổng = 0,750000000000002

Benchmark.measure {
    100000.times {
        hash = {}
        arr.each { |a| hash[a.id] = a }
    }
}

Điểm chuẩn @ real = 0,627355, @ cstime = 0,0, @ cutime = 0,0, @ stime = 0,010000000000000009, @ utime = 0,6199999999999974, @ tổng = 0,6299999999999975

Benchmark.measure {
    100000.times {
        arr.each_with_object({}) { |v, h| h[v.id] = v }
    }
}

Điểm chuẩn @ real = 1.650568, @ cstime = 0.0, @ cutime = 0.0, @ stime = 0.12999999999999998, @ utime = 1.51, @ total = 1.64

Tóm lại là

Chỉ vì Ruby là biểu cảm và năng động, không có nghĩa là bạn nên luôn tìm kiếm giải pháp tốt nhất. Mỗi vòng lặp cơ bản là nhanh nhất trong việc tạo một băm.

h = arr.each_with_object({}) { |v,h| h[v] = f(v) }

Ruby 2.6.0 cho phép một cú pháp ngắn hơn bằng cách truyền một khối cho to_hphương thức :

arr.to_h { |a| [a, f(a)] }

Đây là những gì tôi có thể sẽ viết:

h = Hash[arr.zip(arr.map(&method(:f)))]

Đơn giản, rõ ràng, rõ ràng, tuyên bố. Bạn có cần gì nữa không?

Tôi đang làm nó như được mô tả trong bài viết tuyệt vời này http://robots.thoughtbot.com/iteration-as-an-anti-pattern#build-a-hash-from-an-array

array = ["apples", "bananas", "coconuts", "watermelons"]
hash = array.inject({}) { |h,fruit| h.merge(fruit => f(fruit)) }

Thông tin thêm về injectphương pháp: http://ruby-doc.org/core-2.0.0/Enumerable.html#method-i-inject

Một cái khác, IMHO rõ ràng hơn một chút -

Hash[*array.reduce([]) { |memo, fruit| memo << fruit << f(fruit) }]

Sử dụng độ dài dưới dạng f () -

2.1.5 :026 > array = ["apples", "bananas", "coconuts", "watermelons"]
 => ["apples", "bananas", "coconuts", "watermelons"] 
2.1.5 :027 > Hash[*array.reduce([]) { |memo, fruit| memo << fruit << fruit.length }]
 => {"apples"=>6, "bananas"=>7, "coconuts"=>8, "watermelons"=>11} 
2.1.5 :028 >

ngoài câu trả lời của Vlado Cingel (tôi chưa thể thêm nhận xét, vì vậy tôi đã thêm câu trả lời).

Inject cũng có thể được sử dụng theo cách này: khối phải trả lại bộ tích lũy. Chỉ phép gán trong khối mới trả về giá trị của phép gán và lỗi được báo cáo.

array = ["apples", "bananas", "coconuts", "watermelons"]
hash = array.inject({}) { |h,fruit| h[fruit]= f(fruit); h }