Làm cách nào để tạo một băm trong Ruby so sánh chuỗi, bỏ qua trường hợp?

Question

Trong Ruby, tôi muốn lưu trữ một số thứ trong Hash, nhưng tôi không muốn nó phân biệt chữ hoa chữ thường. Ví dụ:

h = Hash.new 
h["HELLO"] = 7 
puts h["hello"] 

Điều này sẽ xuất 7, mặc dù trường hợp khác. Tôi có thể chỉ ghi đè phương pháp bình đẳng của băm hoặc một cái gì đó tương tự?

Cảm ơn.

Answer 1

Để ngăn chặn sự thay đổi này từ các bộ phận độc lập hoàn toàn phá vỡ chương trình của bạn (chẳng hạn như đá quý ruby ​​khác mà bạn đang sử dụng), tạo ra một lớp học riêng cho băm nhạy cảm của bạn.

class HashClod < Hash 
    def [](key) 
    super _insensitive(key) 
    end 

    def []=(key, value) 
    super _insensitive(key), value 
    end 

    # Keeping it DRY. 
    protected 

    def _insensitive(key) 
    key.respond_to?(:upcase) ? key.upcase : key 
    end 
end 

you_insensitive = HashClod.new 

you_insensitive['clod'] = 1 
puts you_insensitive['cLoD'] # => 1 

you_insensitive['CLod'] = 5 
puts you_insensitive['clod'] # => 5 

Sau khi ghi đè các chức năng chuyển nhượng và truy xuất, có khá nhiều bánh. Việc tạo một thay thế đầy đủ cho Hash sẽ đòi hỏi phải tỉ mỉ hơn về việc xử lý các bí danh và các hàm khác (ví dụ, #has_key? Và #store) cần thiết để thực hiện đầy đủ. Các mô hình trên có thể dễ dàng được mở rộng cho tất cả các phương pháp liên quan.

Answer 2

Bất kỳ lý do gì để không chỉ sử dụng chuỗi # upcase?

h = Hash.new 

h["HELLO"] = 7 

puts h["hello".upcase] 

Nếu bạn nhấn mạnh vào sửa đổi băm, bạn có thể làm điều gì đó như sau

class Hash 
alias :oldIndexer :[] 

def [](val) 
    if val.respond_to? :upcase then oldIndexer(val.upcase) else oldIndexer(val) end 
end 
end 

Vì nó đã được đưa lên, bạn cũng có thể làm điều này để làm cho thiết lập trường hợp nhạy cảm:

class Hash 
alias :oldSetter :[]= 
def []=(key, value) 
    if key.respond_to? :upcase then oldSetter(key.upcase, value) else oldSetter(key, value) end 
end 
end 

Tôi cũng khuyên bạn nên làm điều này bằng cách sử dụng module_eval.

Answer 3

Nói chung, tôi sẽ nói rằng đây là một kế hoạch xấu; Tuy nhiên, nếu tôi là bạn, tôi muốn tạo một lớp con của băm đó sẽ ghi đè các [] phương pháp:

class SpecialHash < Hash 
    def [](search) 
    # Do special code here 
    end 
end 

Answer 4

require 'test/unit' 
class TestCaseIndifferentHash < Test::Unit::TestCase 
    def test_that_the_hash_matches_keys_case_indifferent 
    def (hsh = {}).[](key) super(key.upcase) end 

    hsh['HELLO'] = 7 
    assert_equal 7, hsh['hello'] 
    end 
end 

Answer 5

Nếu bạn thực sự muốn bỏ qua trường hợp theo cả hai hướng và xử lý tất cả các phương pháp Hash như #has_key?, #fetch , #values_at, #delete, v.v., bạn sẽ cần phải làm một công việc nhỏ nếu bạn muốn xây dựng điều này từ đầu, nhưng nếu bạn tạo một lớp mới kéo dài từ lớp ActiveSupport::HashWithIndifferentAccess, bạn sẽ có thể làm điều đó khá dễ dàng như vậy :

require "active_support/hash_with_indifferent_access" 

class CaseInsensitiveHash < HashWithIndifferentAccess 
    # This method shouldn't need an override, but my tests say otherwise. 
    def [](key) 
    super convert_key(key) 
    end 

    protected 

    def convert_key(key) 
    key.respond_to?(:downcase) ? key.downcase : key 
    end 
end 

Dưới đây là một số ví dụ hành vi:

h = CaseInsensitiveHash.new 
h["HELLO"] = 7 
h.fetch("HELLO")    # => 7 
h.fetch("hello")    # => 7 
h["HELLO"]      # => 7 
h["hello"]      # => 7 
h.has_key?("hello")    # => true 
h.values_at("hello", "HELLO") # => [7, 7] 
h.delete("hello")    # => 7 
h["HELLO"]      # => nil 

Answer 6

Trong khi phương pháp tiếp cận của Ryan McGeary hoạt động tốt và gần như chắc chắn là cách chính xác để làm điều đó, có một lỗi mà tôi đã không thể phân biệt nguyên nhân gây ra phương pháp Hash[].

Ví dụ:

r = CaseInsensitiveHash['ASDF', 1, 'QWER', 2] 
=> {"ASDF"=>1, "QWER"=>2} 
r['ASDF'] 
=> nil 
ap r 
{ 
    "ASDF" => nil, 
    "QWER" => nil 
} 
=> {"ASDF"=>1, "QWER"=>2} 

Mặc dù tôi đã không thể tìm thấy hoặc sửa chữa các nguyên nhân cơ bản của lỗi này, hack sau không cải thiện vấn đề:

r = CaseInsensitiveHash.new(Hash['ASDF', 1, 'QWER', 2]) 
=> {"asdf"=>1, "qwer"=>2} 
r['ASDF'] 
=> 1 
ap r 
{ 
    "asdf" => 1, 
    "qwer" => 2 
} 
=> {"asdf"=>1, "qwer"=>2}