A more elegant way to map an array of hashes in ruby

Question

I've got an array of hashes: hashes = [{field: 'one'}, {field: 'two'}]

And I want to get the list of fields from it: ['one', 'two']

hashes.map(&:field) doesn't work, clearly, and hashes.map { |hash| hash[field] } feels a bit clunky to me.

Is there a more elegant way?

EDIT: I should clarify, I do only want the value of 'fields' in my response.

So, hashes = [{field: 'one', another: 'three'}, {field: 'two'}].do_the_thing should be ['one', 'two']

What you've come up with seams pretty reasonable. What feels clunky about it to you? — mikej
– mikej, Commented Nov 12, 2014 at 23:36
Could just be that I'm being picky, but it doesn't read in English very well, and is a little bit of an eyesore to chain. Just wondering if there's someone out there who has come up with something more clever. It's ruby, there must be more than one way, right? :) — gdpelican
– gdpelican, Commented Nov 12, 2014 at 23:39
It's only a slight improvement, but if you want something that reads a bit more nicely you could use hashes.collect - collect is an aliias for map and fits here - collecting the fields from each hash. — mikej
– mikej, Commented Nov 12, 2014 at 23:40
Your hashes.map { |hash| hash[:field] } is not just OK, it's the perfect way to do this. Note you wrote hash[field]; you need :field. — Cary Swoveland
– Cary Swoveland, Commented Nov 13, 2014 at 2:30

Kimball · Accepted Answer · 2014-11-13 00:22:41Z

3

Perhaps something like the following would be more pleasing to the eye:

hashes = [{field: 'one', another: 'three'}, {field: 'two'}] fields = lambda { |hash| hash[:field] } hashes.collect(&fields)

answered Nov 13, 2014 at 0:22

Kimball

1,28111 silver badges17 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

the Tin Man Over a year ago

It's superficially more pleasing when glancing at it, however, if someone was maintaining the code, they'd have to backtrack to find what fields was, discover it was a lambda, so then they'd understand what was going on. There's not enough noise being covered by the use of the lambda to make up for the backtracking.

Kimball Over a year ago

@theTinMan I don't disagree: while tempting, I'd try and avoid using it outside of a small project! However, OP was after something more elegant, and later clarified to something that reads better in English, which it does.

the Tin Man · Accepted Answer · 2014-11-12 23:53:40Z

1

Look at flat_map:

hashes = [{field: 'one'}, {field: 'two'}] hashes.flat_map(&:values) # => ["one", "two"]

answered Nov 12, 2014 at 23:53

the Tin Man

161k44 gold badges222 silver badges308 bronze badges

2 Comments

gdpelican Over a year ago

I probably should have been clearer; I do only want the values for 'field' in my result; this wouldn't work for say [{field: 'one', another: 'whoops!'}, {field: 'two'}]

the Tin Man Over a year ago

Yes, it's pretty important to correctly/completely describe the problem otherwise people thrash around trying to provide help.

Joseph · Accepted Answer · 2014-11-12 23:59:19Z

Not sure if this is any better, but perhaps it reads a little more clearly:

hashes.map { |hash| hash.values }.flatten

Ivan G. · Accepted Answer · 2024-02-29 15:15:36Z

If you are using Rails, ActiveSupport defines Enumerable#pluck for this:

hashes = [{field: 'one'}, {field: 'two'}] hashes.pluck(:field) # => ["one", "two"]

Collectives™ on Stack Overflow

A more elegant way to map an array of hashes in ruby

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Related