Using array.select with grep

Ruby
1

Using irb I set up the following arrays:

arr1
=> [“one”, “two”, “three”]

arr2
=> [“two”, “three”, “four”]

I would expect to be able to collect the elements of arr1 that are also
in arr2 using select and grep, i.e.

arr1.select { |y| arr2.grep(y) }
=> [“two”, “three”]

But what I actually get is:

arr1.select { |y| arr2.grep(y) }
=> [“one”, “two”, “three”]

What is my error or misunderstanding here?

Before anyone asks, I’m not using the array intersecttion (arr1 & arr2)
because I am testing this expression prior to using it to find objects
in an array (arr1) where an object parameter is found in an array of
strings (arr2), e.g. to find all people from the array of people objects
whose first name is in a list of names:

arr1.select { |y| arr2.grep(y.string_of_interest) }

Although if there’s a better way of doing that I’d be interested to
know.

2

On Friday 01 August 2008, Milo T. wrote:

in arr2 using select and grep, i.e.
What is my error or misunderstanding here?
know.
Array#grep returns an array with the matches, which means it returns an
empty
array, which evaluates to true, if there’s no match. You can do what you
want
with

arr1.select{|y| !arr2.grep(y).empty?}

I hope this helps

Stefano

1 Like
3

Stefano C. wrote:

arr1.select{|y| !arr2.grep(y).empty?}

I hope this helps

Yes, that does the job nicely. Thanks!

4

2008/8/1 Milo T. [email protected]:

arr1.select { |y| arr2.grep(y) }
=> [“two”, “three”]

But what I actually get is:

arr1.select { |y| arr2.grep(y) }
=> [“one”, “two”, “three”]

What is my error or misunderstanding here?

Because grep returns an empty array when it can’t find the
given string. And an empty array (everything except false and nil,
actually) is true in Ruby. Use #include? instead:

arr1.select { |y| arr2.include?(y) }

Stefan

5

Hi –

On Fri, 1 Aug 2008, Stefan L. wrote:

Because grep returns an empty array when it can’t find the
given string. And an empty array (everything except false and nil,
actually) is true in Ruby. Use #include? instead:

arr1.select { |y| arr2.include?(y) }

No, that’s not the same.

array = %w{ one two three }
=> [“one”, “two”, “three”]

array.grep(/e/)
=> [“one”, “three”]

array.include?(“e”)
=> false

David

6

Someone please correct me if I’m barking up the wrong tree, but the
block in select wants a function that returns a logical, and grep
isn’t one.

It seems to work if you use include?(), instead, though.

irb(main):004:0> a1 = [ “one”, “two”, “three” ]
=> [“one”, “two”, “three”]
irb(main):005:0> a2 = [“two”, “three”, “four” ]
=> [“two”, “three”, “four”]
irb(main):006:0> a1.find_all{|x| a2.grep(x)}
=> [“one”, “two”, “three”]
irb(main):007:0> a1.find_all{|x| a2.grep(x) == true}
=> []
irb(main):007:0> a1.find_all{|x| a2.include?(x)}
=> [“two”, “three”]

On 8/1/08, Milo T. [email protected] wrote:

arr1.select { |y| arr2.grep(y) }
because I am testing this expression prior to using it to find objects

–
Me, I imagine places that I have never seen / The colored lights in
fountains, blue and green / And I imagine places that I will never go
/ Behind these clouds that hang here dark and low
But it’s there when I’m holding you / There when I’m sleeping too /
There when there’s nothing left of me / Hanging out behind the
burned-out factories / Out of reach but leading me / Into the
beautiful sea

7

2008/8/1 Milo T. [email protected]:

Before anyone asks, I’m not using the array intersecttion (arr1 & arr2)
because I am testing this expression prior to using it to find objects
in an array (arr1) where an object parameter is found in an array of
strings (arr2), e.g. to find all people from the array of people objects
whose first name is in a list of names:

