2 questions: "expanded string" & er

Anon

Hi,
Question 1:
I was reading the PHP manual and it said,"If the string is enclosed in double-quotes ("), variables within the string will be expanded"....what does "expanded" mean in this context?

Question 2:
I ran the following code to get an idea of how ereg() works:

$date="1980-37-21";
if (ereg ("([0-9]{2})-([0-9]{2})-([0-9]{1,2})", $date, $regs)) {
echo "$regs[3].$regs[2].$regs[1]";
} else {
echo "ERROR! Invalid date format";
}

....and was surprised at the result. I thought the values in the curly brackets {} was meant to check the number of digits in the respective part of $date, e.g., in the first part of the ereg() where ([0-9]{2}) it would see that 1980 has 4 digits and therefore, issue the ERROR statement. In fact, it printed "21.37.80"....it chopped off the front "19" in order to conform to {2}. Now, here's where it gets even more confusing (at least for me)....when I changed the middle {2} value to {1}to now read:

ereg ("([0-9]{2})-([0-9]{1})-([0-9]{1,2})", $date, $regs)

it prints the ERROR statement...confirming my initial belief that the value defined in the curly bracket {} checks for the number of digits in that part of $date....or does it?!!!

I've also seen an example in the manual where there is a plus sign (+) within the brackets...

ereg ("([[:alnum:]]+) ([[:alnum:]]+) ([[:alnum:]]+)", $string,$regs);

...what does that mean? and what is the colon (🙂 surrounding "alnum" mean? I assume that "alnum" means alphanumeric? and finally, why is there a set of double square brackets [[ ]] around "alnum"?

I've read the manual and I still don't understand it. Sorry, but I'm dense that way! Thanks to those of you who put up with my stupidity!!.....please try and explain in laymans terms.

Allen.

Anon

First question:

Run this code

$foo = "foo";
$bar = "bar";
echo "foo is $foo and bar is $bar";
echo 'foo is $foo and bar is $bar';

... and expansion will be perfectly clear.

Second question(s): "man 7 regex" (Unix manual, section 7, regex page) explains it all. Quote:

A bound is {' followed by an unsigned decimal integer, possibly followed by,' possibly followed by another unsigned decimal integer, always followed by `}'. The integers must lie between 0 and RE_DUP_MAX (255) inclusive, and if there are two of them, the first may not exceed the second. An atom followed by a bound containing one integer i and no comma matches a sequence of exactly i matches of the atom. An atom followed by a bound containing one integer i and a comma matches a sequence of i or more matches of the atom. An atom followed by a bound containing two integers i and j matches a sequence of i through j (inclusive) matches of the atom.

Translation: ([0-9]{2}) would match exactly two of [0-9].

Later on the manpage, it says:

Within a bracket expression, the name of a character class enclosed in [:' and:]' stands for the list of all characters belonging to that class. Standard character class names are:

          alnum       digit       punct
          alpha       graph       space
          blank       lower       upper
          cntrl       print       xdigit

... which explains part of your final question. Since "an atom followed by `+' matches a sequence of 1 or more matches of the atom," ([[:alnum:]]+) matches one or more alphanumeric characters but not punctuation, et cetera.

Anon

Thanks for the LAYMAN'S EXPLANATION, Steve ....I really understood everything you wrote....NOT!!!

It's manuals with jargons like "atom" and "bound" and "RE_DUP_MAX" and quotes from such manuals that drives me NUTS! Last time I checked an atom was a particle of matter!!
THIS IS WHY I ASKED FOR IT TO BE EXPLAINED IN LAYMAN'S TERMS IN THE FIRST PLACE!!

Would someone else like to give a shot at answering my question?

By the way,I'm not using UNIX.

Anon

First question:
Expanding variables (often called variable interpolation) means to replace the variable name with its data. So, if you have

$greeting = "Hello, world!";
print "$greeting";

It will print "Hello, world!". However, if you were to use

print '$greeting';

the single quotes would suppress the interpolation, and it would print literally "$greeting".

Second question:
You are correct in what you think the values mean, but you are incorrect in your understanding of how that works in relation to a regular expression. The way the regular expression engine works is to start from the beginning of the string, and try to match the expression.

It grabs characters and compares them to the expression, stopping and backtracking when it fails. So, it grabs "1" and compares that to "[0-9]", and matches. Then it grabs "9" and compares "19" to "[0-9]{2}" and matches. Then it grabs "8" and compares "198" to "[0-9]{2}-" and fails. So, it backtracks. It knows that starting with the first character won't match, so it grabs the second character "9" and compares and matches. Then it grabs "8" and compares "98" and matches. Then it grabs "0" and compares "980" and fails. So, it backtracks again. It grabs "8" and compares and matches. Then it grabs "0" and compares "80" and matches. Then it grabs "-" and compares "80-" and matches. On and on, in this case, matching completely. See, it doesn't truncate what it found, it just starts finding what you asked for at a different place than you thought. ;-)

In the second case, it can never find the string "-[0-9]-", so it fails.

There are a couple of ways you can try and limit the search even more. You can try and anchor the match to either the beginning of the string: "^{([0-9]{2}...."} or the end of the string: "....{1,2}$". You can also look for a "word boundary" to make sure that there is nothing before the first part: "\b([0-9]{2}....".

There are several modifiers that you can use on regular expressions to define what you are looking for. You already know about {n} and {n,m}. There are three other popular ones, "+", "", and "?". In reverse order, "?" is equivalent to {0,1}, it means optionally find one of the previous character. So, you might say something like "cars?" to mean either the singular "car" or the plural "cars". The "" means {0,} (zero or more). The "+" is {1,} (one or more). The more in the "*" and "+" case can be (roughly) infinite.

Anon

The complete Unix regex manpage explains atoms. Not surprisingly, they are the smallest basic unit.

The documentation for regular expressions isn't difficult to read out of meanness; it's hard because regular expressions are very powerful, very complicated, and overly economical in their notational system. Bottom line: Regular expressions are hard.

The manpage information that I quoted originated with Henry Spencer, who is one of the more colorful and expressive people in the early history of Usenet. He's not incapable of writing well; the problem is that writing accurately about this particular subject is extremely difficult.

O'Reilly and Associates has an entire book devoted to regular expressions; you might want to check it out.

And as for not using Unix, here's something else that Henry Spencer said: "Those who fail to understand Unix are condemned to reinvent it, poorly."

Anon

regular expressions are ... overly economical in their notational system

Hmm, this leads me to wonder if anyone has ever written a preprocessor giving a more verbose and easier for the human reader language for writing the regular expressions in?

Anon

December 2, 2000
Stephen,
THANK YOU! THANK YOU! I can't begin to tell you how much I appreciate your efforts in explaining things to me....and I'm glad to say that your efforts weren't wasted!!!! Everything is crystal clear now. Kudos to you!! I'm sure glad there are people like you around on this forum.
Once again, thanks!
Allen.