Работа с регулярными выражениями на php. глава 1

Содержание:

Как правильно писать регулярные выражения ¶
Примеры preg_match PHP
«Петя любит Дашу».replace(/Дашу|Машу|Сашу/, «Катю») ¶
Строковые методы, поиск и замена
Поиск совпадений с использованием findall, search и match
- Что делает re.findall()?
- re.search() против re.match()
Методы класса PatternSyntaxException
- Примеры
Границы
- Начало строки
- Конец строки
Алгоритм[править]
PHP- функции Regexp POSIX
Группы регулярных выражений
Кванторы
Unicode. Алфавиты и блоки: \р, \Р
Оптимизация RegExp

Как правильно писать регулярные выражения ¶

Прежде, чем садиться и писать регулярно выраженного кракена, подумайте, что именно вы хотите сделать. Регулярное выражение должно начинаться с мысли «Я хочу найти/заменить/удалить то-то и то-то». Затем вам нужен исходный текст, который содержит как ПРАВИЛЬНЫЕ, так и НЕправильные данные. Затем вы открываете https://regex101.com/, вставляете текст и начинаете писать регулярное выражение. Этот замечательный инструмент укажет и покажет все ошибки, а также подсветит результаты поиска.

Для примера возьмём валидацию ip-адреса. Первая мысль должна быть: «Я хочу валидировать ip-адрес. А что такое ip-адрес? Из чего он состоит?». Затем нужен список валидных и невалидных адресов:

Валидный адрес должен содержать четыре числа (байта) от 0 до 255. Если он содержит число больше 255, это уже ошибка. Если бы мы делали валидацию на каком-либо языке программирования, то можно было бы разбить выражение на четыре части и проверить каждое число отдельно. Но регулярные выражения не поддерживают проверки больше или меньше, поэтому придётся делать по-другому.

Для начала упростим задачу: будем валидировать не весь ip-адрес, а только один байт. А байт это всегда есть либо одно-, либо дву-, либо трёхзначное число. Для одно- и двузначного числа шаблон очень простой — любая цифра. А вот для трёхзначного числа первая цифра либо единица, либо двойка. Если первая цифра единица, то вторая и третья могут быть от нуля до девяти. Если же первая цифра двойка, то вторая может быть только от нуля до пяти. Если первая цифра двойка и вторая пятёрка, то третья может быть только от ноля до пяти. Давайте формализуем:

Теперь, зная все диапазоны байта, можно объединить их в одно выражение через вертикальную палочку | (ИЛИ):

Обратите внимание, что я использовал границу слова \b, чтобы искать полные байты. Пробуем регулярку в деле:

Как видим, все байты стали зелёненькими. Это значит, что мы на верном пути.

Осталось дело за малым: сделать так, чтобы искать четыре байта, а не один. Нужно учесть, что байты разделены тремя точками. То есть мы ищем три байта с точкой на конце и один без точки:

Результат выглядит так:

Подсветились только валидные ip-адреса, значит регулярное выражение работает корректно.

Если бы я сразу начал писать валидацию всего адреса, а не отдельного байта, то с большой долей вероятности допустил бы ошибку. Скопления скобочек, палочек и точечек трудно воспринимаются на глаз, поэтому задачу надо обязательно упрощать.

Примеры preg_match PHP

Примеры применения регулярных выражений в python

if (!preg_match("/^*\@*\.{2,6}$/i", $email)) exit("Неправильный адрес");

// \S означает "не пробел", а + -
// "любое число букв, цифр или точек". Модификатор 'i' после '/'
// заставляет PHP не учитывать регистр букв при поиске совпадений.
// Модификатор 's', стоящий рядом с 'i', говорит, что мы работаем
// в "однострочном режиме" (см. ниже в этой главе).
preg_match('/(\S+)@(+)/is', "Привет от somebody@mail.ru!", $p);
// Имя хоста будет в $p, а имя ящика (до @) - в $p.
echo "В тексте найдено: ящик - $p, хост - $p";

if (!preg_match("|^{13,16}$|", $var)) ...

if (preg_match("/(^+(*))$/" , $filename)==NULL) {
        echo "invalid filename";
        exit;
}

/\.(?:z(?:ip|{2})|r(?:ar|{2})|jar|bz2|gz|tar|rpm)$/i

