std.regex

Регулярные выражения являются часто используемым методом сопоставления шаблонов в строках, а regex — это запоминающееся слово для шаблона в этом языке предметной области. Типичные задачи, обычно решаемые с помощью регулярных выражений, включают проверку ввода пользователя и повсеместно используемый поиск и замену в инструментах обработки текста.

Обзор

import std.regex;
import std.stdio;
void main()
{
    // Print out all possible dd/mm/yy(yy) dates found in user input.
    auto r = regex(r"\b[0-9][0-9]?/[0-9][0-9]?/[0-9][0-9](?:[0-9][0-9])?\b");
    foreach (line; stdin.byLine)
    {
      // matchAll() returns a range that can be iterated
      // to get all subsequent matches.
      foreach (c; matchAll(line, r))
          writeln(c.hit);
    }
}
...

// Create a static regex at compile-time, which contains fast native code.
auto ctr = ctRegex!(`^.*/([^/]+)/?$`);

// It works just like a normal regex:
auto c2 = matchFirst("foo/bar", ctr);   // First match found here, if any
assert(!c2.empty);   // Be sure to check if there is a match before examining contents!
assert(c2[1] == "bar");   // Captures is a range of submatches: 0 = full match.

...
// multi-pattern regex
auto multi = regex([`\d+,\d+`,`(a-z]+):(\d+)`]);
auto m = "abc:43 12,34".matchAll(multi);
assert(m.front.whichPattern == 2);
assert(m.front[1] == "abc");
assert(m.front[2] == "43");
m.popFront();
assert(m.front.whichPattern == 1);
assert(m.front[1] == "12");
...

// The result of the `matchAll/matchFirst` is directly testable with if/assert/while.
// e.g. test if a string consists of letters:
assert(matchFirst("Letter", `^\p{L}+$`));

Синтаксис и общие сведения

• Имена подвыражений с использованием синтаксиса Python.
• Свойства Unicode, такие как скрипты, блоки и общие двоичные свойства, например, Алфавитный, Пробел, Шестнадцатеричная цифра и т.д.
• Обратные ссылки произвольной длины и сложности, включая просмотр вперёд в обратном просмотре и наоборот.

Синтаксис шаблона

Классы символов

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

Поддержка Unicode

• 1.1 Шестнадцатеричное представление с помощью \uxxxx, \U00YYYYYY, \xZZ.
• 1.2 Свойства Unicode.
• 1.3 Классы символов с операциями над множествами.
• 1.4 Границы слов используют весь набор символов "слова".
• 1.5 Использование простого преобразования регистров для сопоставления без учёта регистра по всему диапазону кодовых точек.
• 1.6 Уважение разрывов строк как любого из \u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A.
• 1.7 Работа на уровне кодовых точек.

Формат строки замены

Направление работы с фрагментами и нулевым выделением памяти

Лицензия:

Лицензия Boost 1.0.

Авторы:

Дмитрий Ольшанский, конструкции API и утилит смоделированы по оригинальным std.regex Уолтера Брайта и Андрея Александреску.

Исходный код

std/regex/package.d

шаблон Regex(Char)

Regex объект содержит шаблон регулярного выражения в скомпилированном виде.

Экземпляры этого объекта создаются с помощью вызовов regex. Это предполагаемая форма для кэширования и хранения часто используемых регулярных выражений.

Пример

Проверка, не содержит ли этот объект скомпилированных шаблонов.

Regex!char r;
assert(r.empty);
r = regex(""); // Note: "" is a valid regex pattern.
assert(!r.empty);

Получение диапазона всех именованных захватов в регулярном выражении.

import std.range;
import std.algorithm;

auto re = regex(`(?P<name>\w+) = (?P<var>\d+)`);
auto nc = re.namedCaptures;
static assert(isRandomAccessRange!(typeof(nc)));
assert(!nc.empty);
assert(nc.length == 2);
assert(nc.equal(["name", "var"]));
assert(nc[0] == "name");
assert(nc[1..$].equal(["var"]));

псевдоним StaticRegex = Regex(Char);

StaticRegex является Regex объектом, содержащим D-код, сгенерированный на этапе компиляции для ускорения поиска совпадений.

Больше не используется, сохраняется как псевдоним Regex для обратной совместимости.

