[Regex] Alternative for look behind

Ruby
1

Hi all,

I need to replace all ‘-’ characters at the beginning of a sequence
(string) with 'X’s (until a character appears that is not ‘-’).

E.g.

-------abcde-gh----

should be changed into

XXXXXXXabcde-gh----

If Ruby would support look behind in Regular Expressions, I could
probably do something like this:

sequence.gsub(/(?=^-*)-/, “X”)

But unfortunately Ruby does not support look behind.

Of course, I could count the number of ‘-’ at the beginning of the
sequence:

x = sequence[/-*/].length

And then I could replace the first x characters with “X”. But I don’t
like that solution, it feels clumsy. Is there an elegant way of doing
this?

Thanks in advance & best regards!
Janus

2

From: Janus B. [mailto:[email protected]]

I need to replace all ‘-’ characters at the beginning of a sequence

(string) with 'X’s (until a character appears that is not ‘-’).

E.g.

-------abcde-gh----

should be changed into

XXXXXXXabcde-gh----

my initial reaction was not a look behind,

irb(main):062:0> s.gsub(/(^-*)/){$1.tr(“-”,“X”)}
=> “XXXXXXXabcde-gh----”

the second was to use oniguruma,

re=Oniguruma::ORegexp.new( ‘(?^-)(?.)’ )
#=> /(?^-)(?.)/
s
#=> “-------abcde-gh----”
m=re.match s
#=> #MatchData:0x2c51b7c
m[:dashes]
#=> “-------”
m[:after]
#=> “abcde-gh----”
…

nice naming feature, but overkill for this case. ymmv.

kind regards -botp

3

On 16.08.2008 03:56, Janus B. wrote:

If Ruby would support look behind in Regular Expressions, I could
probably do something like this:

sequence.gsub(/(?=^-*)-/, “X”)

But unfortunately Ruby does not support look behind.

It does - in 1.9. But:

irb(main):001:0> sequence = ‘-------abcde-gh----’
=> “-------abcde-gh----”
irb(main):002:0> sequence.gsub(/(?=^-*)-/, “X”)
=> “X------abcde-gh----”
irb(main):003:0>

I am not sure lookbehind is the proper means here. After all you want
to replace a sequence of dashes before a particular sequence
(according to your description above). So you would rather use
lookforward, wouldn’t you?

irb(main):003:0> sequence.gsub(/-(?=-*abcde)/, “X”)
=> “XXXXXXXabcde-gh----”

Granted, it does not anchor.

Here’s another solution

irb(main):008:0> s = sequence.dup
=> “-------abcde-gh----”
irb(main):009:0> while s.sub! /^(X*)-/, ‘\1X’; end
=> nil
irb(main):010:0> s
=> “XXXXXXXabcde-gh----”

But I’d rather use Pena’s solution or another block form

irb(main):011:0> sequence.sub(/^-/) {|m| “X” * m.length}
=> “XXXXXXXabcde-gh----”
irb(main):012:0> sequence.sub(/^-/) {|m| m.tr ‘-’,‘X’}
=> “XXXXXXXabcde-gh----”

Kind regards

robert

4

On 16.08.2008 18:46, Janus B. wrote:

Thanks to both of you! I like your solutions. I’m a fan of one liners…

You’re welcome!

write the equivalent replacing characters at the end of the string using
look ahead it works just fine:

irb(main):001:0> sequence = ‘-------abcde-gh----’
=> “-------abcde-gh----”
irb(main):002:0> sequence.gsub(/-(?=-*$)/, “X”)
=> “-------abcde-ghXXXX”

I believe the reason is that with lookbehind the regular expression
needs start matching at the same location (the beginning of the
sequence) multiple times. Even though lookbehind does not consume
characters I believe RX implementations prohibit matching at the same
location over and over again - partly for efficiency reasons but also to
avoid endless loops. The lookforward solution with replacement at the
end of the sequence moves the start position of the match one character
forward for every match. That’s how I explain myself why the straight
forward lookbehind does not work.

There’s another reason, why lookbehind won’t work: the docs state

“Subexp of look-behind must be fixed character length.”

See サービス終了のお知らせ

At the moment I cannot think of a solution with lookbehind that would
avoid these issues because all lookbehinds must start matching at the
beginning of the sequence in order to fulfill your requirement that the
initial sequence must be replaced.

The problem with look ahead/forward is, that I have to make sure the
sequence starts with “-”. Otherwise something like this could happen:

irb(main):003:0> sequence = ‘abcde-gh----’
=> “abcde-gh----”
irb(main):004:0> sequence.gsub(/-(?=-*[abcdefgh])/, “X”)
=> “abcdeXgh----”

Well, this won’t happen if the sequence “abcde” is known to appear only
after an initial sequence of dashes. (Note the difference between your
lookforward solution and mine: you created a character class while I
just matched the plain sequence). But of course it’s not the same as
“replace initial portion of dashes”.

I can recommend “Mastering regular expressions” if you want to dive
deeper into this: it’s pretty well written and does only have as much
theory of regular languages as necessary but explains very well
differences between regular expression implementations and also
considers efficiency aspects.

Kind regards

robert

5

Thanks to both of you! I like your solutions. I’m a fan of one liners…

I ended up using this one, as it has the best readability for a novice
programmer like me imho:

Robert K. wrote:

irb(main):011:0> sequence.sub(/^-*/) {|m| “X” * m.length}
=> “XXXXXXXabcde-gh----”

Robert K. wrote:

It does - in 1.9. But:

irb(main):001:0> sequence = ‘-------abcde-gh----’
=> “-------abcde-gh----”
irb(main):002:0> sequence.gsub(/(?=^-*)-/, “X”)
=> “X------abcde-gh----”

Thanks for the info. Just downloaded 1.9 to check it out. But I still
don’t comprehend why look behind is not working like I expected. If I
write the equivalent replacing characters at the end of the string using
look ahead it works just fine:

irb(main):001:0> sequence = ‘-------abcde-gh----’
=> “-------abcde-gh----”
irb(main):002:0> sequence.gsub(/-(?=-*$)/, “X”)
=> “-------abcde-ghXXXX”

Robert K. wrote:

I am not sure lookbehind is the proper means here. After all you want
to replace a sequence of dashes before a particular sequence
(according to your description above). So you would rather use
lookforward, wouldn’t you?

irb(main):003:0> sequence.gsub(/-(?=-*abcde)/, “X”)
=> “XXXXXXXabcde-gh----”

Granted, it does not anchor.

The problem with look ahead/forward is, that I have to make sure the
sequence starts with “-”. Otherwise something like this could happen:

irb(main):003:0> sequence = ‘abcde-gh----’
=> “abcde-gh----”
irb(main):004:0> sequence.gsub(/-(?=-*[abcdefgh])/, “X”)
=> “abcdeXgh----”

Kind regards,
Janus