Класс QRegularExpression

Класс QRegularExpression предоставляет сопоставление с образцом с использованием регулярных выражений. Подробнее...

Этот класс был представлен в Qt 5.0.

• Список всех членов, включая унаследованные

Примечание: Все функции в этом классе являются реентерабельными.

Типы публичного доступа

Функции публичного доступа

Статические публичные члены

Связанные нечлены

Подробное описание

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

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

Хорошие ссылки по регулярным выражениям включают:

• Mastering Regular Expressions (Третье издание) Джеффри Е. Ф. Фридл, ISBN 0-596-52812-4;
• страницу pcrepattern(3) man, описывающую синтаксис шаблонов, поддерживаемый PCRE (реализацией по умолчанию регулярных выражений, совместимых с Perl);
• документацию регулярных выражений Perl здесь и учебник по регулярным выражениям Perl здесь.

Введение

QRegularExpression реализует регулярные выражения, совместимые с Perl. Он полностью поддерживает Unicode. Для обзора синтаксиса регулярных выражений, поддерживаемого QRegularExpression, обратитесь к упомянутой выше странице man pcrepattern(3). Регулярное выражение состоит из двух частей: строки шаблона и набора параметров шаблона, изменяющих смысл строки шаблона.

Вы можете установить строку шаблона, передав строку конструктору QRegularExpression:

QRegularExpression re("a pattern");

Это устанавливает строку шаблона в a pattern. Вы также можете использовать функцию setPattern() для установки шаблона для существующего объекта QRegularExpression:

QRegularExpression re;
re.setPattern("another pattern");

Обратите внимание, что из-за правил строк-литералов C++, все обратные слэши внутри строки шаблона должны быть экранированы ещё одним обратным слэшем:

// matches two digits followed by a space and a word
QRegularExpression re("\\d\\d \\w+");

// matches a backslash
QRegularExpression re2("\\\\");

Функция pattern() возвращает шаблон, который в данный момент установлен для объекта QRegularExpression:

QRegularExpression re("a third pattern");
QString pattern = re.pattern(); // pattern == "a third pattern"

Параметры шаблона

Значение строки шаблона может быть изменено установкой одного или нескольких параметров шаблона. Например, можно установить шаблон для поиска без учёта регистра, установив QRegularExpression::CaseInsensitiveOption.

Вы можете установить параметры, передав их в конструктор QRegularExpression, как показано ниже:

// matches "Qt rocks", but also "QT rocks", "QT ROCKS", "qT rOcKs", etc.
QRegularExpression re("Qt rocks", QRegularExpression::CaseInsensitiveOption);

В качестве альтернативы, вы можете использовать функцию setPatternOptions() для существующего объекта QRegularExpression:

QRegularExpression re("^\\d+$");
re.setPatternOptions(QRegularExpression::MultilineOption);
// re matches any line in the subject string that contains only digits (but at least one)

Получить текущие параметры шаблона объекта QRegularExpression можно с помощью функции patternOptions():

QRegularExpression re = QRegularExpression("^two.*words$", QRegularExpression::MultilineOption
                                                           | QRegularExpression::DotMatchesEverythingOption);

QRegularExpression::PatternOptions options = re.patternOptions();
// options == QRegularExpression::MultilineOption | QRegularExpression::DotMatchesEverythingOption

Для получения дополнительной информации о каждом параметре шаблона обратитесь к документации перечисления QRegularExpression::PatternOption.

Тип совпадения и параметры совпадения

Последние два аргумента функций match() и globalMatch() устанавливают тип совпадения и параметры совпадения. Тип совпадения — это значение из перечисления QRegularExpression::MatchType; «традиционный» алгоритм поиска выбирается с помощью типа совпадения NormalMatch (по умолчанию). Также можно включить частичное соответствие регулярного выражения строке-объекту: см. раздел частичного соответствия для получения дополнительной информации.