/\.(?:mp3|wav|og(?:g|a)|flac|midi?|rm|aac|wma|mka|ape)$/i

/\.(?:exe|msi|dmg|bin|xpi|iso)$/i

/\.(?:jp(?:e?g|e|2)|gif|png|tiff?|bmp|ico)$/i

/\.(?:mpeg|ra?m|avi|mp(?:g|e|4)|mov|divx|asf|qt|wmv|m\dv|rv|vob|asx|ogm)$/i

preg_match_all('/(8|7|\+7){0,1}{0,}({2}){0,}(({2}{0,}{2}{0,}{3})|({3}{0,}{2}{0,}{2})|({3}{0,}{1}{0,}{3})|({2}{0,}{3}{0,}{2}))/',
    $text, $regs );

if (preg_match("/^{8,20}$/",$string)) echo "yes"; else echo "no";

7.абвгДДДеёааббаабб

if (preg_match("/(.)\\1\\1/",$string)) echo "yes"; else echo "no";

preg_match("/abc/", $string); // true если найдёт в любом месте
preg_match("/^abc/", $string); // true если найдёт в начале
preg_match("/abc$/", $string); // true если найдёт в конце

preg_match("/(ozilla.|MSIE.3)/i", $_SERVER);

«Петя любит Дашу».replace(/Дашу|Машу|Сашу/, «Катю») ¶

Php regular expressions

Не трудно догадаться, что результатом работы js-выражения выше будет текст . Даже, если Петя неровно дышит к Маше или Саше, то результат всё равно не изменится.

Рассмотрим базовые спец. символы, которые можно использовать в шаблонах:

Символ	Описание	Пример использования	Результат
\	Символ экранирования или начала мета-символа	/путь\/к\/папке/	Надёт текст
^	Признак начала строки	/^Дом/	Найдёт все строки, которые начинаются на
$	Признак конца строки	/родной$/	Найдёт все строки, которые заканчиваются на
.	Точка означает любой символ, кроме перевода строки	/Петя ..бит Машу/	Найдёт как , так и
\|	Означает ИЛИ	/Вася\|Петя/	Найдёт как Васю, так и Петю
?	Означает НОЛЬ или ОДИН раз	/Вжу?х/	Найдёт и
*	Означает НОЛЬ или МНОГО раз	/Вжу*х/	Найдёт , , , и т.д.
+	Означает ОДИН или МНОГО раз	/Вжу+х/	Найдёт , , и т.д.

Помимо базовых спец. символов есть мета-символы (или мета-последовательности), которые заменяют группы символов:

Символ	Описание	Пример использования	Результат
\w	Буква, цифра или _ (подчёркивание)	/^\w+$/	Соответствует целому слову без пробелов, например
\W	НЕ буква, цифра или _ (подчёркивание)	/\W\w+\W/	Найдёт полное слово, которое обрамлено любыми символами, например
\d	Любая цифра	/^\d+$/	Соответствует целому числу без знака, например
\D	Любой символ НЕ цифра	/^\D+$/	Соответствует любому выражению, где нет цифр, например
\s	Пробел или табуляция (кроме перевода строки)	/\s+/	Найдёт последовательность пробелов от одного и до бесконечности
\S	Любой символ, кроме пробела или табуляции	/\s+\S/	Найдёт последовательность пробелов, после которой есть хотя бы один другой символ
\b	Граница слова	/\bдом\b/	Найдёт только отдельные слова , но проигнорирует
\B	НЕ граница слова	/\Bдом\b/	Найдёт только окночние слов, которые заканчиваются на
\R	Любой перевод строки (Unix, Mac, Windows)	/.*\R/	Найдёт строки, которые заканчиваются переводом строки

Нужно отметить, что спец. символы \w, \W, \b и \B не работают по умолчанию с юникодом (включая кириллицу). Для их правильной работы нужно указывать модификатор . К сожалению, на окончание 2019 года JavaScript не поддерживает регулярные выражения для юникода даже с модификатором, поэтому в js эти мета-символы работают только для латиницы.

Ещё регулярные выражения поддерживают разные виды скобочек:

