From: ES <ruby-ml@...>
Date: 2005-03-19T05:42:13+09:00
Subject: Re: Iterating through a string and removing leading characters


In data 3/18/2005, "Randy Kramer" <rhkramer@gmail.com> ha scritto:

>This is going to seem a little strange (for a number of reasons I might
>mention below), but I would like to iterate through a string from beginning
>to end, examining each character, then discarding (or moving) them
>(elsewhere).
>
>This is so that I can, upon finding certain character(s), run one of several
>REs on the next part of the string.  I'm looking to find a very efficient way
>to do this.
>
>Here are the approaches I'm considering so far.  Any other suggestions?
>
>   * ?? (Is there any method which chops the first character from the string?
>How efficient is that (especially compared to the method described in the
>next bullet).
>   * Reverse the string, then use something like s[length (-1)] to examine
>then chop to discard the last character.  The problem with this approach is
>that I then have to reverse the string again to have the REs work.  (I
>(briefly) thought about just setting up the REs in reverse, but I foresee a
>lot of difficulty there--scanning through the string in reverse (from last
>character to first, negates the advantage I was hoping to gain, that of
>starting the RE match only from positions where the RE could possibly match.)
>
>Barring anything better, the approach I may take is to iterate through the
>string and, when I find a potential RE match, use s[n,len] to return a
>partial string to be checked against the RE.
>
>Aside: I'm trying to make a very efficient parser in Ruby for a wiki-like
>thing I want to build, and am trying to avoid the approach of simply making
>multiple scans through the document for each of a fairly large number of REs.
>
>I might be guilty of premature optimization, but I prefer to think of it as
>doing some proof of concept testing before committing to a design.
>
>I have done some tests that show a 1 to 10% savings in time by taking a
>similar approach for REs that could only match at the beginning of a string.
>(At some point I'll "publish" those results on WikiLearn (or the next
>incarnation thereof).)  The next REs are considerably more complex as they
>can match anywhere in the string--if the savings from the same approach for
>them is only 1 to 10%, the complexity will not be worth it.  If by some
>chance it exceeds say 50%, I will seriously consider that complexity.

I implemented a semi-stateful wiki parser in a somewhat similar manner
using StringScanner. It's fairly fast.

>Randy Kramer

E