@trusted auto regex(S : C[], C)(const S[] patterns, const(char)[] flags = "")
Ограничения: если (isSomeString!S);

@trusted auto regex(S)(S pattern, const(char)[] flags = "")
Ограничения: если (isSomeString!S);

Компиляция шаблона регулярного выражения для последующего выполнения.

Возвращает:

Regex объект, работающий с входными данными, имеющими такую же ширину символов, что и pattern.

Параметры:

S pattern	Одно регулярное выражение для поиска совпадений.
S[] patterns	Массив строк регулярных выражений. Результирующий Regex объект будет соответствовать любому выражению; используйте whichPattern, чтобы узнать, какое.
const(char)[] flags	Атрибуты (поддерживаются g, i, m, s и x)

Выбрасывает:

RegexException в случае возникновения ошибок во время компиляции.

Примеры:

void test(S)()
{
    // multi-pattern regex example
    S[] arr = [`([a-z]+):(\d+)`, `(\d+),\d+`];
    auto multi = regex(arr); // multi regex
    S str = "abc:43 12,34";
    auto m = str.matchAll(multi);
    writeln(m.front.whichPattern); // 1
    writeln(m.front[1]); // "abc"
    writeln(m.front[2]); // "43"
    m.popFront();
    writeln(m.front.whichPattern); // 2
    writeln(m.front[1]); // "12"
}

import std.meta : AliasSeq;
static foreach (C; AliasSeq!(string, wstring, dstring))
    // Test with const array of patterns - see https://issues.dlang.org/show_bug.cgi?id=20301
    static foreach (S; AliasSeq!(C, const C, immutable C))
        test!S();

enum auto ctRegex(alias pattern, alias flags = []);

Компиляция регулярного выражения с использованием CTFE и генерация оптимизированного машинного кода для поиска совпадений.

Возвращает:

Объект StaticRegex для более быстрого поиска совпадений.

Параметры:

pattern	Регулярное выражение
flags	Атрибуты (поддерживаются g, i, m, s и x)

структура Captures(R) если (isSomeString!R);

Captures объект содержит подстроки, захваченные во время вызова match или итерации по RegexMatch диапазону.

Первый элемент диапазона — это полное совпадение.

Примеры:

import std.range.primitives : popFrontN;

auto c = matchFirst("@abc#", regex(`(\w)(\w)(\w)`));
assert(c.pre == "@"); // Part of input preceding match
assert(c.post == "#"); // Immediately after match
assert(c.hit == c[0] && c.hit == "abc"); // The whole match
writeln(c[2]); // "b"
writeln(c.front); // "abc"
c.popFront();
writeln(c.front); // "a"
writeln(c.back); // "c"
c.popBack();
writeln(c.back); // "b"
popFrontN(c, 2);
assert(c.empty);

assert(!matchFirst("nothing", "something"));

// Captures that are not matched will be null.
c = matchFirst("ac", regex(`a(b)?c`));
assert(c);
assert(!c[1]);

@property R pre();

Часть входных данных перед совпадением.

@property R post();

Часть входных данных сразу после совпадения.

@property R hit();

Часть входных данных, соответствующая совпадению.

@property R front();

@property R back();

void popFront();

void popBack();

const @property bool empty();

inout inout(R) opIndex()(size_t i);

Интерфейс диапазона.

const nothrow @safe bool opCast(T : bool)();

Явное приведение к типу bool. Полезно как сокращение для !(x.empty) в операторах if и assert.

import std.regex;

assert(!matchFirst("nothing", "something"));

const nothrow @property @safe int whichPattern();

Номер сопоставленного шаблона (считая с 1 для первого шаблона). Возвращает 0 при отсутствии совпадения.

Примеры:

import std.regex;
writeln(matchFirst("abc", "[0-9]+", "[a-z]+").whichPattern); // 2

R opIndex(String)(String i)
Ограничения: если (isSomeString!String);

Поиск именованного подсовпадения.

import std.regex;
import std.range;

auto c = matchFirst("a = 42;", regex(`(?P<var>\w+)\s*=\s*(?P<value>\d+);`));
assert(c["var"] == "a");
assert(c["value"] == "42");
popFrontN(c, 2);
//named groups are unaffected by range primitives
assert(c["var"] =="a");
assert(c.front == "42");

const @property size_t length();

Количество совпадений в этом объекте.