Выражение	Описание	Пример использования	Результат
(…)	Круглые скобки означают под-шаблон, который идёт в результат поиска	/(Петя\|Вася\|Саша) любит Машу/	Найдёт всю строку и запишет воздыхателя Маши в результат поиска под номером 1
(?:…)	Круглые скобки с вопросом и двоеточием означают под-шаблон, который НЕ идёт в результат поиска	/(?:Петя\|Вася\|Саша) любит Машу/	Найдёт только полную строку, воздыхатель останется инкогнито
(?P<name>…)	Задаёт имя под-шаблона	/(?P<воздыхатель>Петя\|Вася\|Саша) любит Машу/	Найдёт полную строку, а воздыхателя запишет в результат под индексом 1 и ‘воздыхатель’
	Квадратные скобки задают ЛЮБОЙ СИМВОЛ из последовательности (включая спец. символы \w, \d, \s и т.д.)	/^+$/	Соответствует любому выражению , но не
	Если внутри квадратных скобок указать минус, то это считается диапазоном	/+/	Аналог /\w/ui для JavaScript
	Если минус является первым или последним символом диапазона, то это просто минус	/+/	Найдёт любое целое числое с плюсом или минусом (причём не обязательно, чтобы минус или плюс были спереди)
	Квадратные скобки с «крышечекой» означают любой символ НЕ входящий в диапазон	//i	Найдёт любой символ, который не является буквой, числом или пробелом
]	Квадратные скобки в квадратных скобках задают класс символов (alnum, alpha, ascii, digit, print, space, punct и другие)	/]+/	Найдёт последовательность непечатаемых символов
{n}	Фигурные скобки с одним числом задают точное количество символов	/\w+н{2}\w+/u	Найдёт слово, в котором две буквы н
{n,k}	Фигурные скобки с двумя числами задают количество символов от n до k	/\w+н{1,2}\w+/u	Найдёт слово, в котором есть одна или две буквы н
{n,}	Фигурные скобки с одним числом и запятой задают количество символов от n до бесконечности	/\w+н{3,}\w+/u	Найдёт слово, в котором н встречается от трёх и более раз подряд

Строковые методы, поиск и замена

Удаленная работа и вакансии : «работа на дому без опыта» в москве

Следующие методы работают с регулярными выражениями из строк.

Все методы, кроме replace, можно вызывать как с объектами типа regexp в аргументах, так и со строками, которые автоматом преобразуются в объекты RegExp.

Так что вызовы эквивалентны:

var i = str.search(/\s/)
var i = str.search("\\s")

При использовании кавычек нужно дублировать \ и нет возможности указать флаги. Если регулярное выражение уже задано строкой, то бывает удобна и полная форма

var regText = "\\s"
var i = str.search(new RegExp(regText, "g"))

Возвращает индекс регулярного выражения в строке, или -1.

Если Вы хотите знать, подходит ли строка под регулярное выражение, используйте метод (аналогично RegExp-методы ). Чтобы получить больше информации, используйте более медленный метод (аналогичный методу ).

Этот пример выводит сообщение, в зависимости от того, подходит ли строка под регулярное выражение.

function testinput(re, str){
   if (str.search(re) != -1)
      midstring = " contains ";
   else
      midstring = " does not contain ";
   document.write (str + midstring + re.source);
}

Если в regexp нет флага , то возвращает тот же результат, что .

Если в regexp есть флаг , то возвращает массив со всеми совпадениями.

Чтобы просто узнать, подходит ли строка под регулярное выражение , используйте .

Если Вы хотите получить первый результат — попробуйте r.

В следующем примере используется, чтобы найти «Chapter», за которой следует 1 или более цифр, а затем цифры, разделенные точкой. В регулярном выражении есть флаг , так что регистр будет игнорироваться.

str = "For more information, see Chapter 3.4.5.1";
re = /chapter (\d+(\.\d)*)/i;
found = str.match(re);
alert(found);

Скрипт выдаст массив из совпадений:

Chapter 3.4.5.1 — полностью совпавшая строка
3.4.5.1 — первая скобка
.1 — внутренняя скобка

Следующий пример демонстрирует использование флагов глобального и регистронезависимого поиска с . Будут найдены все буквы от А до Е и от а до е, каждая — в отдельном элементе массива.

var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var regexp = //gi;
var matches = str.match(regexp);
document.write(matches);