Параметры совпадения — это набор одного или нескольких значений QRegularExpression::MatchOption. Они изменяют способ выполнения конкретного поиска регулярного выражения в строке-объекте. Для получения дополнительной информации обратитесь к документации перечисления QRegularExpression::MatchOption.

Обычный поиск

Чтобы выполнить поиск, можно просто вызвать функцию match(), передав строку для поиска. Мы будем называть эту строку строкой-объектом. Результатом функции match() является объект QRegularExpressionMatch, который можно использовать для проверки результатов поиска. Например:

// match two digits followed by a space and a word
QRegularExpression re("\\d\\d \\w+");
QRegularExpressionMatch match = re.match("abc123 def");
bool hasMatch = match.hasMatch(); // true

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

QRegularExpression re("\\d\\d \\w+");
QRegularExpressionMatch match = re.match("abc123 def");
if (match.hasMatch()) {
    QString matched = match.captured(0); // matched == "23 def"
    // ...
}

Также можно начать поиск с произвольного смещения внутри строки-объекта, передав смещение как аргумент функции match(). В следующем примере "12 abc" не будет найдено, так как поиск начинается со смещения 1:

QRegularExpression re("\\d\\d \\w+");
QRegularExpressionMatch match = re.match("12 abc 45 def", 1);
if (match.hasMatch()) {
    QString matched = match.captured(0); // matched == "45 def"
    // ...
}

Извлечение захваченных подстрок

Объект QRegularExpressionMatch также содержит информацию о подстроках, захваченных группами захвата в строке шаблона. Функция captured() вернёт строку, захваченную n-ой группой захвата:

QRegularExpression re("^(\\d\\d)/(\\d\\d)/(\\d\\d\\d\\d)$");
QRegularExpressionMatch match = re.match("08/12/1985");
if (match.hasMatch()) {
    QString day = match.captured(1); // day == "08"
    QString month = match.captured(2); // month == "12"
    QString year = match.captured(3); // year == "1985"
    // ...
}

Группы захвата в шаблоне нумеруются, начиная с 1, а неявная группа захвата 0 используется для захвата подстроки, совпадающей со всем шаблоном.

Также можно получить начальное и конечное смещения (в строке-объекте) каждой захваченной подстроки, используя функции capturedStart() и capturedEnd():

QRegularExpression re("abc(\\d+)def");
QRegularExpressionMatch match = re.match("XYZabc123defXYZ");
if (match.hasMatch()) {
    int startOffset = match.capturedStart(1); // startOffset == 6
    int endOffset = match.capturedEnd(1); // endOffset == 9
    // ...
}

Все эти функции имеют перегрузку, принимающую QString в качестве параметра для извлечения именованных захваченных подстрок. Например:

QRegularExpression re("^(?<date>\\d\\d)/(?<month>\\d\\d)/(?<year>\\d\\d\\d\\d)$");
QRegularExpressionMatch match = re.match("08/12/1985");
if (match.hasMatch()) {
    QString date = match.captured("date"); // date == "08"
    QString month = match.captured("month"); // month == "12"
    QString year = match.captured("year"); // year == 1985
}

Поиск всех совпадений

Глобальный поиск полезен для поиска всех вхождений заданного регулярного выражения в строке-объекте. Предположим, нам нужно извлечь все слова из заданной строки, где слово — это подстрока, соответствующая шаблону \w+.

QRegularExpression::globalMatch возвращает QRegularExpressionMatchIterator, который является итератором вперёд, подобным Java-итератору, который можно использовать для перебора результатов. Например:

QRegularExpression re("(\\w+)");
QRegularExpressionMatchIterator i = re.globalMatch("the quick fox");

Поскольку это итератор, подобный Java-итератору, QRegularExpressionMatchIterator указывает сразу перед первым результатом. Каждый результат возвращается как объект QRegularExpressionMatch. Функция hasNext() возвращает true, если есть хотя бы один результат, а next() возвращает следующий результат и перемещает итератор вперёд. Продолжая с предыдущего примера:

