CVIII. Regular Expression Functions (POSIX Extended)

Wstęp

Podpowiedź: PHP also supports regular expressions using a Perl-compatible syntax using the PCRE functions. Those functions support non-greedy matching, assertions, conditional subpatterns, and a number of other features not supported by the POSIX-extended regular expression syntax.

Ostrzeżenie

These regular expression functions are not binary-safe. The PCRE functions are.

Regular expressions are used for complex string manipulation. PHP uses the POSIX extended regular expressions as defined by POSIX 1003.2. For a full description of POSIX regular expressions see the regex man pages included in the regex directory in the PHP distribution. It's in manpage format, so you'll want to do something along the lines of man /usr/local/src/regex/regex.7 in order to read it.

Wymagania

Do zbudowania tego rozszerzenia nie są wymagane żadne zewnętrzne biblioteki.

Instalacja

Ostrzeżenie

Do not change the TYPE unless you know what you are doing.

To enable regexp support configure PHP --with-regex[=TYPE]. TYPE can be one of system, apache, php. The default is to use php.

PHP w wersji dla systemów Windows posiada wbudowaną obsługę dla tego rozszerzenia. Nie trzeba ładować żadnych dodatkowych rozszerzeń aby korzystać z tych funkcji.

Konfiguracja czasu wykonywania

To rozszerzenie nie definiuje posiada żadnych dyrektyw konfiguracyjnych w pliku php.ini.

Typy zasobów

To rozszerzenie nie posiada żadnych rodzajów zasobów.

Stałe predefinopwane

To rozszerzenie nie posiada żadnych stałych.

Przykłady

Przykład 1. Regular Expression Examples


<?php

// Returns true if "abc" is found anywhere in $string.

ereg("abc", $string);            



// Returns true if "abc" is found at the beginning of $string.

ereg("^abc", $string);



// Returns true if "abc" is found at the end of $string.

ereg("abc$", $string);



// Returns true if client browser is Netscape 2, 3 or MSIE 3.

eregi("(ozilla.[23]|MSIE.3)", $HTTP_USER_AGENT);  



// Places three space separated words into $regs[1], $regs[2] and $regs[3].

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



// Put a <br /> tag at the beginning of $string.

$string = ereg_replace("^", "<br />", $string); 

 

// Put a <br /> tag at the end of $string.

$string = ereg_replace("$", "<br />", $string); 



// Get rid of any newline characters in $string.

$string = ereg_replace("\n", "", $string);

?>

Patrz także

For regular expressions in Perl-compatible syntax have a look at the PCRE functions. The simpler shell style wildcard pattern matching is provided by fnmatch().

Spis treści
ereg_replace -- Replace regular expression
ereg -- Regular expression match
eregi_replace -- Replace regular expression case insensitive
eregi -- Case insensitive regular expression match
split -- Split string into array by regular expression
spliti -- Split string into array by regular expression case insensitive
sql_regcase -- Make regular expression for case insensitive match

User Contributed Notes


I was having a ton of issues with other people's phone number validation expressions, so I made my own. It works with most US phone numbers, including those with extentions. Format matches any of the following formats:



5551234567

555 1234567

555 123 4567

555 123-4567

555-1234567

555-123-4567

555123-4567

(555)1234567

(555)123 4567

(555)123-4567

(555) 1234567

(555) 123-4567

(555) 123 4567



And any of the following extentions can be added with or without a space between them and the number:

x123

x.123

x. 123

x 123

ext.123

ext. 123

ext 123

ext123



Extentions support between 1 and 5 digits. 



Here is the expression:



$regex = '^[(]?[2-9]{1}[0-9]{2}[) -]{0,2}' . '[0-9]{3}[- ]?' . '[0-9]{4}[ ]?' . '((x|ext)[.]?[ ]?[0-9]{1,5})?$';



Enjoy!


In a PCRE \s matches whitespace, but not inside a character class:



preg_match ('/\s/', ' ') // match

preg_match ('/[\s]/', ' ') // no match



Within a character class [:space:] is treated as a single character that matches any single whitespace character:



$pattern = '/[[:space:]]/';

$subject = "space tab\tnewline\n";

preg_match_all($pattern, $subject, $out) // == 3



To match a hyphen from within a character class, it must either be first or last; otherwise, it will act as a range operator.



Example: To match a blank string or a string containing only uppercase letters, underscores, spaces, and hyphens:



preg_match('/^[A-Z_ -]*$/', $subject)



To match any whitespace, not just spaces:



preg_match('/^[A-Z_[:space:]-]*$/', $subject)


