Sometime I saw you wrote regex =~ string, while sometime you wrote
string =~ regex.
What's their difference and what's the recommended way? Thanks.

Jenn.

On 01/04/2010 10:27 AM, Ruby Newbee wrote:
> Sometime I saw you wrote regex =~ string, while sometime you wrote
> string =~ regex.
> What's their difference and what's the recommended way? Thanks.

The first version invokes method Regexp#=~ and the second version 
invokes String#=~ - which happen to do roughly the same although I 
believe the second one to be a tad slower.  I personally prefer the 
first form because of the speed difference and regular expression 
matching is rather an operation of Regexp than of String.

Kind regards

	robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

Robert Klemme wrote:
> On 01/04/2010 10:27 AM, Ruby Newbee wrote:
>> Sometime I saw you wrote regex =~ string, while sometime you wrote
>> string =~ regex.
>> What's their difference and what's the recommended way? Thanks.
> 
> The first version invokes method Regexp#=~ and the second version
> invokes String#=~ - which happen to do roughly the same although I
> believe the second one to be a tad slower.  I personally prefer the
> first form because of the speed difference and regular expression
> matching is rather an operation of Regexp than of String.

Interesting.  Whereas I prefer the second because I think
mystring =~ /foo/
is syntactically analogous to
mystring == 'foo'

> 
> Kind regards
> 
>   robert

Best,
-- 
Marnen Laibow-Koser
http://www.marnen.org
marnen@marnen.org
-- 
Posted via http://www.ruby-forum.com/.

On Mon, Jan 4, 2010 at 6:20 AM, Robert Klemme
<shortcutter@googlemail.com> wrote:

> The first version invokes method Regexp#=3D~ and the second version invok=
es
> String#=3D~ - which happen to do roughly the same although I believe the
> second one to be a tad slower. =A0I personally prefer the first form beca=
use
> of the speed difference and regular expression matching is rather an
> operation of Regexp than of String.

Very technically speaking, calling the Regexp#=3D~ will be
microscopically faster because it avoids a tiny bit of C code that
gets executed when calling the String#=3D~ version. In practice though,
the difference is so small as to be invisible against the noise of the
rest of the system.

String#=3D~ just has a little sugar built in.

If it's passed a Regexp, then it just calls the C function underlying Regex=
p#=3D~.
If it is passed a String, it complains.
If it is passed anything else, it tries to call #=3D~ on what it was
passed, passing itself as the argument.  This lets one build custom
matching classes that Strings can use with the =3D~ syntax.


Kirk Haines