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.
···
--
Posted via http://www.ruby-forum.com/\.
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
···
On Friday 01 August 2008, Milo Thurston wrote:
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.
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
···
2008/8/1 Milo Thurston <knirirr@gmail.com>:
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?
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 Thurston <knirirr@gmail.com> wrote:
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.
--
Posted via http://www.ruby-forum.com/\.
--
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
Just one additional remark: if your Arrays grow large you might
benefit from converting them to Set which has faster lookups.
Kind regards
robert
···
2008/8/1 Milo Thurston <knirirr@gmail.com>:
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.
--
use.inject do |as, often| as.you_can - without end
Stefano Crocco wrote:
arr1.select{|y| !arr2.grep(y).empty?}
I hope this helps
Yes, that does the job nicely. Thanks!
···
--
Posted via http://www.ruby-forum.com/\.
Hi --
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?
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
···
On Fri, 1 Aug 2008, Stefan Lang wrote:
2008/8/1 Milo Thurston <knirirr@gmail.com>:
--
Rails training from David A. Black and Ruby Power and Light:
* Advancing With Rails August 18-21 Edison, NJ
* Co-taught by D.A. Black and Erik Kastner
See http://www.rubypal.com for details and updates!
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
···
On Friday 01 August 2008, shadowfirebird@gmail.com 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.
Robert Klemme 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.
···
--
Posted via http://www.ruby-forum.com/\.
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
···
--
Jabber: sepp2k@jabber.org
ICQ: 205544826
Given Milo's use case, he's only using strings, so it doesn't
matter. include? is clearer in this case, IMO.
Stefan
···
2008/8/1 David A. Black <dblack@rubypal.com>:
Hi --
On Fri, 1 Aug 2008, Stefan Lang wrote:
2008/8/1 Milo Thurston <knirirr@gmail.com>:
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?
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
I didn't say they were the same; I said that grep() didn't work in
that context, but include?() did. 
···
On 8/1/08, Stefano Crocco <stefano.crocco@alice.it> wrote:
On Friday 01 August 2008, shadowfirebird@gmail.com 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
--
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
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. 
Cheers
robert
···
2008/8/1 Milo Thurston <knirirr@gmail.com>:
Robert Klemme 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?
--
use.inject do |as, often| as.you_can - without end