Продолжаем разговор о регулярных выражениях. В предыдущем посте я рассказал об основах, а в этом рассмотрим некоторые более “продвинутые” конструкции регулярных выражений.

Предполагается что вы уже знаете как указать регулярному выр ажению какие символы и/или их последовательности должны быть в строке для совпадения. А что если вам нужно указать не те символы которые должны присутствовать, а те которых не должно быть? То есть если вам нужно вывести лишь согласные буквы, вы можете конечно их перечислить, а можете использовать и отрицательную группу с гласными, например:

PS C:\> "a","b","c","d","e","f","g","h" -match "[^aoueyi]"
b
c
d
f
g
h

"Крышка" в качестве первого символа группы символов означает именно отрицание. То есть на месте группы может присутствовать любой символ кроме перечисленных в ней. Для того чтобы включить отрицание в символьных группах (\d, \w, \s), не обязательно заключать их в квадратные скобки, достаточно… перевести их в верхний регистр Например \D будет означать "что угодно, кроме цифр", а \S "всё кроме пробелов"

PS C:\> "a","b","1","c","45" -match "\D"
a
b
c
PS C:\> "a","-","*","c","&" -match "\W"
-
*
&

Уже гораздо могущественнее обычных символов подстановки, не так ли? А ведь мы только начали изучать основы! Символьные группы позволяют нам указать лишь содержимое одной позиции, один символ находящийся в неопределенном месте строки. А что если нам надо например выбрать все слова которые начинаются с буквы w? если просто поместить эту букву в регулярное выражение, то оно совпадёт для всех строк где w вообще встречается, и не важно – в начале, в середине или в конце строки. В таких случаях на помощь приходят "якоря". Они позволяют производить сравнение начиная с определенной позиции в строке. ^ (крышка) является якорем начала строки, а $ (знак доллара) - обозначает конец строки. Не запутайтесь - ^ как символ отрицания используется лишь в начале группы символов, а вне группы - этот символ является уже якорем Да, да, авторам регулярных выражений явно не хватало специальных символов, и они по возможности, использовали их более чем в одном месте (о втором значении $ поговорим позже) Впрочем лучше посмотреть на примере:

PS C:\> Get-Process | where {$_.name -match "^w"}

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
     80      10     1460        156    47     0,11    452 wininit
    114       9     2732       1428    55     0,56   3508 winlogon
    162      11     3660       1652    44     0,14   3620 wisptis
    225      20     5076       4308    95    31,33   3800 wisptis
    469      28     9572      11904   101     3,23   1844 wlcrasvc
    706      54    52452      43008   632     9,64   1072 wmdc
    105      10     2308       1428    76     0,08   4056 wuauclt

Эта команда вывела процессы у которых сразу после начала имени (^) следует символ w. Иначе говоря имя начинается на w. Давайте для усложнения примера, и для упрощения понимания, добавим сюда “крышку” в значении отрицательной группы:

PS C:\> Get-Process | where {$_.name -match "^w[^l-z]"}

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
     80      10     1460        156    47     0,11    452 wininit
    114       9     2732       1428    55     0,56   3508 winlogon
    162      11     3660       1652    44     0,14   3620 wisptis
    225      20     5076       4308    95    31,50   3800 wisptis

Теперь команда вывела нам процессы у которых имя начинается с символа w, а следующий символ является чем угодно, только не из диапазона l-z.

Обратите внимание, примеры уже начинают походить на краказябли, а вы их уже можете понимать

Ну и для закрепления, опробуем второй якорь – конец строки:

PS C:\> "Яблоки","Груши","Дыня","Енот","Апельсины","Персик" -match "[ыи]$"
Яблоки
Груши
Апельсины

Это выражение вывело нам все слова в которых последняя буква И или Ы.

Если вы можете точно описать содержимое всей строки, то вы можете использовать и оба якоря одновременно:

PS C:\> "abc","adc","aef","bca","aeb","abec","abce" -match "^a.[cb]$"
abc
adc
aeb

Это регулярное выражение выводит все строки которые начинаются с буквы А, за которой следует один любой символ (точка), затем символ C или B и затем конец строки.

Продолжение следует…

