Enumerable#find return index

[Tod McIntyre]

This is quite embarassing because I Don't consider myself a poor
programmer, but I just started looking at ruby the other day.

Blocks seem to be a good way to iterate through something to search for
an entry for instance. It's easy to return the object that meets
certain criteria using blocks but I'm finding it hard to return the
index of that particular object in, say, an array.

as an example

arr=[4,1,3,7]
arr.find { |f| f==someval }
will return the val within arr that matches someval, which doesn't
really help me because I already have someval

How do I actually return the index in arr to the first match of someval.

so if someval == 3, my block would return 2, for the above example

 

[Daniel Baird]

------=_Part_4982_22864780.1142396065777
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

try
arr.index(3)

;Daniel

This is quite embarassing because I Don't consider myself a poor
programmer, but I just started looking at ruby the other day.

Blocks seem to be a good way to iterate through something to search for
an entry for instance. It's easy to return the object that meets
certain criteria using blocks but I'm finding it hard to return the
index of that particular object in, say, an array.

as an example

arr=3D[4,1,3,7]
arr.find { |f| f=3D=3Dsomeval }
will return the val within arr that matches someval, which doesn't
really help me because I already have someval

How do I actually return the index in arr to the first match of someval.

so if someval =3D=3D 3, my block would return 2, for the above example

--
Daniel Baird
http://danielbaird.com (TiddlyW;nks! :: Whiteboard Koala :: Blog :: Things
That Suck)
[[My webhost uptime is ~ 92%.. if no answer pls call again later!]]

------=_Part_4982_22864780.1142396065777--

 

[Ross Bamford]

This is quite embarassing because I Don't consider myself a poor
programmer, but I just started looking at ruby the other day.

Blocks seem to be a good way to iterate through something to search for
an entry for instance. It's easy to return the object that meets
certain criteria using blocks but I'm finding it hard to return the
index of that particular object in, say, an array.

Check out this thread:

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/178495

(The upshot is that in CVS, 1.9 now allows a block to #index to specify
what is to be found).

In the meantime, the current #index should do the job for most cases
(e.g. the example you showed):

a = [:a,:b,:c,:d,:e]
# => [:a, :b, :c, :d, :e]

a.indexa)
# => 0

a.indexe)
# => 4

 

[Robert Klemme]

This is quite embarassing because I Don't consider myself a poor
programmer, but I just started looking at ruby the other day.

Blocks seem to be a good way to iterate through something to search for
an entry for instance. It's easy to return the object that meets
certain criteria using blocks but I'm finding it hard to return the
index of that particular object in, say, an array.

as an example

arr=[4,1,3,7]
arr.find { |f| f==someval }
will return the val within arr that matches someval, which doesn't
really help me because I already have someval

Yeah, but this is just a special case. With a block you can employ
arbitrary selection criteria - not just ==.

How do I actually return the index in arr to the first match of someval.

so if someval == 3, my block would return 2, for the above example

As Ross and Daniel have pointed out already, use #index.

Kind regards

robert

 

[Tod McIntyre]

arr=[4,1,3,7]
arr.find { |f| f==someval }
will return the val within arr that matches someval, which doesn't
really help me because I already have someval

Yeah, but this is just a special case. With a block you can employ
arbitrary selection criteria - not just ==.

How do I actually return the index in arr to the first match of someval.

so if someval == 3, my block would return 2, for the above example

As Ross and Daniel have pointed out already, use #index.

Kind regards

robert

Once again I knew this would be a simple answer!! I thank you for your
quick responses. Obviously I should be reading the api more thoroughly
before posting.

 

[Robert Klemme]

arr=[4,1,3,7]
arr.find { |f| f==someval }
will return the val within arr that matches someval, which doesn't
really help me because I already have someval

Yeah, but this is just a special case. With a block you can employ
arbitrary selection criteria - not just ==.

How do I actually return the index in arr to the first match of
someval.

so if someval == 3, my block would return 2, for the above example

As Ross and Daniel have pointed out already, use #index.

Kind regards

robert

Once again I knew this would be a simple answer!! I thank you for your
quick responses. Obviously I should be reading the api more thoroughly
before posting.

Ah, don't bother. The API of the standard lib has it's humps and bumps
(for example not fully consistent usage of ! for destructive methods etc.)
so it's normal to fall into one or the other pit initially.

Kind regards

robert

 

[dblack]

Hi --

Ah, don't bother. The API of the standard lib has it's humps and bumps (for
example not fully consistent usage of ! for destructive methods etc.) so it's
normal to fall into one or the other pit initially.

I have to leap to the defense of ! It really is consistent:

* given meth and meth!, meth! is the more "dangerous" version
* "dangerous" often means "receiver-changing", but definitely
does not have to mean that
* methods whose names already imply receiver-changing don't
have a ! because they don't need one, and also ! methods
only come in pairs with a non-! equivalent. (It would be
hard to imagine what "Replace the contents of this string
object, but without changing the object" would mean....)

"Implying receiver-changing" is of course in the eyes of Matz But
while there are judgements, I don't think there's any inconsistency.


David

--
David A. Black ([email protected])
Ruby Power and Light, LLC (http://www.rubypowerandlight.com)

"Ruby for Rails" chapters now available
from Manning Early Access Program! http://www.manning.com/books/black

 

[Robert Klemme]

Hi --



I have to leap to the defense of ! It really is consistent:

* given meth and meth!, meth! is the more "dangerous" version
* "dangerous" often means "receiver-changing", but definitely
does not have to mean that

Although it's certainly the most common use of "!".

* methods whose names already imply receiver-changing don't
have a ! because they don't need one, and also ! methods
only come in pairs with a non-! equivalent. (It would be
hard to imagine what "Replace the contents of this string
object, but without changing the object" would mean....)

"Implying receiver-changing" is of course in the eyes of Matz But
while there are judgements, I don't think there's any inconsistency.

Um, yes. I should print this out and place it in front of my monitor.
Somehow I keep forgetting this definition - must be some old newsgroup
thread having anchored deep in my subconscious.

Thanks for putting that straight!

Kind regards

robert