// matches =

Метод replace может заменять вхождения регулярного выражения не только на строку, но и на результат выполнения функции. Его полный синтаксис — такой:

var newString = str.replace(regexp/substr, newSubStr/function)

Объект RegExp. Его вхождения будут заменены на значение, которое вернет параметр номер 2

Строка, которая будет заменена на .

Строка, которая заменяет подстроку из аргумента номер 1.

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

Метод не меняет строку, на которой вызван, а просто возвращает новую, измененную строку.

Чтобы осуществить глобальную замену, включите в регулярное выражение флаг .

Если первый аргумент — строка, то она не преобразуется в регулярное выражение, так что, например,

var ab = "a b".replace("\\s","..") // = "a b"

Вызов replace оставил строку без изменения, т.к искал не регулярное выражение , а строку «\s».

В строке замены могут быть такие спецсимволы:

Pattern	Inserts
	Вставляет «$».
	Вставляет найденную подстроку.
	Вставляет часть строки, которая предшествует найденному вхождению.
	Вставляет часть строки, которая идет после найденного вхождения.
or	Где или — десятичные цифры, вставляет подстроку вхождения, запомненную -й вложенной скобкой, если первый аргумент — объект RegExp.

Если Вы указываете вторым параметром функцию, то она выполняется при каждом совпадении.

В функции можно динамически генерировать и возвращать строку подстановки.

Первый параметр функции — найденная подстрока. Если первым аргументом является объект , то следующие параметров содержат совпадения из вложенных скобок. Последние два параметра — позиция в строке, на которой произошло совпадение и сама строка.

Например, следующий вызов возвратит XXzzzz — XX , zzzz.

function replacer(str, p1, p2, offset, s)
{
return str + " - " + p1 + " , " + p2;
}
var newString = "XXzzzz".replace(/(X*)(z*)/, replacer)

Как видите, тут две скобки в регулярном выражении, и потому в функции два параметра , .
Если бы были три скобки, то в функцию пришлось бы добавить параметр .

Следующая функция заменяет слова типа на :