Мне достаточно часто задают вопросы связанные не столько с самим PowerShell, сколько с применением в нем регулярных выражений. Это и понятно – регулярные выражения (или если сокращенно “регэкспы” (regexp, regular expressions)) обладают огромной мощью, и способны сильно упростить жизнь системного администратора или программиста. Однако в мире системного администрирования Windows они мало известны и непопулярны – в cmd.exe практически единственная возможность их применения это утилита findstr.exe, которая обладает очень маленьким функционалом и использует жутко урезанный диалект регулярных выражений. В VBScript функционал регулярных выражений тоже хорошо запрятан, и практически не используется. А вот в PowerShell, авторы языка позаботились о том чтобы регулярные выражения были легко доступны, удобны в использовании и максимально функциональны. Тем более что с последним пунктом всё оказалось достаточно просто – PowerShell использует реализацию регулярных выражений .NET, а она является одной из самых функциональных и производительных, и даже способна потягаться даже с признанным лидером в этой области – perl’ом

Итак, перейдем к делу. Что же такое регулярные выражения? Я не помню правильных и сухих определений из умных книжек, да и незачем, кому интересно – прочитает их сам Регулярные выражения это специальный мини-язык служащий для разбора (parsing) текстовых данных. С его помощью можно разделять строки на компоненты, выбирать нужные части строк для дальнейшей обработки, производить замены, и всё это с огромной гибкостью и точностью.

Впрочем… знакомство с регулярными выражениями лучше начать не с них, а с более простой технологии служащей подобным целям, с которой знакомы все Windows администраторы – с подстановочных символов. Наверняка вы не раз выполняли команду dir, и указывали ей в качестве аргумента маску файла, например *.exe. В данном случае звёздочка означает “любое количество любых символов”. Аналогично можно использовать и знак вопроса, он будет означать “один любой символ”, то есть dir ??.exe выведет все файлы с расширением .exe и именем из двух символов. В PowerShell’овской реализации подстановочных символов можно применять и еще одну конструкцию – группы символов. Так например [a-f] будет означать “один любой символ от a до f (a,b,c,d,e,f)”, а [smw] любую из трех букв (s, m или w). Таким образом команда get-childitem [smw]??.exe выведет файлы с расширением .exe, у которых имя состоит из трех букв, и первая буква либо s, либо m, либо w. Неплохо, неправда ли? Так вот, по сравнению с возможностями регулярных выражения – это детский лепет Но начнём с малого

Для начала изучения мы будем использовать оператор PowerShell -match, который позволяет сравнивать текст слева от него, с регулярным выражением справа. В случае если текст подпадает под регулярное выражение, оператор выдаёт True, иначе – False.

PS C:\> "PowerShell" -match "Power"
True

Вы наверное обратили внимание, что при сравнении с регулярным выражением ищется лишь вхождение строки, полное совпадение текста необязательно (разумеется это можно изменить, но об этом позже). То есть достаточно чтобы регулярное выражение встречалось в тексте.

PS C:\> "Shell" -match "Power"
False
PS C:\> "PowerShell" -match "rsh"
True

Еще одна тонкость: оператор -match по умолчанию не чувствителен к регистру символов (как и другие текстовые операторы в PowerShell), если же вам нужна чувствительность к регистру, используйте -cmatch:

PS C:\> "PowerShell" -cmatch "rsh"
False

В регулярных выражениях можно использовать и группы символов:

PS C:\> Get-Process | where {$_.name -match "sy[ns]"}

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
    165      11     2524       8140    79     0,30   5228 mobsync
    114      10     3436       3028    83    50,14   3404 SynTPEnh
    149      11     2356        492    93     0,06   1592 SynTPStart
    810       0      116        380     6               4 System

И диапазоны в этих группах:

PS C:\> "яблоко","апельсин","груша","абрикос" -match "а[а-п]"
апельсин
абрикос

Кстати тут я в левой части оператора -match поместил массив строк, и он соответственно вывел лишь те строки, которые подошли под регулярное выражение.

Разумеется перечисления символов можно комбинировать, например группа [агдэ-я] будет означать “А или Г или Д или любой символ от Э до Я включительно”. Но гораздо интереснее использовать диапазоны для определения целых классов символов. Например [а-я] будет означать любую букву русского алфавита, а [a-z] английского. Аналогично можно поступать с цифрами – следующая команда выведет все процессы в именах которых встречаются цифры:

PS C:\> Get-Process | where {$_.name -match "[0-9]"}

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
     93      10     1788       2336    70     1,25    548 FlashUtil10c
    158      12     6500       1024    96     0,14   3336 smax4pnp
     30       6      764        160    41     0,02   3920 TabTip32

