Iterate through hashes to find values predefined in an array

Question

I have an array with hashes:

test  = [
  {"type"=>1337, "age"=>12, "name"=>"Eric Johnson"},
  {"type"=>1338, "age"=>18, "name"=>"John Doe"},
  {"type"=>1339, "age"=>22, "name"=>"Carl Adley"},
  {"type"=>1340, "age"=>25, "name"=>"Anna Brent"}
]

I am interested in getting all the hashes where the name key equals to a value that can be found in an array:

get_hash_by_name = ["John Doe","Anna Brent"]

Which would end up in the following:

# test_sorted = would be:
# {"type"=>1338, "age"=>18, "name"=>"John Doe"}
# {"type"=>1340, "age"=>25, "name"=>"Anna Brent"}

I probably have to iterate with test.each somehow, but I still trying to get a grasp of Ruby. Happy for all help!

Answer 1

Here's something to meditate on:

Iterating over an array to find something is slow, even if it's a sorted array. Computer languages have various structures we can use to improve the speed of lookups, and in Ruby Hash is usually a good starting point. Where an Array is like reading from a sequential file, a Hash is like reading from a random-access file, we can jump right to the record we need.

Starting with your test array-of-hashes:

test  = [
  {'type'=>1337, 'age'=>12, 'name'=>'Eric Johnson'},
  {'type'=>1338, 'age'=>18, 'name'=>'John Doe'},
  {'type'=>1339, 'age'=>22, 'name'=>'Carl Adley'},
  {'type'=>1340, 'age'=>25, 'name'=>'Anna Brent'},
  {'type'=>1341, 'age'=>13, 'name'=>'Eric Johnson'},
]

Notice that I added an additional "Eric Johnson" record. I'll get to that later.

I'd create a hash that mapped the array of hashes to a regular hash where the key of each pair is a unique value. The 'type' key/value pair appears to fit that need well:

test_by_types = test.map { |h| [
  h['type'], h]
}.to_h
# => {1337=>{"type"=>1337, "age"=>12, "name"=>"Eric Johnson"},
#     1338=>{"type"=>1338, "age"=>18, "name"=>"John Doe"},
#     1339=>{"type"=>1339, "age"=>22, "name"=>"Carl Adley"},
#     1340=>{"type"=>1340, "age"=>25, "name"=>"Anna Brent"},
#     1341=>{"type"=>1341, "age"=>13, "name"=>"Eric Johnson"}}

Now test_by_types is a hash using the type value to point to the original hash.

If I create a similar hash based on names, where each name, unique or not, points to the type values, I can do fast lookups:

test_by_names = test.each_with_object(
                  Hash.new { |h, k| h[k] = [] }
                ) { |e, h|
                    h[e['name']] << e['type']
                  }.to_h
# => {"Eric Johnson"=>[1337, 1341],
#     "John Doe"=>[1338],
#     "Carl Adley"=>[1339],
#     "Anna Brent"=>[1340]}

Notice that "Eric Johnson" points to two records.

Now, here's how we look up things:

get_hash_by_name = ['John Doe', 'Anna Brent']

test_by_names.values_at(*get_hash_by_name).flatten
# => [1338, 1340]

In one quick lookup Ruby returned the matching types by looking up the names.

We can take that output and grab the original hashes:

test_by_types.values_at(*test_by_names.values_at(*get_hash_by_name).flatten)
# => [{"type"=>1338, "age"=>18, "name"=>"John Doe"},
#     {"type"=>1340, "age"=>25, "name"=>"Anna Brent"}]

Because this is running against hashes, it's fast. The hashes can be BIG and it'll still run very fast.

Back to "Eric Johnson"...

When dealing with the names of people it's likely to get collisions of the names, which is why test_by_names allows multiple type values, so with one lookup all the matching records can be retrieved:

test_by_names.values_at('Eric Johnson').flatten
# => [1337, 1341]

test_by_types.values_at(*test_by_names.values_at('Eric Johnson').flatten)
# => [{"type"=>1337, "age"=>12, "name"=>"Eric Johnson"},
#     {"type"=>1341, "age"=>13, "name"=>"Eric Johnson"}]

This will be a lot to chew on if you're new to Ruby, but the Ruby documentation covers it all, so dig through the Hash, Array and Enumerable class documentation.

Also, *, AKA "splat", explodes the array elements from the enclosing array into separate parameters suitable for passing into a method. I can't remember where that's documented.

If you're familiar with database design this will look very familiar, because it's similar to how we do database lookups.

The point of all of this is that it's really important to consider how you're going to store your data when you first ingest it into your program. Do it wrong and you'll jump through major hoops trying to do useful things with it. Do it right and the code and data will flow through very easily, and you'll be able to massage/extract/combine the data easily.

Said differently, Arrays are containers useful for holding things you want to access sequentially, such as jobs you want to print, sites you need to access in order, files you want to delete in a specific order, but they're lousy when you want to lookup and work with a record randomly.

Knowing which container is appropriate is important, and for this particular task, it appears that an array of hashes isn't appropriate, since there's no fast way of accessing specific ones.

And that's why I made my comment above asking what you were trying to accomplish in the first place. See "What is the XY problem?" and "XyProblem" for more about that particular question.

Answer 2

You can use select and include? so

test.select {|object| get_hash_by_name.include? object['name'] }

…should do the job.