@property ref auto captures();

Обратная совместимость с оригинальным std.regex.

структура RegexMatch(R) если (isSomeString!R);

Состояние движка регулярных выражений, возвращаемое семейством функций match.

По сути, это упорядоченный диапазон Captures!R, генерируемый ленивым поиском совпадений во входных данных.

@property R pre();

@property R post();

@property R hit();

Сокращения для front.pre, front.post, front.hit.

inout @property inout(Captures!R) front();

void popFront();

auto save();

Функциональность для обработки последующих совпадений глобальных регулярных выражений через интерфейс диапазона:

import std.regex;
auto m = matchAll("Hello, world!", regex(`\w+`));
assert(m.front.hit == "Hello");
m.popFront();
assert(m.front.hit == "world");
m.popFront();
assert(m.empty);

const @property bool empty();

Проверка, пуст ли этот объект совпадения.

T opCast(T : bool)();

То же, что и !(x.empty), представлено для удобства в условных операторах.

inout @property inout(Captures!R) captures();

То же, что и .front, для совместимости с оригинальным std.regex.

auto match(R, RegEx)(R input, RegEx re)
Ограничения: если (isSomeString!R && isRegexFor!(RegEx, R));

auto match(R, String)(R input, String re)
Ограничения: если (isSomeString!R && isSomeString!String);

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

Использование этой функции не рекомендуется — используйте либо matchAll, либо matchFirst.

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

Возвращает:

Объект RegexMatch, содержащий состояние движка после первого совпадения.

auto matchFirst(R, RegEx)(R input, RegEx re)
Ограничения: если (isSomeString!R && isRegexFor!(RegEx, R));

auto matchFirst(R, String)(R input, String re)
Ограничения: если (isSomeString!R && isSomeString!String);

auto matchFirst(R, String)(R input, String[] re...)
Ограничения: если (isSomeString!R && isSomeString!String);

Найти первую (самую левую) часть input, которая соответствует шаблону re. Эта функция выбирает наиболее подходящий движок регулярных выражений в зависимости от свойств шаблона.

Параметр re может быть одного из трех типов:

• Простая строка(и), в этом случае она компилируется в байткод перед поиском совпадений.
• Regex!char (wchar/dchar), содержащий шаблон в виде скомпилированного байткода.
• StaticRegex!char (wchar/dchar), содержащий шаблон в виде скомпилированного машинного кода.

Возвращает:

Captures, содержащий область совпадения и все подсовпадения, если совпадение найдено, иначе пустой Captures.

auto matchAll(R, RegEx)(R input, RegEx re)
Ограничения: если (isSomeString!R && isRegexFor!(RegEx, R));

auto matchAll(R, String)(R input, String re)
Ограничения: если (isSomeString!R && isSomeString!String);

auto matchAll(R, String)(R input, String[] re...)
Ограничения: если (isSomeString!R && isSomeString!String);

Начать поиск всех неперекрывающихся совпадений шаблону re в заданных input. Результат — ленивый диапазон совпадений, генерируемых по мере их обнаружения слева направо во входных данных.

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

Параметр re может быть одного из трех типов:

• Простая строка(и), в этом случае она компилируется в байткод перед поиском совпадений.
• Regex!char (wchar/dchar), содержащий шаблон в виде скомпилированного байткода.
• StaticRegex!char (wchar/dchar), содержащий шаблон в виде скомпилированного машинного кода.

Возвращает:

RegexMatch, представляющий состояние совпадения после нахождения первого совпадения, или пустой, если оно не найдено.

auto bmatch(R, RegEx)(R input, RegEx re)
Ограничения: если (isSomeString!R && isRegexFor!(RegEx, R));

auto bmatch(R, String)(R input, String re)
Ограничения: если (isSomeString!R && isSomeString!String);

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

Использование этой функции не рекомендуется — используйте либо matchAll, либо matchFirst.

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

Возвращает:

Объект RegexMatch, содержащий состояние движка после первого совпадения.