Sadly, the Posix regexp evaluator (PHP 4.1.2) does not seem to support multi-character coallating sequences, even though such sequences are included in the man-page documentation.



Specifically, the man-page discusses the expression "[[.ch.]]*c" which matches the first five characters of "chchcc".  Running this expression in ereg_replace generates the error "Warning: REG_ECOLLATE".  (Running an equivalent expression with only one character between the periods does work, however.)



Multi-character coallating sequences are not supported!



This is really, really too bad, because it would have provided a simple way to exlude words from the target.



I'm going to go learn PCRE, now.  :-(


mholdgate wrote a very nice quick reference guide in the next page (http://www.php.net/manual/en/function.ereg.php), but I felt it could be improved a little:

________________



^        Start of line

$        End of line

n?        Zero or only one single occurrence of character 'n'

n*        Zero or more occurrences of character 'n'

n+        At least one or more occurrences of character 'n'

n{2}        Exactly two occurrences of 'n'

n{2,}        At least 2 or more occurrences of 'n'

n{2,4}        From 2 to 4 occurrences of 'n'

.        Any single character

()        Parenthesis to group expressions

(.*)        Zero or more occurrences of any single character, ie, anything!

(n|a)        Either 'n' or 'a'

[1-6]        Any single digit in the range between 1 and 6

[c-h]        Any single lower case letter in the range between c and h

[D-M]        Any single upper case letter in the range between D and M

[^a-z]        Any single character EXCEPT any lower case letter between a and z.



        Pitfall: the ^ symbol only acts as an EXCEPT rule if it is the 

        very first character inside a range, and it denies the 

        entire range including the ^ symbol itself if it appears again 

        later in the range. Also remember that if it is the first 

        character in the entire expression, it means "start of line". 

        In any other place, it is always treated as a regular ^ symbol.

        In other words, you cannot deny a word with ^undesired_word 

        or a group with ^(undesired_phrase).

        Read more detailed regex documentation to find out what is 

        necessary to achieve this.



[_4^a-zA-Z]    Any single character which can be the underscore or the 

        number 4 or the ^ symbol or any letter, lower or upper case



?, +, * and the {} count parameters can be appended not only to a single character, but also to a group() or a range[].



therefore,

^.{2}[a-z]{1,2}_?[0-9]*([1-6]|[a-f])[^1-9]{2}a+$

would mean:



^.{2}         = A line beginning with any two characters, 

[a-z]{1,2}     = followed by either 1 or 2 lower case letters, 

_?         = followed by an optional underscore, 

[0-9]*         = followed by zero or more digits, 

([1-6]|[a-f])     = followed by either a digit between 1 and 6 OR a 

        lower case letter between a and f, 

[^1-9]{2}     = followed by any two characters except digits 

        between 1 and 9 (0 is possible), 

a+$         = followed by at least one or more 

        occurrences of 'a' at the end of a line.


It's easy to exclude characters but excluding words with a regular expression is a bit more tricky. For parentheses there is no equivalent to the ^ for brackets. The only way I've found to exclude a string is to proceed by inverse logic: accept all the words that do NOT correspond to the string. So if you want to accept all strings except those _begining_ with "abc", you'd have to accept any string that matches one of the following:

  ^(ab[^c])

  ^(a[^b]c)

  ^(a[^b][^c])

  ^([^a]bc)

  ^([^a]b[^c])

  ^([^a][^b]c)

  ^([^a][^b][^c])



which, put together, gives the regex

  ^(ab[^c]|a[^b]c|a[^b][^c]|[^a]bc|[^a]b[^c]|[^a][^b]c|[^a][^b][^c])



Note that this won't work to detect the word "abc" anywhere in a string. You need to have some way of anchoring the inverse word match

like: ^(a[^b]|[^a]b|[^a][^b])   ;"ab" not at begining of line

  or: (a[^b]|[^a]b|[^a][^b])&   ;"ab" not at end of line

  or: 123(a[^b]|[^a]b|[^a][^b]) ;"ab" not after "123"



I don't know why "(abc){0,0}" is an invalid synthax. It would've made all this much simpler.

 

 

Slightly off-topic, here's a regex date validator (format yyyy-mm-dd, remove all spaces and linefeeds):

  ^(19|20)([0-9]{2}-((0[13-9]|1[0-2])-(0[1-9]|[12][0-9]|30)|

  (0[13578]|1[02])-31|02-(0[1-9]|1[0-9]|2[0-8]))|([2468]0|

  [02468][48]|[13579][26])-02-29)$