Так как эта группа используется достаточно часто, для неё была выделена специальная последовательность – \d (от слова digit). По смыслу она полностью идентична [0-9], но гораздо короче

PS C:\> Get-Process | where {$_.name -match "\d"}

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
     93      10     1788       2336    70     1,25    548 FlashUtil10c
    158      12     6500       1024    96     0,14   3336 smax4pnp
     30       6      764        160    41     0,02   3920 TabTip32

Так же последовательность была выделена для группы “любые буквы любого алфавита, любые цифры, или символ подчеркивания” эта группа обозначается как \w (от word) она примерно эквивалентна конструкции [a-zа-я_0-9] (в \w еще входят символы других алфавитов которые используются для написания слов).

Еще вам наверняка встретится другая популярная группа: \s – “пробел, или другой пробельный символ” (например символ табуляции). Сокращение от слова space. В большинстве случаев вы можете обозначать пробел просто как пробел но эта конструкция добавляет читабельности регулярному выражению.

Не менее популярной группой можно назвать символ . (точка). Точка в регулярных выражениях аналогична по смыслу знаку вопроса в подстановочных символах, то есть обозначает один любой символ.

Все вышеперечисленные конструкции можно использовать как отдельно, так и в составе групп, например [\s\d] будет соответствовать любой цифре или пробелу. Если вы хотите указать внутри группы символ - (тире/минус) то надо либо экранировать его символом \ (обратный слеш), либо поставить его в начале группы, чтобы он не был случайно истолкован как диапазон:

PS C:\> "?????","Word","123","-" -match "[-\d]"
123
-

Продолжение: Отрицательные группы и якоря.

Regular expression is very important in any programming . Sometimes we cannot think correctly for some common regular expressions. Here is a link where i found very handy regular expression set.

Regular Expressions Patterns and Examples

This will be very helpful i guess.

Cheer$

I have been using this command for a while now and it helped very much.
The command rename is available in perl package. This is a core package brought by the Debian installer.
To check the availability of the command :

fool@localhost:~$which rename
/usr/bin/rename

Having a closer look at the command, you will notice that it is a symbolic link to /etc/alternatives/rename :

fool@localhost:~$ls -l /usr/bin/rename
lrwxrwxrwx 1 root root 24 août  23  2008 /usr/bin/rename -> /etc/alternatives/rename

To display the current configuration :

root@localhost:~#update-alternatives –display rename
rename – auto mode
 link currently points to /usr/bin/prename
/usr/bin/prename – priority 60
 slave rename.1.gz: /usr/share/man/man1/prename.1.gz