QStringList words;
while (i.hasNext()) {
    QRegularExpressionMatch match = i.next();
    QString word = match.captured(1);
    words << word;
}
// words contains "the", "quick", "fox"

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

Можно передать начальное смещение и один или несколько параметров совпадения в функцию globalMatch(), точно так же, как при обычном поиске с функцией match().

Частичное соответствие

Частичное соответствие возникает, когда конец строки-объекта достигнут, но для успешного завершения поиска необходимы дополнительные символы. Обратите внимание, что частичный поиск обычно намного менее эффективен, чем обычный поиск, потому что многие оптимизации алгоритма поиска не могут быть применены.

Частичное соответствие должно быть явно запрошено путем указания типа совпадения PartialPreferCompleteMatch или PartialPreferFirstMatch при вызове QRegularExpression::match или QRegularExpression::globalMatch. Если частичное соответствие найдено, то вызов функции hasMatch() для объекта QRegularExpressionMatch, возвращаемого match(), вернёт false, но hasPartialMatch() вернёт true.

При обнаружении частичного соответствия захваченные подстроки не возвращаются, и (неявная) группа захвата 0, соответствующая всему выражению, захватывает частично совпавшую подстроку строки-объекта.

Обратите внимание, что запрос частичного соответствия может всё ещё привести к полному соответствию, если оно найдено; в этом случае hasMatch() вернёт true и hasPartialMatch() false. Никогда не происходит, чтобы QRegularExpressionMatch сообщала как о частичном, так и о полном соответствии.

Частичное соответствие в основном полезно в двух сценариях: валидация пользовательского ввода в реальном времени и инкрементный/многосегментный поиск.

Валидация пользовательского ввода

Предположим, что мы хотим, чтобы пользователь ввёл дату в определённом формате, например, "MMM dd, yyyy". Мы можем проверить корректность ввода с помощью шаблона:

^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d\d?, \d\d\d\d$

(Этот шаблон не проверяет некорректные дни, но мы оставим его для целей примера).

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

• ввод, который не может соответствовать регулярному выражению;
• ввод, который соответствует регулярному выражению;
• ввод, который не соответствует регулярному выражению прямо сейчас, но будет соответствовать, если к нему будут добавлены символы.

Обратите внимание, что эти три случая точно соответствуют возможным состояниям QValidator (см. перечисление QValidator::State).

В частности, в последнем случае мы хотим, чтобы движок регулярных выражений сообщал о частичном соответствии: мы успешно ищем шаблон в строке-объекте, но поиск не может продолжаться, так как достигнут конец строки-объекта. Обратите внимание, что алгоритм поиска должен продолжать работу и проверять все варианты, и если найдено полное (не частичное) соответствие, то оно должно быть сообщено, и строка ввода должна быть принята как полностью корректная.

Это поведение реализуется типом совпадения PartialPreferCompleteMatch. Например:

QString pattern("^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d\\d?, \\d\\d\\d\\d$");
QRegularExpression re(pattern);

