Класс QRegularExpression

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

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

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

Открытые типы

Открытые функции

Статические открытые члены

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

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

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

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

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

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

Введение

QRegularExpression реализует регулярные выражения, совместимые с Perl. Он полностью поддерживает Unicode. Для ознакомления с синтаксисом регулярных выражений, поддерживаемым QRegularExpression, обратитесь к упомянутой странице справки 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("\\\\");

В качестве альтернативы, вы можете использовать строковые литералы без экранирования, в этом случае вам не нужно экранировать обратные слэши в шаблоне, все символы между R"(...)" считаются необработанными символами. Как видно в следующем примере, это упрощает написание шаблонов:

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

Функция 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() для получения следующего результата без продвижения итератора.

Также можно просто использовать результат QRegularExpression::globalMatch в цикле for с диапазоном, например, так:

// using a raw string literal, R"(raw_characters)", to be able to use "\w"
// without having to escape the backslash as "\\w"
QRegularExpression re(R"(\w+)");
QString subject("the quick fox");
for (const QRegularExpressionMatch &match : re.globalMatch(subject)) {
    // ...
}

Можно передать начальное смещение и один или несколько параметров сопоставления в функцию 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.

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

QRegularExpression внутренне использует компилятор «just in time» (JIT) для оптимизации выполнения алгоритма сопоставления. JIT активно использует самомодифицируемый код, что может привести к зависанию инструментов отладки, таких как Valgrind. Вы должны включить все проверки самомодифицируемого кода, если вы хотите отладить программы, использующие QRegularExpression (например, опция командной строки Valgrind's --smc-check). Недостатком включения таких проверок является то, что ваша программа будет работать значительно медленнее.

Чтобы избежать этого, JIT по умолчанию отключён, если вы компилируете Qt в режиме отладки. Возможно переопределить значение по умолчанию и включить или отключить использование JIT (как в режиме отладки, так и в релизном) путём установки переменной окружения QT_ENABLE_REGEXP_JIT соответственно на ненулевое или нулевое значение.

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

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

перечисление QRegularExpression::MatchOptionфлаги QRegularExpression::MatchOptions

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

перечисление QRegularExpression::MatchType

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

enum QRegularExpression::PatternOptionflags QRegularExpression::PatternOptions

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

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

[since 6.0] enum QRegularExpression::WildcardConversionOptionflags QRegularExpression::WildcardConversionOptions

Перечисление WildcardConversionOption определяет модификаторы способа преобразования шаблона подстановок в шаблон регулярного выражения.

Это перечисление было добавлено или изменено в Qt 6.0.

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

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

[since 6.1] QRegularExpression::QRegularExpression(QRegularExpression &&re)

Создает объект QRegularExpression, перемещая данные из re.

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

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

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

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 &QRegularExpression::operator=(const QRegularExpression &re)

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

QRegularExpression::~QRegularExpression()

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

[static, since 5.15] QString QRegularExpression::anchoredPattern(QStringView expression)

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

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

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

Это перегруженный метод.

Этот метод был добавлен в Qt 5.12.

int QRegularExpression::captureCount() const

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

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

QString QRegularExpression::errorString() const

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

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

[static, since 5.15] 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);

Этот метод был добавлен в Qt 5.15.

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

Это перегруженный метод.

[static, since 6.0] QRegularExpression QRegularExpression::fromWildcard(QStringView pattern, Qt::CaseSensitivity cs = Qt::CaseInsensitive, QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

Возвращает регулярное выражение для шаблона glob pattern. Регулярное выражение будет чувствительным к регистру, если cs равен Qt::CaseSensitive, и преобразуется в соответствии с options.

Эквивалентно

auto reOptions = cs == Qt::CaseSensitive ? QRegularExpression::NoPatternOption :
                                           QRegularExpression::CaseInsensitiveOption;
return QRegularExpression(wildcardToRegularExpression(str, options), reOptions);

Этот метод был добавлен в Qt 6.0.

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

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

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

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

[since 6.0] QRegularExpressionMatchIterator QRegularExpression::globalMatch(QStringView subjectView, qsizetype offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

Это перегруженный метод.

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

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

Этот метод был добавлен в Qt 6.0.

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

bool QRegularExpression::isValid() const

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

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

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

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

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

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

[since 6.0] QRegularExpressionMatch QRegularExpression::match(QStringView subjectView, qsizetype offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

Это перегруженный метод.

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

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

Этот метод был добавлен в Qt 6.0.

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

[since 5.1] 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 есть имя «день», у захватывающей группы #2 есть имя «месяц» и т. д.

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

Этот метод был добавлен в Qt 5.1.

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

[since 5.4] void QRegularExpression::optimize() const

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

Этот метод был добавлен в Qt 5.4.

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

QString QRegularExpression::pattern() const

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

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

qsizetype 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 с этим регулярным выражением. Эта операция очень быстрая и никогда не терпит неудачу.

QString QRegularExpression::wildcardToRegularExpression(QStringView pattern, QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

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

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

Эта реализация тесно следует определению шаблона для шаблонов глобов:

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

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

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

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

QString QRegularExpression::wildcardToRegularExpression(const QString &pattern, QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

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

Эта функция была введена в 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!=().