Current `best’ version is /usr/bin/prename.

How to use this command?
Quite simple if you know how to use regular expressions.
Thanks to the option -n, you can test your regular expression without renaming your files effectively.
Let us have an example :

fool@localhost:~$touch fool_1.t fool_2.t

If you want to rename fool_1.t and fool_2.t into fool1.t and fool2.t : 
fool@localhost:~$rename -n ’s/_//g’ *.t
fool_1.t renamed as fool1.t
fool_2.t renamed as fool2.t

To rename the files permanently, remove the option ‘-n‘ :
fool@localhost:~$rename ’s/_//g’ *.t

More information :

man rename
 

Regular Expression Advanced Language Elements

Grouping Constructs

• ( ) - captures the matched substring (or noncapturing group). Captures using () are numbered automatically based on the order of the opening parenthesis, starting from one. The first capture, capture element number zero, is the text matched by the whole regular expression pattern
• (?<name> ) - captures the matched substring into a group name or number name. The string used for name must not contain any punctuation and it cannot begin with a number. You can use single quotes instead of angle brackets
• (?<name1-name2> ) - balancing group definition. Deletes the definition of the previously defined group name2 and stores in group name1 the interval between the previously defined name2 group and the current group. If no group name2 is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct allows the stack of captures for group name2 to be used as a counter for keeping track of nested constructs such as parentheses. In this construct, name1 is optional. You can use single quotes instead of angle brackets
• (?: ) – noncapturing group
• (?imnsx-imnsx: ) – applies or disables the specified options within the subexpression. For example, (?i-s: ) turns on case insensitivity and disables single-line mode
• (?= ) – zero-width positive lookahead assertion. Continues match only if the subexpression matches at this position on the right. For example, \w+(?=\d) matches a word followed by a digit, without matching the digit. This construct does not backtrack
• (?! ) – zero-width negative lookahead assertion. Continues match only if the subexpression does not match at this position on the right. For example, \b(?!un)\w+\b matches words that do not begin with un
• (?<= ) -zero-width positive lookbehind assertion. Continues match only if the subexpression matches at this position on the left. For example, (?<=19)99 matches instances of 99 that follow 19. This construct does not backtrack
• (?<!– ) – zero-width negative lookbehind assertion. Continues match only if the subexpression does not match at the position on the left
• (?> ) – nonbacktracking subexpression (also known as a “greedy” subexpression). The subexpression is fully matched once, and then does not participate piecemeal in backtracking (That is, the subexpression matches only strings that would be matched by the subexpression alone.)

Named captures are numbered sequentially, based on the left-to-right order of the opening parenthesis (like unnamed captures), but numbering of named captures starts after all unnamed captures have been counted.

Backreference Constructs

• \number – backreference. For example, (\w)\1 finds doubled word characters
• \k <name> - named backreference. For example, (?\w)\k finds doubled word characters. The expression (?<43>\w)\43 does the same. You can use single quotes instead of angle brackets; for example, \k’char’

Alternation Constructs

• | – matches any one of the terms separated by the | (vertical bar) character. The leftmost successful match wins
• (?(expression)yes|no)  – matches the “yes” part if the expression matches at this point; otherwise, matches the “no” part. The “no” part can be omitted. The expression can be any valid subexpression, but it is turned into a zero-width assertion, so this syntax is equivalent to (?(?=expression)yes|no). Note that if the expression is the name of a named group or a capturing group number, the alternation construct is interpreted as a capture test (described in the next row of this table). To avoid confusion in these cases, you can spell out the inside (?=expression) explicitly
• (?(name)yes|no) – matches the “yes” part if the named capture string has a match; otherwise, matches the “no” part. The “no” part can be omitted. If the given name does not correspond to the name or number of a capturing group used in this expression, the alternation construct is interpreted as an expression test (described in the preceding row of this table)

Miscellaneous Constructs

• (?imnsx-imnsx) – sets or disables options such as case insensitivity to be turned on or off in the middle of a pattern. Option changes are effective until the end of the enclosing group. See also the information on the grouping construct (?imnsx-imnsx: ), which is a cleaner form
• (?# ) – inline comment inserted within a regular expression. The comment terminates at the first closing parenthesis character
• # [to end of line] – X-mode comment. The comment begins at an unescaped # and continues to the end of the line. (Note that the x option or the RegexOptions.IgnorePatternWhitespace enumerated option must be activated for this kind of comment to be recognized.)

Bibliography

• MSDN

Regular Expression Language Elements

Meta Characters

• . – matches any single character
• $ – matches the end of a line
• ^ - matches the beginning of a line
• * – matches zero or more occurrences of the character immediately preceding
• \ - this is escape or quoting character. The character after this is treated as an ordinary character
• [] – matches any one of the characters between the brackets
• [a1-a9] - ranges of characters can specified by using a hyphen
• [^a1-a9] - to match any character except those in the range, t
• () - treat the expressions between ( and ) as a group. Also, saves the characters matched by the expression into temporary holding areas. Up to nine pattern matches can be saved in a single regular expression. They can be referenced as 1 through 9
• | - or two conditions together
• + - matches one or more occurrences of the character or regular expression immediately preceding
• ? - matches 0 or 1 occurrence of the character or regular expression immediately preceding
• {n} – specifies exactly n matches
• {n,} – specifies at least n matches
• {n,m} – specifies at least n, but no more than m, matches
• *? - specifies the first match that consumes as few repeats as possible (equivalent to lazy *)
• +? - specifies as few repeats as possible, but at least one (equivalent to lazy +)
• ?? - specifies zero repeats if possible, or one (lazy ?)
• {n}? – equivalent to {n} (lazy {n})
• {n,}? – specifies as few repeats as possible, but at least n (lazy {n,})
• {n,m}? – specifies as few repeats as possible between n and m (lazy {n,m})

Character Escapes

• \a -  matches a bell (alarm) \u0007
• \b - matches a backspace \u0008 if in a [] character class; otherwise,  \b denotes a word boundary (between \w and \W characters) . In a replacement pattern, \b always denotes a backspace
• \t - matches a tab \u0009
• \r – matches a carriage return \u000D
• \v - matches a vertical tab \u000B
• \f – matches a form feed \u000C
• \n – matches a new line \u000A
• \e – matches an escape \u001B
• 40 – matches an ASCII character as octal (up to three digits); numbers with no leading zero are backreferences if they have only one digit or if they correspond to a capturing group number
• \x20 – matches an ASCII character using hexadecimal representation (exactly two digits)
• \cC – matches an ASCII control character
• \u0020 – matches a Unicode character using hexadecimal representation (exactly four digits)

Substitutions

• $number – substitutes the last substring matched by group number number (decimal)
• ${name} – substitutes the last substring matched by a (? ) group
• $$ – substitutes a single “$” literal
• $& – substitutes a copy of the entire match itself
• $` – substitutes all the text of the input string before the match
• $’ – substitutes all the text of the input string after the match
• $+ - substitutes the last group captured
• $_ - substitutes the entire input string

