询问Ruby数组的哈希值

Question

I need to group people by age in Ruby. I have their date of birth, and a method which returns their age in years. So a solution like this works.

case
when (0..15).cover?(age_years)
  'child'
when (16..24).cover?(age_years)
  '16 to 24'
when (25..34).cover?(age_years)
  '25 to 34'
when (35..44).cover?(age_years)
  '35 to 44'
when (45..54).cover?(age_years)
  '45 to 54'
when (55..64).cover?(age_years)
  '55 to 64'
when age_years > 64
  'really old'
else
  'unknown'
end

However, I am trying to learn Ruby and am looking for a more elegant solution. I thought about putting the age_ranges into an array of hashes like this...

age_ranges = [{ name: 'child', min_age: 0, max_age: 15 },
              { name: '16 to 24', min_age: 16, max_age: 24 }]

but am at a loss as to how to interrogate this data to return the correct name where the age_years is within the appropriate ranges, or even a range like this

age_ranges = [{ name: 'child', age_range: '0..15' },
              { name: '16 to 24', age_range: '16..24' }]

which looks neater but I have no idea if I have written gibberish as I don't know how to extract the name when the age years matches.

Can someone point me in the right direction?

Answer 1

Now that you have an map of age names and ranges (note I used range , not string as a value of age_range ), you want to search the age_ranges array of hashes for such, which value of age_range includes the age:

def age_ranges
  [
    { name: 'child',    age_range: 0..15 },
    { name: '16 to 24', age_range: 16..24 }
  ]
end

def find_age(age)
  age_ranges.find { |hash| hash[:age_range].include?(age) }[:name]
end

find_age(12)
#=> "child"
find_age(17)
#=> "16 to 24"

Note, that [:name] will fail if find returns nil (meaning, no matches found).

To overcome it either add an infinite range as a last one in the array (I'd prefer this one, because it is simpler):

def age_ranges
  [
    { name: 'child',    age_range: 0..15 },
    { name: '16 to 24', age_range: 16..24 },
    { name: 'unknown',  age_range: 25..Float::INFINITY }
  ]
end

Or handle it while fetching the age in the find_age method:

def find_age(age)
  age_ranges.each_with_object('unknown') { |hash, _| break hash[:name] if hash[:age_range].include?(age) }
end

Also, make sure to handle the negative numbers passed to the method (since age_ranges do not cover negatives):

def find_age(age)
  return 'Age can not be less than 0' if age.negative?
  age_ranges.find { |hash| hash[:age_range].include?(age) }[:name]
end

PS After all these "note/make sure" I want to say that @mudasobwa's answer is the simplest way to go about it :)

Answer 2

Use Range#=== triple equal directly, as it is supposed to be used:

case age_years
when 0..15 then 'child'
when 16..24 then '16 to 24'
when 25..34 then '25 to 34'
when 35..44 then '35 to 44'
when 45..54 then '45 to 54'
when 55..64 then '55 to 64'
when 64..Float::INFINITY then 'really old' # or when 64.method(:<).to_proc
else 'unknown'
end

---

To make case to accept floats, one should use triple-dot ranges:

case age_years
when 0...16 then 'child'
when 16...25 then '16 to 24'
when 25...35 then '25 to 34'
when 35...45 then '35 to 44'
when 45...55 then '45 to 54'
when 55...64 then '55 to 64'
when 64..Float::INFINITY then 'really old' # or when 64.method(:<).to_proc
else 'unknown'
end

Answer 3

Here's how I'd do it, to avoid code repetition between 16 and 64 :

def age_range(age, offset=4, span=10, lowest_age=16)
  i    = ((age-offset-1)/span).to_i
  min  = [i*span+offset+1, lowest_age].max
  max  = (i+1)*span + offset
  "#{min} to #{max}"
end

def age_description(age)
  case age
    when 0...16 then 'child'
    when 16..64 then age_range(age)
    when 64..999 then 'really old'
    else 'unknown'
  end
end

(0..99).each do |age|
  puts "%s (%s)" % [age_description(age), age]
end

It outputs :

child (0)
child (1)
child (2)
child (3)
child (4)
child (5)
child (6)
child (7)
child (8)
child (9)
child (10)
child (11)
child (12)
child (13)
child (14)
child (15)
16 to 24 (16)
16 to 24 (17)
16 to 24 (18)
16 to 24 (19)
16 to 24 (20)
16 to 24 (21)
16 to 24 (22)
16 to 24 (23)
16 to 24 (24)
25 to 34 (25)
25 to 34 (26)
25 to 34 (27)
25 to 34 (28)
25 to 34 (29)
25 to 34 (30)
25 to 34 (31)
25 to 34 (32)
25 to 34 (33)
25 to 34 (34)
35 to 44 (35)
...

As a bonus, it also works with Floats (eg 15.9 and 16.0).