Checking an array for an item

[Sam Phoneix]

How come this code doesn't return "true" for the following?

x = [1,2,3]

puts(x.include?(Fixnum))



Thanks

 

[David Chelimsky]

How come this code doesn't return "true" for the following?

x = [1,2,3]

puts(x.include?(Fixnum))

It uses ==, not ===.

$ri Enumerable#include?

---------------------------------------------------- Enumerable#include?
enum.include?(obj) => true or false
enum.member?(obj) => true or false

 

[Tim Hunter]

How come this code doesn't return "true" for the following?

x = [1,2,3]

puts(x.include?(Fixnum))



Thanks

Because include? doesn't test the class of an object, it tests for the
presence of an object. The ri command is your friend here:

$ ri Array.include?
--------------------------------------------------------- Array#include?
array.include?(obj) -> true or false
------------------------------------------------------------------------
Returns true if the given object is present in self (that is, if
any object == anObject), false otherwise.

a = [ "a", "b", "c" ]
a.include?("b") #=> true
a.include?("z") #=> false

 

[Thomas Wieczorek]

How come this code doesn't return "true" for the following?

x = [1,2,3]

puts(x.include?(Fixnum))

You could try something like:

class Array
def include_class?(klass)
if self.detect { |x| x.class == klass }
return true
else
return false
end
end
end

 

[Giles Bowkett]

How come this code doesn't return "true" for the following?

x = [1,2,3]

puts(x.include?(Fixnum))

In addition to the reasons other people mentioned, Fixnum is an actual
object in Ruby. You could put it in an array if you wanted:

classes_that_start_with_f = [Fixnum, File, FizzBuzz]

classes_that_start_with_f.include?(Fixnum) # returns true

That's why it doesn't work like you expect; because #include?(Fixnum)
is for finding the actual Fixnum class object.

To get what you want the best approach is map, or one of a few
functions similar to map, such as collect or inject:

[1,2,3].map {|number| number.is_a? Fixnum} => [true, true, true]
[1,2,3,"asdfasdfasdf"].map {|number| number.is_a? Fixnum} => [true, true, true, false]
[1,2,3,"asdfasdfasdf"].map {|number| number.is_a? Fixnum}.include?(true)

=> true

class Array
def include_class?(klass)
map do |thing|
thing.is_a? klass
end.include?(true)
end
end

[1,2,3].include_class?(Fixnum)

=> true

Thomas Wieczorek's solution is good too. #detect is a cousin of #map.

--
Giles Bowkett

Podcast: http://hollywoodgrit.blogspot.com
Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org
Tumblelog: http://giles.tumblr.com

 

[Sam Phoneix]

[1,2,3].map {|number| number.is_a? Fixnum}

=> [true, true, true]

Thanks

 

[Rick DeNatale]

How come this code doesn't return "true" for the following?

x = [1,2,3]

puts(x.include?(Fixnum))

To get what you want the best approach is map, or one of a few
functions similar to map, such as collect or inject:

Well, if you're trying to find out if the array contains at least one
Fixnum then this isn't really the best way. Instead I'd use

x.any? {|obj| Fixnum === obj }

which returns a single boolean, and only looks at as many elements of
the array as it needs to.

Alternately one could use

x.find {|obj| Fixnum === obj }

which will return either the first Fixnum in the array, or nil if
their isn't one, which can be used the same way as a boolean value in
almost all cases.

 

[Giles Bowkett]

Well, if you're trying to find out if the array contains at least one

Fixnum then this isn't really the best way. Instead I'd use

x.any? {|obj| Fixnum === obj }

which returns a single boolean, and only looks at as many elements of
the array as it needs to.

Yeah, I think that's the best way too.

--
Giles Bowkett

Podcast: http://hollywoodgrit.blogspot.com
Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org
Tumblelog: http://giles.tumblr.com

 

[Giles Bowkett]

Well, if you're trying to find out if the array contains at least one

Yeah, I think that's the best way too.

Wait, no I don't. I'd say switch === with .is_a? and that would be the
best way. More readable, and allows you to avoid the question "what is
===?"

Generally I think you should avoid === unless implementing it on new
classes for the sake of case/switch statements.

--
Giles Bowkett

Podcast: http://hollywoodgrit.blogspot.com
Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org
Tumblelog: http://giles.tumblr.com