Character Classes

• \p{name} – matches any character in the named character class specified by {name}. Supported names are Unicode groups and block ranges
• \P{name} – matches text not included in groups and block ranges specified in {name}
• \w - matches any word character
• \W - matches any nonword character
• \s - matches any white-space character
• \S - matches any non-white-space character
• \d - matches any decimal digit
• \D - matches any nondigit

Atomic Zero-Width Assertions

• \A – specifies that the match must occur at the beginning of the string (ignores the Multiline option)
• \Z - specifies that the match must occur at the end of the string or before \n at the end of the string (ignores the Multiline option)
• \z - specifies that the match must occur at the end of the string (ignores the Multiline option)
• \G – specifies that the match must occur at the point where the previous match ended. When used with Match.NextMatch(), this ensures that matches are all contiguous
• \b - specifies that the match must occur on a boundary between \w (alphanumeric) and \W (nonalphanumeric) characters. The match must occur on word boundaries – that is, at the first or last characters in words separated by any nonalphanumeric characters
• \B - specifies that the match must not occur on a \b boundary

Bibliography

• MSDN

Regular Expressions in C#

Everyone developer who works with a text should know the regular expressions (Regex). Regex is essential tool to text processing. We can find any phrase that we want if we create properly regular expression.

C# support of regular expressions:

• Regex Class – the Regex class represents an immutable (read-only) regular expression. It also contains static methods that allow use of other regular expression classes without explicitly creating instances of the other classes.
• Match Class – the Match class represents the results of a regular expression matching operation. The following example uses the Match method of the Regex class to return an object of type Match in order to find the first match in the input string.
• MatchCollection Class – the MatchCollection class represents a sequence of successful non-overlapping matches. The collection is immutable (read-only) and has no public constructor. Instances of MatchCollection are returned by the Regex.Matches property.
• GroupCollection Class – the GroupCollection class represents a collection of captured groups and returns the set of captured groups in a single match. The collection is immutable (read-only) and has no public constructor. Instances of GroupCollection are returned in the collection that the Match.Groups property returns.
• CaptureCollection Class – the CaptureCollection class represents a sequence of captured substrings and returns the set of captures done by a single capturing group. A capturing group can capture more than one string in a single match because of quantifiers. The Captures property, an object of the CaptureCollection class, is provided as a member of the Match and Group classes to facilitate access to the set of captured substrings.
• Group Class – the Group class represents the results from a single capturing group. Because Group can capture zero, one, or more strings in a single match (using quantifiers), it contains a collection of Capture objects. Because Group inherits from Capture, the last substring captured can be accessed directly (the Group instance itself is equivalent to the last item of the collection returned by the Captures property).
• Capture Class – the Capture class contains the results from a single subexpression capture.

Bibliography

• MSDN

I have in my hand the book “Regular Expressions Cookbook”, by Jan Goyvaerts and Steven Levithan. Very well written and I would like it to be part of your library, if it is not already there.
http://referencedesigner.com/blog/regular-expressions-cookbook/328/

Allows zip5 and zip5-zip4 formats

^(?<zip5>\d{5})$|(^(?<zip5>\d{5})-(?<zip4>\d{4})$)