arr1.select { |y| arr2.grep(y.string_of_interest) }

Although if there’s a better way of doing that I’d be interested to
know.

Just one additional remark: if your Arrays grow large you might
benefit from converting them to Set which has faster lookups.

Kind regards

robert

8

Hi –

On Fri, 1 Aug 2008, [email protected] wrote:

irb(main):006:0> a1.find_all{|x| a2.grep(x)}
=> [“one”, “two”, “three”]
irb(main):007:0> a1.find_all{|x| a2.grep(x) == true}
=> []
irb(main):007:0> a1.find_all{|x| a2.include?(x)}
=> [“two”, “three”]

See my previous post. #grep and #include? are not the same.

David

9

David A. Black wrote:

No, that’s not the same.

array = %w{ one two three }

=> [“one”, “two”, “three”]

array.grep(/e/)

=> [“one”, “three”]

array.grep(“e”)
=> []

So since the code in question only deals with strings and not regexen,
using
include? does indeed have the same result as checking whether grep
returned
an empty array.

HTH,
Sebastian

10

On Friday 01 August 2008, [email protected] wrote:

Someone please correct me if I’m barking up the wrong tree, but the
block in select wants a function that returns a logical, and grep
isn’t one.

Everything in ruby can be used as a boolean value, so technically you
can use
it. The only problem is that the value grep returns is always a ‘true’
value.

Stefano

11

2008/8/1 David A. Black [email protected]:

=> [“one”, “two”, “three”]
=> [“two”, “three”]
given string. And an empty array (everything except false and nil,
actually) is true in Ruby. Use #include? instead:

arr1.select { |y| arr2.include?(y) }

No, that’s not the same.

=> false
Given Milo’s use case, he’s only using strings, so it doesn’t
matter. include? is clearer in this case, IMO.

Stefan

12

I didn’t say they were the same; I said that grep() didn’t work in
that context, but include?() did. :smiley:

On 8/1/08, Stefano C. [email protected] wrote:

Stefano

–
Me, I imagine places that I have never seen / The colored lights in
fountains, blue and green / And I imagine places that I will never go
/ Behind these clouds that hang here dark and low
But it’s there when I’m holding you / There when I’m sleeping too /
There when there’s nothing left of me / Hanging out behind the
burned-out factories / Out of reach but leading me / Into the
beautiful sea

13

2008/8/1 Milo T. [email protected]:

final = set + array

…OK, or do I need to do

final = set.to_a + array

…or even something else?

It all depends on what you need. If you need Set semantics, use Sets.
If you need lists (maintain a particular order) use Arrays. It all
depends. You can easily convert via #to_a and #to_set. But if you are
finding yourself converting all the time chances are that you are
doing something wrong. :slight_smile:

Cheers

robert

14

Robert K. wrote:

Just one additional remark: if your Arrays grow large you might
benefit from converting them to Set which has faster lookups.

You’re right - if I use a Set then the lookup is astonishingly fast by
comparison.
Is it OK to combine arrays and sets, though? For example, I have a Set
of things I need to grep and an array I don’t, and these need to be
combined as an array. So, is:

final = set + array

…OK, or do I need to do

final = set.to_a + array

…or even something else?
Thanks.

15

Hi –

On Fri, 1 Aug 2008, Sebastian H. wrote:

array.grep(“e”)
=> []

So since the code in question only deals with strings and not regexen, using
include? does indeed have the same result as checking whether grep returned
an empty array.

Right – I un-stringed them by mistake.

David

16

Hi –

On Fri, 1 Aug 2008, [email protected] wrote:

I didn’t say they were the same; I said that grep() didn’t work in
that context, but include?() did. :smiley:

I think that was in reply to me, and it’s true that I was using “not
the same” to mean “not interchangeable” – but in fact I was all wrong
anyway because I rewrote the OP’s code in my head to use regexes
instead of strings.

David