R replaceFirst(R, C, RegEx)(R input, RegEx re, const(C)[] format)
Constraints: if (isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

Создаёт новую строку из input, заменяя первое совпадение строкой, сгенерированной из неё согласно спецификатору format.

Для замены всех совпадений используйте replaceAll.

Параметры:

R input	строка для поиска
RegEx re	скомпилированное регулярное выражение для использования
const(C)[] format	строка формата для генерации замен, см. строку формата.

Возвращает:

Строку того же типа, с первым найденным совпадением (если есть) заменённым. Если совпадений не найдено, возвращается исходная строка.

Примеры:

writeln(replaceFirst("noon", regex("n"), "[$&]")); // "[n]oon"

R replaceFirst(alias fun, R, RegEx)(R input, RegEx re)
Constraints: if (isSomeString!R && isRegexFor!(RegEx, R));

Это универсальный инструмент для замены, который создаёт новую строку, заменяя совпадения шаблона re в input. В отличие от других перегрузок, нет строки формата; вместо этого, совпадения передаются пользовательскому функтору fun, который возвращает новую строку для замены.

Этот вариант заменяет первое совпадение в input, см. replaceAll для замены всех совпадений.

Возвращает:

Новую строку того же типа, что и input, со всеми совпадениями, заменёнными значениями, возвращёнными fun. Если совпадений не найдено, возвращается исходная input.

Примеры:

import std.conv : to;
string list = "#21 out of 46";
string newList = replaceFirst!(cap => to!string(to!int(cap.hit)+1))
    (list, regex(`[0-9]+`));
writeln(newList); // "#22 out of 46"

@trusted void replaceFirstInto(Sink, R, C, RegEx)(ref Sink sink, R input, RegEx re, const(C)[] format)
Constraints: if (isOutputRange!(Sink, dchar) && isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

@trusted void replaceFirstInto(alias fun, Sink, R, RegEx)(Sink sink, R input, RegEx re)
Constraints: if (isOutputRange!(Sink, dchar) && isSomeString!R && isRegexFor!(RegEx, R));

Вариант replaceFirst, который вместо выделения новой строки при каждом вызове выводит результат по частям в sink. Это позволяет эффективно строить окончательный результат по частям.

Как и в семействе функций replaceFirst, есть перегрузка для подстановки, управляемой строкой формата, и перегрузка с пользовательской функцией обратного вызова.

Примеры:

import std.array;
string m1 = "first message\n";
string m2 = "second message\n";
auto result = appender!string();
replaceFirstInto(result, m1, regex(`([a-z]+) message`), "$1");
//equivalent of the above with user-defined callback
replaceFirstInto!(cap=>cap[1])(result, m2, regex(`([a-z]+) message`));
writeln(result.data); // "first\nsecond\n"

@trusted R replaceAll(R, C, RegEx)(R input, RegEx re, const(C)[] format)
Constraints: if (isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

Создаёт новую строку из input, заменяя все фрагменты, соответствующие шаблону re, строкой, сгенерированной из совпадения согласно спецификатору format.

Для замены только первого совпадения используйте replaceFirst.

Параметры:

R input	строка для поиска
RegEx re	скомпилированное регулярное выражение для использования
const(C)[] format	строка формата для генерации замен, см. строку формата.

Возвращает:

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

Примеры:

// insert comma as thousands delimiter
auto re = regex(r"(?<=\d)(?=(\d\d\d)+\b)","g");
writeln(replaceAll("12000 + 42100 = 54100", re, ",")); // "12,000 + 42,100 = 54,100"

@trusted R replaceAll(alias fun, R, RegEx)(R input, RegEx re)
Constraints: if (isSomeString!R && isRegexFor!(RegEx, R));

Это универсальный инструмент для замены, который создаёт новую строку, заменяя совпадения шаблона re в input. В отличие от других перегрузок, нет строки формата; вместо этого, совпадения передаются пользовательскому функтору fun, который возвращает новую строку для замены.

Этот вариант заменяет все найденные совпадения в input, см. replaceFirst для замены только первого совпадения.

Возвращает:

Новую строку того же типа, что и input, со всеми совпадениями, заменёнными значениями, возвращёнными fun. Если совпадений не найдено, возвращается исходная input.

Параметры:

R input	строка для поиска
RegEx re	скомпилированное регулярное выражение
fun	делегат для использования

Примеры:

string baz(Captures!(string) m)
{
    import std.string : toUpper;
    return toUpper(m.hit);
}
// Capitalize the letters 'a' and 'r':
auto s = replaceAll!(baz)("Strap a rocket engine on a chicken.",
        regex("[ar]"));
writeln(s); // "StRAp A Rocket engine on A chicken."

@trusted void replaceAllInto(Sink, R, C, RegEx)(Sink sink, R input, RegEx re, const(C)[] format)
Constraints: if (isOutputRange!(Sink, dchar) && isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

@trusted void replaceAllInto(alias fun, Sink, R, RegEx)(Sink sink, R input, RegEx re)
Constraints: if (isOutputRange!(Sink, dchar) && isSomeString!R && isRegexFor!(RegEx, R));

Вариант replaceAll, который вместо выделения новой строки при каждом вызове выводит результат по частям в sink. Это позволяет эффективно строить окончательный результат по частям.

Как и в replaceAll, есть 2 перегрузки: одна со строкой формата, другая с пользовательским функтором.

Примеры:

// insert comma as thousands delimiter in fifty randomly produced big numbers
import std.array, std.conv, std.random, std.range;
static re = regex(`(?<=\d)(?=(\d\d\d)+\b)`, "g");
auto sink = appender!(char [])();
enum ulong min = 10UL ^^ 10, max = 10UL ^^ 19;
foreach (i; 0 .. 50)
{
    sink.clear();
    replaceAllInto(sink, text(uniform(min, max)), re, ",");
    foreach (pos; iota(sink.data.length - 4, 0, -4))
        writeln(sink.data[pos]); // ','
}

R replace(alias scheme = match, R, C, RegEx)(R input, RegEx re, const(C)[] format)
Constraints: if (isSomeString!R && isRegexFor!(RegEx, R));

R replace(alias fun, R, RegEx)(R input, RegEx re)
Constraints: if (isSomeString!R && isRegexFor!(RegEx, R));

Старый API для замены; операция зависит от флагов шаблона re. С флагом "g" он выполняет эквивалент replaceAll, в противном случае он работает так же, как replaceFirst.

Использование этой функции не рекомендуется, используйте replaceAll или replaceFirst явно.

struct Splitter(Flag!"keepSeparators" keepSeparators = No.keepSeparators, Range, alias RegEx = Regex) if (isSomeString!Range && isRegexFor!(RegEx, Range));

Splitter!(keepSeparators, Range, RegEx) splitter(Flag!"keepSeparators" keepSeparators = No.keepSeparators, Range, RegEx)(Range r, RegEx pat)
Constraints: if (is(BasicElementOf!Range : dchar) && isRegexFor!(RegEx, Range));

Разделяет строку r с помощью регулярного выражения pat в качестве разделителя.

Параметры:

keepSeparators	флаг, определяющий, должны ли совпадения включаться в результирующий диапазон
Range r	строка для разделения
RegEx pat	шаблон для разделения

Возвращает:

Ленивый диапазон строк

Примеры:

import std.algorithm.comparison : equal;
auto s1 = ", abc, de,  fg, hi, ";
assert(equal(splitter(s1, regex(", *")),
    ["", "abc", "de", "fg", "hi", ""]));

Примеры:

Разделение по шаблону, но с сохранением совпадений в результирующем диапазоне

import std.algorithm.comparison : equal;
import std.typecons : Yes;

auto pattern = regex(`([\.,])`);

assert("2003.04.05"
    .splitter!(Yes.keepSeparators)(pattern)
    .equal(["2003", ".", "04", ".", "05"]));

assert(",1,2,3"
    .splitter!(Yes.keepSeparators)(pattern)
    .equal([",", "1", ",", "2", ",", "3"]));

@property Range front();

@property bool empty();

void popFront();

@property auto save();

Примитивы для диапазонов вперёд.

@trusted String[] split(String, RegEx)(String input, RegEx rx)
Constraints: if (isSomeString!String && isRegexFor!(RegEx, String));

Жадный вариант splitter , который создаёт массив со сплитнутыми фрагментами input.

alias RegexException = std.regex.internal.ir.RegexException;

Объект исключения, выбрасываемый в случае ошибок во время компиляции регулярного выражения.

auto escaper(Range)(Range r);

Диапазон, лениво генерирующий строку, экранированную для использования внутри регулярного выражения.

Примеры:

import std.algorithm.comparison;
import std.regex;
string s = `This is {unfriendly} to *regex*`;
assert(s.escaper.equal(`This is \{unfriendly\} to \*regex\*`));