function styleHyphenFormat(propertyName)
{
  function upperToHyphenLower(match)
  {
    return '-' + match.toLowerCase();
  }
  return propertyName.replace(//, upperToHyphenLower);
}

Поиск совпадений с использованием findall, search и match

Предположим, вы хотите извлечь все номера курсов, то есть 100, 213 и 156 из приведенного выше текста. Как это сделать?

Что делает re.findall()?

В приведенном выше коде специальный символ является регулярным выражением, которое соответствует любой цифре. В этой статье вы узнаете больше о таких шаблонах.
Добавление к нему символа означает наличие по крайней мере 1 числа.

Подобно , есть символ , для которого требуется 0 или более чисел. Это делает наличие цифры не обязательным, чтобы получилось совпадение. Подробнее об этом позже.

В итоге, метод извлекает все вхождения 1 или более номеров из текста и возвращает их в список.

re.search() против re.match()

Как понятно из названия, ищет шаблоны в заданном тексте.
Но, в отличие от , который возвращает согласованные части текста в виде списка, возвращает конкретный объект соответствия. Он содержит первый и последний индекс первого соответствия шаблону.

Аналогично, также возвращает объект соответствия. Но разница в том, что он требует, чтобы шаблон находился в начале самого текста.

В качестве альтернативы вы можете получить тот же результат, используя метод для объекта соответствия.

Методы класса PatternSyntaxException

PatternSyntaxException — это непроверенное исключение, которое указывает на синтаксическую ошибку в шаблоне. Класс PatternSyntaxException предоставляет следующие методы, чтобы помочь вам определить, что пошло не так:

№	метод и описание
1	public String getDescription() Получает описание ошибки.
2	public int getIndex() Получает индекс ошибки.
3	public String getPattern() Извлекает ошибочный шаблон регулярного выражения.
4	public String getMessage() Возвращает многострочную строку, содержащую описание синтаксической ошибки и ее индекс, ошибочный шаблон регулярного выражения и визуальную индикацию индекса ошибки в шаблоне.

Примеры

Напишите регулярное выражение, которое соответствует любому номеру телефона.

Телефонный номер в этом примере состоит либо из 7 номеров подряд, либо из 3 номеров, пробела или тире, а затем из 4 номеров.

package regex.phonenumber;

import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;


public class CheckPhone {

    @Test
    public void testSimpleTrue() {
        String pattern = "\\d\\d\\d()?\\d\\d\\d\\d";
        String s= "1233323322";
        assertFalse(s.matches(pattern));
        s = "1233323";
        assertTrue(s.matches(pattern));
        s = "123 3323";
        assertTrue(s.matches(pattern));
    }
}

В следующем примере проверяется, содержит ли текст число из 3 цифр.

package regex.numbermatch;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class CheckNumber {


    @Test
    public void testSimpleTrue() {
        String s= "1233";
        assertTrue(test(s));
        s= "0";
        assertFalse(test(s));
        s = "29 Kasdkf 2300 Kdsdf";
        assertTrue(test(s));
        s = "99900234";
        assertTrue(test(s));
    }




    public static boolean test (String s){
        Pattern pattern = Pattern.compile("\\d{3}");
        Matcher matcher = pattern.matcher(s);
        if (matcher.find()){
            return true;
        }
        return false;
    }

}

В следующем примере показано как извлечь все действительные ссылки с веб-страницы. Не учитывает ссылки, начинающиеся с «javascript:» или «mailto:».

package regex.weblinks;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class LinkGetter {
    private Pattern htmltag;
    private Pattern link;

    public LinkGetter() {
        htmltag = Pattern.compile("<a\\b*href=\"*>(.*?)");
        link = Pattern.compile("href=\"*\">");
    }

    public List getLinks(String url) {
        List links = new ArrayList();
        try {
            BufferedReader bufferedReader = new BufferedReader(
                    new InputStreamReader(new URL(url).openStream()));
            String s;
            StringBuilder builder = new StringBuilder();
            while ((s = bufferedReader.readLine()) != null) {
                builder.append(s);
            }

            Matcher tagmatch = htmltag.matcher(builder.toString());
            while (tagmatch.find()) {
                Matcher matcher = link.matcher(tagmatch.group());
                matcher.find();
                String link = matcher.group().replaceFirst("href=\"", "")
                        .replaceFirst("\">", "")
                        .replaceFirst("\"?target=\"*", "");
                if (valid(link)) {
                    links.add(makeAbsolute(url, link));
                }
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return links;
    }

    private boolean valid(String s) {
        if (s.matches("javascript:.*|mailto:.*")) {
            return false;
        }
        return true;
    }

    private String makeAbsolute(String url, String link) {
        if (link.matches("http://.*")) {
            return link;
        }
        if (link.matches("/.*") && url.matches(".*$")) {
            return url + "/" + link;
        }
        if (link.matches(".*") && url.matches(".*")) {
            return url + "/" + link;
        }
        if (link.matches("/.*") && url.matches(".*[/]")) {
            return url + link;
        }
        if (link.matches("/.*") && url.matches(".*")) {
            return url + link;
        }
        throw new RuntimeException("Cannot make the link absolute. Url: " + url
                + " Link " + link);
    }
}

Поиск дублированных слов. \b является границей слова и \1 ссылается на совпадение первой группы, то есть первого слова. (?!-in)\b(\w+) \1\b находит повторяющиеся слова, если они не начинаются с «-in». Добавьте (?S) для поиска по нескольким строкам.

Поиск элементов, которые начинаются с новой строки.

Также можете посмотреть официальную документацию тут.

Оцени статью

Оценить

Средняя оценка / 5. Количество голосов:

Видим, что вы не нашли ответ на свой вопрос.

Помогите улучшить статью.

Спасибо за ваши отзыв!

Границы

Java Regex API также может соответствовать границам в строке, а именно началом или концом строки, началом слова и т. д. API Java Regex поддерживает следующие границы:

Символ	Описание
^	Начало строки
$	Конец строки
\b	Граница слова (где слово начинается или заканчивается, например, пробел, табуляция и т. д.).
\B	Несловесная граница
\A	Начало ввода.
\G	Конец предыдущего совпадения
\Z	Конец ввода, кроме конечного объекта (если есть)
\z

Начало строки

Соответствие границ ^ соответствует началу строки в соответствии со спецификацией API Java. Например, следующий пример получает только одно совпадение с индексом 0:

String text = "Line 1\nLine2\nLine3";

Pattern pattern = Pattern.compile("^");
Matcher matcher = pattern.matcher(text);

while(matcher.find()){
    System.out.println("Found match at: "  + matcher.start() + " to " + matcher.end());
}

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

Начало соответствия строки / строки часто используется в сочетании с другими символами, чтобы проверить, начинается ли строка с определенной подстроки. Например, этот пример проверяет, начинается ли строка ввода с подстроки http: //:

String text = "http://jenkov.com";

Pattern pattern = Pattern.compile("^http://");
Matcher matcher = pattern.matcher(text);

while(matcher.find()){
    System.out.println("Found match at: "  + matcher.start() + " to " + matcher.end());
}

В этом примере найдено одно совпадение подстроки http: // из индекса 0 в индекс 7 во входном потоке. Даже если бы входная строка содержала больше экземпляров подстроки http: //, они не соответствовали бы этому регулярному выражению, так как оно начиналось с символа ^.

Конец строки

Соответствие $ соответствует концу строки в соответствии со спецификацией Java. На практике, однако, похоже, что он соответствует только концу входной строки.

Соответствие начала строки часто используется в сочетании с другими символами, чаще всего для проверки, заканчивается ли строка определенной подстрокой:

String text = "http://jenkov.com";

Pattern pattern = Pattern.compile(".com$");
Matcher matcher = pattern.matcher(text);

while(matcher.find()){
    System.out.println("Found match at: "  + matcher.start() + " to " + matcher.end());
}

В этом примере будет найдено одно совпадение в конце входной строки.

Алгоритм[править]

Данный алгоритм работает быстрее недетерминированного конечного автомата, построенного по теореме Клини, но только для регулярных выражений, состоящих из символов:

— один любой буквенный символ,

— один любой символ,

— символ начала текста,

— символ конца текста,

— предыдущий символ встречается ноль или более раз.

Например, для , очевидно, проще написать простой сопоставитель, чем строить НКА.

Псевдокодправить

function match(regexp: String, text: String): boolean  
    if regexp == '^'
        return matchHere(regexp, text)  
    int i = 0
    while i  text.length
        if matchHere(regexp, text)
            return true
        i++
    return false

Функция проверяет есть ли вхождение регулярного выражения в любом месте в пределах текста. Если существует более одного вхождения, то найдется самое левое и самое короткое.

Логика функции проста. Если — первый символ регулярного выражения, то любое возможное вхождение должно начинаться в начале текста. То есть если — регулярное выражение, то должно входить в текст только с первой позиции текста, а не где-то в середине текста. Это проверяется путем сопоставления остатка регулярного выражения с текстом, начиная с первой позиции и нигде более.

В противном случае регулярное выражение может входить в текст в любой позиции. Это проверяется путем сопоставления регулярного выражения во всех позициях текста. Если регулярное выражение входит более одного раза в текст, то только самое левое вхождение будет распознано. То есть если — регулярное выражение, то для него найдется самое левое вхождение в текст.

function matchHere(regexp: String, text: String): boolean 
    if regexp == '\0'
        return true 
    if regexp == '*'  
        return matchStar(regexp, regexp, text)
    if regexp == '$' and regexp == '\0'
        return text == '\0'
    if text != '\0' and (regexp == '.' or regexp == text)
        return matchHere(regexp, text)
    return false

Основная часть работы сделана в , которая сопоставляет регулярное выражение с текстом в текущей позиции. Функция пытается сопоставить первый символ регулярного выражения с первым символом текста. В случае успеха мы можем сравнить следующий символ регулярного выражения со следующим символом текста, вызвав рекурсивно. Иначе нет совпадения с регулярным выражением в текущей позиции текста.

function matchStar(c: char, regexp: String, text: String): boolean
    int i = 0
    while i  text.length and (text == c or c == '.')
        if matchHere(regexp, text)
            return true
        i++
    return false

Рассмотрим возможные случаи:

Если в ходе рекурсии регулярное выражение осталось пустым то текст допускается этим регулярным выражением.
Если регулярное выражение имеет вид , то вызывается функция которая пытается сопоставить повторение символа , начиная с нуля повторений и увеличивая их количество, пока не найдет совпадение с оставшимся текстом. Если совпадение не будет найдено, то регулярное выражение не допускает текст. Текущая реализация ищет «кратчайшее совпадение», которое хорошо подходит для сопоставления с образцом, как в grep, где нужно как можно быстрее найти совпадение. «Наидлиннейшее совпадение» более интуитивно и больше подходит для текстовых редакторов, где найденное заменят на что-то. Большинство современных библиотек для работы с регулярными выражениями предоставляют оба варианта.
Если регулярное выражение это , то оно допускает этот текст тогда и только тогда, когда текст закончился.
Если первый символ текста совпал с первым символом регулярного выражения, то нужно проверить совпадают ли следующий символ регулярного выражения со следующим символом текста, сделав рекурсивный вызов .
Если все предыдущие попытки найти совпадения провалились, то никакая подстрока из текста не допускается регулярным выражением.

Модификацииправить

Немного изменим функцию для поиск самого левого и самого длинного вхождения :

Найдем максимальную последовательность подряд идущих символов . Назовем ее .
Сопоставим часть текста без с остатком регулярного выражения.
Если части совпали, то текст допускается этим регулярным выражением. Иначе, если пусто, то текст не допускается этим регулярным выражением, иначе убираем один символ из и повторяем шаг .

Псевдокодправить

function matchStar(c: char, regexp: String, text: String): boolean
    int i
    for (i = 0; text != '\0' and (text == c or c == '.'); i++)
    while i  0
        if matchHere(regexp, text)
            return true
        i--
    return false

PHP- функции Regexp POSIX

PHP в настоящее время предлагает семь функций для поиска строк с использованием регулярных выражений в стиле POSIX —

Значение	Описание
ereg()	Функция ereg() ищет строку, указанную строкой для строки, заданной шаблоном, возвращает true, если шаблон найден, и false в противном случае.
ereg_replace ()	Функция ereg_replace() ищет строку, указанную в шаблоне, и заменяет шаблон заменой, если найден.
eregi()	Функция eregi() выполняет поиск по всей строке, заданной шаблоном, для строки, указанной строкой. Поиск не чувствителен к регистру.
eregi_replace()	Функция eregi_replace() работает точно так же, как и ereg_replace(), за исключением того, что поиск шаблона в строке не чувствителен к регистру.
Split()	Функция split() будет разделять строку на различные элементы, границы каждого элемента на основе появления шаблона в строке.
spliti()	Функция spliti() работает точно так же, как и sibling split(), за исключением того, что она не чувствительна к регистру.
sql_regcase()	Функция sql_regcase() может рассматриваться как служебная функция, преобразующая каждый символ в строку входных параметров в выражение в квадратных скобках, содержащее два символа.

Группы регулярных выражений

Группы регулярных выражений — функция, позволяющая извлекать нужные объекты соответствия как отдельные элементы.

Предположим, что я хочу извлечь номер курса, код и имя как отдельные элементы. Не имея групп мне придется написать что-то вроде этого.

Давайте посмотрим, что получилось.
Я скомпилировал 3 отдельных регулярных выражения по одному для соответствия номерам курса, коду и названию.
Для номера курса, шаблон указывает на соответствие всем числам от 0 до 9. Добавление символа в конце заставляет найти по крайней мере 1 соответствие цифрам 0-9. Если вы уверены, что номер курса, будет иметь ровно 3 цифры, шаблон мог бы быть .

Для кода курса, как вы могли догадаться, будет совпадать с 3 большими буквами алфавита А-Я подряд (буква “ё” не включена в общий диапазон букв).

Для названий курса, будем искать а-я верхнего и нижнего регистра, предполагая, что имена всех курсов будут иметь как минимум 4 символа.

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

Обратите внимание на шаблон номера курса: , код: и название: они все помещены в круглую скобку (), для формирования группы

Кванторы

Частоту или положение заключенных в скобки символьных последовательностей и одиночных символов можно обозначить специальным символом. Каждый особый персонаж имеет конкретную коннотацию. +, * ,? , {int. range} и $ flags следуют за символьной последовательностью.

#	Значение	Описание
р +	Он соответствует любой строке, содержащей хотя бы один p.
п*	Он соответствует любой строке, содержащей ноль или более p.
p ?	Он соответствует любой строке, содержащей ноль или более p. Это просто альтернативный способ использования p *.
р {N}	Он соответствует любой строке, содержащей последовательность из N p
р {2,3}	Он соответствует любой строке, содержащей последовательность из двух или трех p.
p {2,}	Он соответствует любой строке, содержащей последовательность не менее двух p.
р $	Он соответствует любой строке с p в конце ее.
^ р	Он соответствует любой строке с p в начале ее.

Примеры

Следующие примеры дают понятия о совпадении символов.

Значение	Описание
	Он соответствует любой строке, не содержащей ни одного символа в диапазоне от a до z и от A до Z.
p.p	Он соответствует любой строке, содержащей p, за которой следует любой символ, в свою очередь, за которым следует другой p.
^. {2} $	Он соответствует любой строке, содержащей ровно два символа.
(.*).	Он соответствует любой строке, заключенной внутри b и / b.
p ( hp ) *	Он соответствует любой строке, содержащей ap, а затем ноль или более экземпляров последовательности php.

Unicode. Алфавиты и блоки: \р, \Р

Свойства Unicode, алфавиты и блоки: \р{свойство}, \Р{свойство}. На концептуальном уровне Юникод представляет собой отображение множества символов на множество кодов, но стандарт Юникода не сводится к простому перечислению пар. Он также определяет атрибуты символов (например, «этот символ является строчной буквой», «этот символ пишется справа налево», «этот символ является диакритическим знаком, который должен объединяться с другим символом» и т. д.).
Уровень поддержки этих атрибутов зависит от конкретной программы, но многие программы с поддержкой Юникода позволяют находить хотя бы некоторые из них при помощи конструкций \p{атрибут} (символ, обладающий указанным атрибутом) и \P{атрибут} (символ, не обладающий атрибутом).

Оптимизация RegExp

Рекомендации по оптимизации регулярных выражений.

Ускоренное достижение совпадения. Руководствуясь знаниями принципов работы традиционного механизма НКА, можно привести механизм к совпадению по ускоренному пути. Рассмотрим пример  this|that. Каждая альтернатива начинается с th, если у первой альтернативы не найдется совпадение для th, то th второй альтернативы тоже заведомо не совпадет, поэтому такая попытка заведомо завершится неудачей. Чтобы время не тратилось даром, можно сформулировать то же выражение в виде th(?:is|at). В этом случае th проверяется всего один раз, а относительно затратная конструкция выбора откладывается до момента, когда она становится действительно необходимой. Кроме того, в выражении th(?:is|at) проявляется начальный литерал th, что позволяет задействовать ряд других оптимизаций.
Привязка к началу текста/логической строки. Эта разновидность оптимизации понимает, что регулярные выражения, начинающиеся с ^, могут совпасть только от начала строки, поэтому их не следует применять с других позиций.
Привязка к концу текста/логической строки. Эта разновидность оптимизации основана на том, что совпадения некоторых регулярных выражений, завершающихся метасимволом $ или другими якорями конца строки, должны отделяться от конца строки определенным количеством байтов. Например, для выражения regex(es)?$ совпадение должно начинаться не более чем за восемь символов от конца строки, поэтому механизм может сразу перейти к этой позиции. При большой длине целевого текста это существенно сокращает количество начальных позиций поиска. Восемь, а не семь, потому что во многих диалектах $ может совпадать перед завершающим символом новой строки.
Исключение по первому символу/классу/подстроке. Данный вид оптимизации руководствуется информацией (любое совпадение должно начинаться с конкретного символа или подстроки), на основании которой производится быстрая проверка и применение регулярного выражения только с соответствующих позиций строки. Например, выражение this|that|other может совпадать только в позициях, начинающихся с ; механизм проверяет все символы строки и применяет выражение только с соответствующих позиций, что может привести к огромной экономии времени. Чем длиннее проверяемая строка, тем меньше вероятность ложной идентификации начальных позиций.
Используйте несохраняющие круглые скобки. Если вы не используете текст, совпадающий с подвыражениями в круглых скобках, используйте несохраняющие скобки (?:…). Помимо прямого выигрыша из-за отсутствия затрат на сохранение появляется побочная экономия – состояния, используемые при возврате, становятся менее сложными и поэтому быстрее восстанавливаются.