QString input("Jan 21,");
QRegularExpressionMatch match = re.match(input, 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true

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

QString input("Dec 8, 1985");
QRegularExpressionMatch match = re.match(input, 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // true
bool hasPartialMatch = match.hasPartialMatch(); // false

Другой пример с другим шаблоном, демонстрирующий поведение, когда предпочтение отдаётся полному соответствию над частичным:

QRegularExpression re("abc\\w+X|def");
QRegularExpressionMatch match = re.match("abcdef", 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // true
bool hasPartialMatch = match.hasPartialMatch(); // false
QString captured = match.captured(0); // captured == "def"

В этом случае подшаблон abc\\w+X частично соответствует строке-объекту; однако, подшаблон def полностью соответствует строке-объекту, и поэтому сообщается о полном соответствии.

Если при поиске найдено несколько частичных соответствий (но нет полного соответствия), то объект QRegularExpressionMatch сообщит о первом найденном.

QRegularExpression re("abc\\w+X|defY");
QRegularExpressionMatch match = re.match("abcdef", 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true
QString captured = match.captured(0); // captured == "abcdef"

Инкрементальное/многосегментное сопоставление

Инкрементальное сопоставление — это ещё один пример частичного сопоставления. Предположим, что мы хотим найти вхождения регулярного выражения в большой текст (то есть подстроки, соответствующие регулярному выражению). Для этого мы хотели бы «подать» большой текст в движок регулярных выражений частями. Очевидная проблема заключается в том, что произойдёт, если подстрока, соответствующая регулярному выражению, охватывает две или более частей.

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

QRegularExpression реализует это поведение при использовании типа сопоставления PartialPreferFirstMatch. Этот тип сопоставления сообщает о частичном соответствии, как только оно найдено, и другие альтернативные варианты сопоставления не проверяются (даже если они могли бы привести к полному соответствию). Например:

QRegularExpression re("abc|ab");
QRegularExpressionMatch match = re.match("ab", 0, QRegularExpression::PartialPreferFirstMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true

Это происходит потому, что при сопоставлении первого раздела оператора «или» находится частичное соответствие, и поэтому сопоставление останавливается, не проверяя второй раздел. Ещё один пример:

QRegularExpression re("abc(def)?");
QRegularExpressionMatch match = re.match("abc", 0, QRegularExpression::PartialPreferFirstMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true

Это демонстрирует то, что может показаться неинтуитивным поведением квантификаторов: так как ? жадный, то движок сначала пытается продолжить сопоставление после сопоставления "abc"; но затем сопоставление достигает конца строки-объекта, и поэтому сообщается о частичном соответствии. Это ещё более удивительно в следующем примере:

QRegularExpression re("(abc)*");
QRegularExpressionMatch match = re.match("abc", 0, QRegularExpression::PartialPreferFirstMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true

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

Поскольку * квантификатор жадный, то сообщение о полном соответствии может быть ошибкой, потому что после текущей строки-объекта "abc" могут существовать другие вхождения "abc". Например, весь текст мог быть «abcabcX», и поэтому правильным соответствием (в полном тексте) должно было быть "abcabc"; но сопоставление только с начальной "abc" вместо этого даёт частичное соответствие.

Обработка ошибок

Объект QRegularExpression может быть невалидным из-за синтаксических ошибок в строке шаблона. Функция isValid() вернёт true, если регулярное выражение валидно, или false в противном случае:

QRegularExpression invalidRe("(unmatched|parenthesis");
bool isValid = invalidRe.isValid(); // false

Более подробную информацию об определённой ошибке можно получить, вызвав функцию errorString(); кроме того, функция patternErrorOffset() вернёт смещение в строке шаблона

QRegularExpression invalidRe("(unmatched|parenthesis");
if (!invalidRe.isValid()) {
    QString errorString = invalidRe.errorString(); // errorString == "missing )"
    int errorOffset = invalidRe.patternErrorOffset(); // errorOffset == 22
    // ...
}

Если попытка сопоставления выполняется с невалидным объектом QRegularExpression, то возвращаемый объект QRegularExpressionMatch также будет невалидным (то есть, его функция isValid() вернёт false). То же самое относится к попытке глобального сопоставления.

Неподдерживаемые функции Perl-совместимых регулярных выражений

QRegularExpression не поддерживает все функции, доступные в Perl-совместимых регулярных выражениях. Самой заметной является то, что дублирование имён для групп захвата не поддерживается, и использование их может привести к неопределённому поведению.

Это может измениться в будущей версии Qt.

Примечания для пользователей QRegExp

Класс QRegularExpression, представленный в Qt 5, является значительным улучшением по сравнению с QRegExp с точки зрения предлагаемых API, поддерживаемого синтаксиса шаблонов и скорости выполнения. Самое большое отличие заключается в том, что QRegularExpression просто хранит регулярное выражение, и оно не изменяется при запросе сопоставления. Вместо этого возвращается объект QRegularExpressionMatch, чтобы проверить результат сопоставления и извлечь захваченную подстроку. То же самое относится к глобальному сопоставлению и QRegularExpressionMatchIterator.

Другие различия описаны ниже.

Разный синтаксис шаблонов

Перевод регулярного выражения из QRegExp в QRegularExpression может потребовать изменений в самом шаблоне.

В некоторых сценариях QRegExp была слишком снисходительной и принимала шаблоны, которые просто невалидны при использовании QRegularExpression. Их как-то легко обнаружить, потому что объекты QRegularExpression, созданные с этими шаблонами, не являются валидными (см. isValid()).

В других случаях шаблон, перенесённый из QRegExp в QRegularExpression, может беззвучно изменить семантику. Поэтому необходимо пересмотреть используемые шаблоны. Наиболее заметными случаями беззвучной несовместимости являются:

• Двойные фигурные скобки необходимы для использования шестнадцатеричного эскейпа, такого как \xHHHH с более чем 2 цифрами. Шаблон, такой как \x2022 должен быть перенесён в \x{2022}, иначе он будет соответствовать пробелу (0x20) и строке "22". В общем случае крайне рекомендуется всегда использовать фигурные скобки с эскейпом \x независимо от количества указанных цифр.
• Квантификация от 0 до n, как {,n} должна быть перенесена в {0,n} для сохранения семантики. В противном случае шаблон, такой как \d{,3} фактически будет соответствовать цифре и строке "{,3}".
• QRegExp по умолчанию выполняет сопоставление с учётом Unicode, в то время как QRegularExpression требует отдельного параметра; см. ниже для получения дополнительной информации.

Перевод из QRegExp::exactMatch()

QRegExp::exactMatch() в Qt 4 выполняла две задачи: точно сопоставляла регулярное выражение с строкой-объектом и реализовывала частичное сопоставление.

Перевод точного сопоставления из QRegExp

Точное сопоставление указывает, соответствует ли регулярное выражение всей строке-объекту. Например, классы обрабатывают строку-объект "abc123":

Точное сопоставление не отражено в QRegularExpression. Если вы хотите убедиться, что строка-объект точно соответствует регулярному выражению, вы можете обернуть шаблон с помощью функции anchoredPattern():

QString p("a .*|pattern");

// re matches exactly the pattern string p
QRegularExpression re(QRegularExpression::anchoredPattern(p));

Перевод частичного сопоставления из QRegExp

При использовании QRegExp::exactMatch(), если точное соответствие не найдено, можно узнать, какая часть строки-объекта была сопоставлена с регулярным выражением, вызвав QRegExp::matchedLength(). Если возвращённая длина равна длине строки-объекта, можно сделать вывод, что найдено частичное соответствие.

QRegularExpression явно поддерживает частичное сопоставление с помощью соответствующего типа MatchType.

Глобальное сопоставление

Из-за ограничений API QRegExp невозможно было правильно реализовать глобальное сопоставление (то есть, как в Perl). В частности, шаблоны, которые могут соответствовать 0 символам (например, "a*"), представляют собой проблему.

QRegularExpression::globalMatch() правильно реализует глобальное сопоставление Perl, и возвращаемый итератор можно использовать для проверки каждого результата.

Поддержка свойств Unicode

При использовании QRegExp, классы символов, такие как \w, \d, и т. д., соответствуют символам с соответствующим свойством Unicode: например, \d соответствует любому символу со свойством Unicode Nd (десятичная цифра).

Эти классы символов по умолчанию соответствуют только символам ASCII при использовании QRegularExpression: например, \d точно соответствует символу в диапазоне 0-9 ASCII. Можно изменить это поведение, используя параметр шаблона UseUnicodePropertiesOption.

Сопоставление с подстановочными знаками

Нет прямого способа выполнить сопоставление с подстановочными знаками в QRegularExpression. Однако для этой цели предоставляется метод wildcardToRegularExpression для перевода шаблонов glob в Perl-совместимое регулярное выражение.

Другие синтаксисы шаблонов

QRegularExpression поддерживает только Perl-совместимые регулярные выражения.

Минимальное сопоставление

QRegExp::setMinimal() реализовывала минимальное сопоставление, просто изменив жадность квантификаторов (QRegExp не поддерживала ленивые квантификаторы, такие как *?, +?, и т. д.). QRegularExpression вместо этого поддерживает жадные, ленивые и собственнические квантификаторы. Параметр шаблона InvertedGreedinessOption может быть полезен для эмуляции эффектов QRegExp::setMinimal(): если он включён, он инвертирует жадность квантификаторов (жадные становятся ленивыми и наоборот).

Режимы возведения в степень

Параметр сопоставления AnchoredMatchOption можно использовать для эмуляции поведения QRegExp::CaretAtOffset. Нет эквивалента для других режимов QRegExp::CaretMode.

Отладка кода, использующего QRegularExpression

QRegularExpression внутренне использует компилятор JIT (Just-In-Time) для оптимизации выполнения алгоритма сопоставления. JIT активно использует самомодифицирующийся код, что может привести к сбою таких средств отладки, как Valgrind. Если вы хотите отладить программы, использующие QRegularExpression, необходимо включить все проверки самомодифицирующегося кода (например, параметр командной строки Valgrind --smc-check). Недостатком включения таких проверок является то, что ваша программа будет работать значительно медленнее.

Для предотвращения этого, JIT отключен по умолчанию, если вы компилируете Qt в режиме отладки. Можно переопределить значение по умолчанию и включить или выключить использование JIT (как в режиме отладки, так и в релизном режиме), установив переменную среды QT_ENABLE_REGEXP_JIT соответственно на ненулевое или нулевое значение.

См. также QRegularExpressionMatch и QRegularExpressionMatchIterator.

Документация по типам членов

enum QRegularExpression::MatchOptionflags QRegularExpression::MatchOptions

Тип MatchOptions является псевдонимом для QFlags<MatchOption>. Он хранит логическое ИЛИ комбинацию значений MatchOption.

enum QRegularExpression::MatchType

Перечисление MatchType определяет тип сопоставления, которое должно быть выполнено со строкой-подлежащей.

enum QRegularExpression::PatternOptionflags QRegularExpression::PatternOptions

Перечисление PatternOption определяет модификаторы способа интерпретации строки шаблона, а следовательно, и способа сопоставления шаблона со строкой-подлежащей.

Тип PatternOptions является псевдонимом для QFlags<PatternOption>. Он хранит логическое ИЛИ комбинацию значений PatternOption.

Документация по членам-функциям

QRegularExpression::QRegularExpression(const QRegularExpression &re)

Конструирует объект QRegularExpression как копию re.

См. также operator=().

QRegularExpression::QRegularExpression(const QString &pattern, QRegularExpression::PatternOptions options = NoPatternOption)

Конструирует объект QRegularExpression, используя заданный pattern в качестве шаблона и options как опции шаблона.

См. также setPattern() и setPatternOptions().

QRegularExpression::QRegularExpression()

Конструирует объект QRegularExpression с пустым шаблоном и без опций шаблона.

См. также setPattern() и setPatternOptions().

QRegularExpression &QRegularExpression::operator=(QRegularExpression &&re)

Перемещающее присваивание регулярного выражения re этому объекту и возвращает ссылку на копию. И шаблон, и опции шаблона копируются.

QRegularExpression &QRegularExpression::operator=(const QRegularExpression &re)

Присваивает регулярное выражение re этому объекту и возвращает ссылку на копию. Копируются как шаблон, так и опции шаблона.

QRegularExpression::~QRegularExpression()

Уничтожает объект QRegularExpression.

[static] QString QRegularExpression::anchoredPattern(QStringView expression)

Возвращает expression, заключённую между якорями \A и \z, для использования в точном соответствии.

Эта функция была введена в Qt 5.15.

См. также Перенос из точного соответствия QRegExp.

[static] QString QRegularExpression::anchoredPattern(const QString &expression)

Это перегруженная функция.

Эта функция была введена в Qt 5.12.

int QRegularExpression::captureCount() const

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

Примечание: Неявная захватывающая группа 0 не включается в возвращаемое число.

См. также isValid().

QString QRegularExpression::errorString() const

Возвращает текстовое описание ошибки, обнаруженной при проверке корректности регулярного выражения, или «нет ошибки», если ошибка не найдена.

См. также isValid() и patternErrorOffset().

[static] QString QRegularExpression::escape(QStringView str)

Экранирует все символы str, чтобы они больше не имели специального значения при использовании в качестве строки шаблона регулярного выражения, и возвращает экранированную строку. Например:

QString escaped = QRegularExpression::escape("a(x) = f(x) + g(x)");
// escaped == "a\\(x\\)\\ \\=\\ f\\(x\\)\\ \\+\\ g\\(x\\)"

Это очень удобно для построения шаблонов из произвольных строк:

QString pattern = "(" + QRegularExpression::escape(name) +
                  "|" + QRegularExpression::escape(nickname) + ")";
QRegularExpression re(pattern);

Примечание: Эта функция реализует алгоритм Perl's quotemeta и экранирует обратной косой чертой все символы в str, за исключением символов в диапазонах [A-Z], [a-z] и [0-9], а также символа подчёркивания (_). Единственное отличие от Perl заключается в том, что литеральный NUL внутри str экранируется последовательностью "\\0" (обратная косая черта + '0') вместо "\\\0" (обратная косая черта + NUL).

Эта функция была введена в Qt 5.15.

[static] QString QRegularExpression::escape(const QString &str)

Это перегруженная функция.

QRegularExpressionMatchIterator QRegularExpression::globalMatch(const QString &subject, int offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

Попытка выполнить глобальный поиск регулярного выражения в данной строке subject, начиная с позиции offset внутри объекта, используя тип поиска matchType и учитывая заданные matchOptions.

Возвращаемый QRegularExpressionMatchIterator находится перед первым результатом соответствия (если таковой имеется).

См. также QRegularExpressionMatchIterator и глобальный поиск.

QRegularExpressionMatchIterator QRegularExpression::globalMatch(const QStringRef &subjectRef, int offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

Это перегруженная функция.

Попытка выполнить глобальный поиск регулярного выражения в указанной ссылке на строку subjectRef, начиная с позиции offset внутри объекта, используя тип поиска matchType и учитывая заданные matchOptions.

Возвращаемый QRegularExpressionMatchIterator находится перед первым результатом соответствия (если таковой имеется).

Эта функция была введена в Qt 5.5.

См. также QRegularExpressionMatchIterator и глобальный поиск.

bool QRegularExpression::isValid() const

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

См. также errorString() и patternErrorOffset().

QRegularExpressionMatch QRegularExpression::match(const QString &subject, int offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

Попытка сопоставить регулярное выражение с заданной строкой subject, начиная с позиции offset внутри объекта, используя тип поиска matchType и учитывая заданные matchOptions.

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

См. также QRegularExpressionMatch и обычный поиск.

QRegularExpressionMatch QRegularExpression::match(const QStringRef &subjectRef, int offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

Это перегруженная функция.

Попытка сопоставить регулярное выражение с указанной ссылкой на строку subjectRef, начиная с позиции offset внутри объекта, используя тип поиска matchType и учитывая заданные matchOptions.

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

Эта функция была введена в Qt 5.5.

См. также QRegularExpressionMatch и обычный поиск.

QStringList QRegularExpression::namedCaptureGroups() const

Возвращает список из captureCount() + 1 элементов, содержащих имена именованных захватывающих групп в строке шаблона. Список отсортирован таким образом, что элемент списка на позиции i — это имя i-й захватывающей группы, если оно есть, или пустая строка, если эта захватывающая группа не имеет имени.

Например, для регулярного выражения

    (?<day>\d\d)-(?<month>\d\d)-(?<year>\d\d\d\d) (\w+) (?<name>\w+)

namedCaptureGroups() вернёт следующий список:

    ("", "day", "month", "year", "", "name")

что соответствует тому факту, что у захватывающей группы #0 (соответствующей всему совпадению) нет имени, у захватывающей группы #1 есть имя «day», у захватывающей группы #2 есть имя «month» и т.д.

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

Эта функция была введена в Qt 5.1.

См. также isValid(), QRegularExpressionMatch::captured() и QString::isEmpty().

void QRegularExpression::optimize() const

Компилирует шаблон немедленно, включая JIT-компиляцию (если JIT включён) для оптимизации.

Эта функция была введена в Qt 5.4.

См. также isValid() и Отладка кода, использующего QRegularExpression.

QString QRegularExpression::pattern() const

Возвращает строку шаблона регулярного выражения.

См. также setPattern() и patternOptions().

int QRegularExpression::patternErrorOffset() const

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

См. также pattern(), isValid() и errorString().

QRegularExpression::PatternOptions QRegularExpression::patternOptions() const

Возвращает опции шаблона для регулярного выражения.

См. также setPatternOptions() и pattern().

void QRegularExpression::setPattern(const QString &pattern)

Устанавливает строку шаблона регулярного выражения на pattern. Опции шаблона остаются неизменными.

См. также pattern() и setPatternOptions().

void QRegularExpression::setPatternOptions(QRegularExpression::PatternOptions options)

Устанавливает заданные options в качестве опций шаблона регулярного выражения. Строка шаблона остается неизменной.

См. также patternOptions() и setPattern().

void QRegularExpression::swap(QRegularExpression &other)

Меняет местами регулярное выражение other с текущим регулярным выражением. Эта операция очень быстрая и никогда не терпит неудачу.

[static] QString QRegularExpression::wildcardToRegularExpression(QStringView pattern)

Возвращает представление регулярного выражения для данного шаблона pattern. Преобразование нацелено на сопоставление с шаблонами путей файлов, что означает, в частности, что разделители путей обрабатываются особым образом. Это подразумевает, что это не просто базовое преобразование из "*" в ".*".

QString wildcard = QRegularExpression::wildcardToRegularExpression("*.jpeg");
// Will match files with names like:
//    foo.jpeg
//    f_o_o.jpeg
//    föö.jpeg

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

Предупреждение: В отличие от QRegExp, эта реализация тесно следует определению шаблона для шаблонов glob:

Примечание: Символ обратной косой черты (\) не является символом экранирования в данном контексте. Для соответствия одному из специальных символов поместите его в квадратные скобки (например, [?]).

Дополнительную информацию об реализации можно найти в:

• Статье Википедии о шаблонах glob
• man 7 glob

Эта функция была добавлена в Qt 5.15.

См. также escape().

[static] QString QRegularExpression::wildcardToRegularExpression(const QString &pattern)

Это перегруженная функция.

Эта функция была добавлена в Qt 5.12.

bool QRegularExpression::operator!=(const QRegularExpression &re) const

Возвращает true , если регулярное выражение отличается от re, или false в противном случае.

См. также operator==().

bool QRegularExpression::operator==(const QRegularExpression &re) const

Возвращает true , если регулярное выражение равно re, или false в противном случае. Два объекта QRegularExpression равны, если у них одинаковая строка шаблона и одинаковые опции шаблона.

См. также operator!=().