This one does not allow (755-433-4444 but accepts

757-333-4444

7774443333

444 444 4444

444 400-9444

^(((?<area>\d{3})-?)|\((?<area>\d{3})\))\s*(?<ph1>\d{3})-?\s*(?<ph2>\d{4})$

Replacement string to use is ${area}${ph1}${ph2} – will print out 4443333333. Add spaces and chars as necesary

[\p{L}\p{N}]

Where
\p{L} matches all letters
\p{N} matches all numbers

More information

Archimede said: “Give me a lever long enough and a fulcrum on which to place it, and I shall move the world.”

Luca said: “Give me a regular expression long enough and a string on which to apply it, and I shall fix this code.”

Для большинства случаев использования регулярных выражений в PowerShell применяются операторы -match, -replace, и командлет Select-String. Но иногда их возможностей недостаточно, и тогда на помощь приходит класс [regex] принося всю мощь регулярных выражений .Net Одно из самых простых его применений – выборка из куска текста нескольких вхождений одного выражения. Для примера – достанем ссылки из кода вебстраницы. Сразу замечу что выражение определяющее url не точное, но в большинстве случаев его будет более чем достаточно.
Итак, для начала объявим функцию для загрузки кода веб-страницы (это обновлённая версия Get-WWWString):

function Get-WwwString ([string]$Url, [string]$Encoding="windows-1251", [System.Management.Automation.PSCredential]$ProxyCredential = $GlobalCreds)
{
        $wc = new-object System.Net.WebClient
        $wc.Encoding = [System.Text.Encoding]::GetEncoding($Encoding)
        $wc.UseDefaultCredentials = $true
        if ($ProxyCredential) {$wc.Proxy.Credentials = $ProxyCredential.GetNetworkCredential()}
        $wc.DownloadString($url)
}

Теперь загружаем страницу, и вытаскиваем ссылки…

$Text = Get-WwwString "http://ya.ru"            

[regex]$reg = '"(\w+://[^"]+)"'
$match = $reg.match($Text)
while ($match.Success)
{
    $match.Groups[1].value
    $match = $match.nextMatch()
}

Preg_Match_All is used to search a string for specific patterns and stores the results in an array. Unlike preg_match which stops searching after it finds a match, preg_match_all searches the entire string and records all matches. It is phrased as: preg_match_all (pattern, string, $array, optional_ordering, optional_offset)

<?php
 $data = "The party will start at 10:30 pm and run untill 12:30 am";
 preg_match_all('/(\d+:\d+)\s*(am|pm)/', $data, $match, PREG_PATTERN_ORDER);
 print_r($match);
 ?>
Output
Array
(
    [0] => Array
        (
            [0] => 10:30 pm
            [1] => 12:30 am
        )

    [1] => Array
        (
            [0] => 10:30
            [1] => 12:30
        )

    [2] => Array
        (
            [0] => pm
            [1] => am
        )

)

In our first example we use PREG_PATTERN_ORDER. We are searching for 2 things; one is the time, the other is it’s am/pm tag. Our results are outputted to $match, as an array where $match[0] contains all matches, $match[1] contains all data matching our first sub-serach (the time) and $match[2] contains all data matching our second sub-search (am/pm).

<?php
 $data = "The party will start at 10:30 pm and run untill 12:30 am";
 preg_match_all('/(\d+:\d+)\s*(am|pm)/', $data, $match, PREG_SET_ORDER);
print_r($match);
 ?>
Output
Array
(
    [0] => Array
        (
            [0] => 10:30 pm
            [1] => 10:30
            [2] => pm
        )

    [1] => Array
        (
            [0] => 12:30 am
            [1] => 12:30
            [2] => am
        )

)

(
    [0] => Array
        (
            [0] => 10:30 pm
            [1] => 10:30
            [2] => pm
        )

    [1] => Array
        (
            [0] => 12:30 am
            [1] => 12:30
            [2] => am
        )

)

In our second example we use PREG_SET_ORDER. This puts each full result into an array. The first result is $match[0], with $match[0][0] being the full match, $match[0][1] being the first sub-match and $match[0][2] being the second sub-match.

The PHP function, preg_grep, is used to search an array for specific patterns and then return a new array based on that filtering. There are two ways to return the results. You can return them as is, or you can invert them (instead of only returning what matches, it would only return what does not match.) It is phrased as: preg_grep ( search_pattern, $your_array, optional_inverse ) The search_pattern needs to be a regular expression. If you are unfamiliar with them this article gives you an overview of the syntax.

<?php
$data = array(0, 1, 2, 'three', 4, 5, 'six', 7, 8, 'nine', 10);
$mod1 = preg_grep("/4|5|6/", $data);
$mod2 = preg_grep("/[0-9]/", $data, PREG_GREP_INVERT);
print_r($mod1);
echo "<br>";
print_r($mod2);
?>

This code would result in the following data:
Array ( [4] => 4 [5] => 5 )
Array ( [3] => three [6] => six [9] => nine )

First we assign our $data variable. This is a list of numbers, some in alpha form, others in numeric. The first thing we run is called $mod1. Here we are searching for anything that contains 4, 5, or 6. When our result is printed below we only get 4 and 5, because 6 was written as ’six’ so it did not match our search.

Next we run $mod2, which is searching for anything that contains a numeric character. But this time we include PREG_GREP_INVERT. This will invert our data, so instead of outputting numbers, it outputs all of our entries that where not numeric (three, six and nine).

PHP regular expressions seems to be a quite complicated area especially if you are not an experienced Unix user. Historically regular expressions were originally designed to help working with strings under Unix systems.

Using regular expressions you can easy find a pattern in a string and/or replace it if you want. This is a very powerful tool in your hand, but be careful as it is slower than the standard string manipulation functions.

Regular expression types

There are 2 types of regular expressions:

• POSIX Extended
• Perl Compatible

The ereg, eregi, … are the POSIX versions and preg_match, preg_replace, … are the Perl version. It is important that using Perl compatible regular expressions the expression should be enclosed in the delimiters, a forward slash (/), for example. However this version is more powerful and faster as well than the POSIX one.

The regular expressions basic syntax

To use regular expressions first you need to learn the syntax of the patterns. We can group the characters inside a pattern like this:

• Normal characters which match themselves like hello
• Start and end indicators as ^ and $
• Count indicators like +,*,?
• Logical operator like |
• Grouping with {},(),[]

An example pattern to check valid emails looks like this:

The code to check the email using Perl compatible regular expression looks like this:

<?php
$pattern = "/^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/";
$str = "test@test.com";
if(preg_match($pattern,$str))
	echo "match";
else
	echo "not match";
?>

Here is syntax pattern

The Preg_Match PHP function is used to search a string, and return a 1 or 0. If the search was successful a 1 will be returned, and if it was not found a 0 will be returned. Although other variables can be added, it is most simply phrased as: preg_match(search_pattern, your_string). The search_pattern needs to be a regular expression. If you are unfamiliar with them this article gives you an overview of the syntax.

<?php
$data = "I had a box of cerial for breakfast today, and then I drank some juice.";
if (preg_match("/juice/", $data))
{
echo "You had juice.";
}
else
{
echo "You had did not have juice.";
}
if (preg_match("/eggs/", $data))
{
echo "You had eggs.";
}
else
{
echo "You had did not have eggs.";
}
?>

The code above uses preg_match to check for a key word (first juice then egg) and replies based on whether it is true (1) or false (0).

Another example
regular expression to validate time

// Must have one and only one space...
"/(0[1-9]¦1[0-2]):[0-5][0-9] ([ap]m¦[AP]M)/"
// Must have at least one space...
"/(0[1-9]¦1[0-2]):[0-5][0-9]\s+([ap]m¦[AP]M)/"

Here’s a list of basic regular expressions/MS Word wildcard search strings, useful for academic copyediting world (esp. to rip through a reference list).  The logic of some of them is still a bit shaky – use with sensible precaution.

Replaces a bracketed year with a year preceded and followed by periods [(2000) to . 2000.]

\(([0-9]{4})\)
. \1.

The same, but with an index letter for the year ((2000a) to . 2000a.)

\(([0-9]{4}[abc])\)
. \1.

Replaces hyphen between two numbers with en-dash.

([0-9])-([0-9])
\1^=\2

Closing quotation mark, comma, or fullstop ordering from Oxford to Chicago style – note: does not find Smart Quotes.

(“)([,.])
\2\1

Same as previous, finding a smart quote
(”)([,.])
\2\1

Closing quotation mark, comma or fullstop from Chicago to Oxford style (not Smart Quotes)

([,.])(“)
\2\1

Replace smart single quotes with smart double quotes (be careful with this one in case there are apostrophes around).

‘(*)’
“\1”

Replace smart double quotes with smart single quotes

“(*)”
‘\1’

Change  “Vol. #, No. #,” to “# (#):”

, Vol. ([0-9]{1,}), No. ([0-9]{1,}),
\1 (\2):

Author-date method; in text, change comma-separated author list to semicolon separated.
([0-9]{4}), ([! ]{1,} [0-9]{4})
\1; \2