Класс QRegularExpression

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

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

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

Типы

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

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

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

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

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

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

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

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

Введение

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("\\\\");

Функция 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 с диапазоном, например, так:

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 --smc-check). Недостатком включения таких проверок является то, что ваша программа будет работать значительно медленнее.

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

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

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

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

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

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

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

перечисление QRegularExpression::PatternOptionфлаги QRegularExpression::PatternOptions

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

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

[since 6.0] перечисление QRegularExpression::WildcardConversionOptionфлаги QRegularExpression::WildcardConversionOptions

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

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

Тип WildcardConversionOptions — это typedef для QFlags<WildcardConversionOption>. Он хранит комбинацию значений WildcardConversionOption по оператору ИЛИ.

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

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, 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, если регулярное выражение не является допустимым.

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

См. также 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);

Примечание: Эта функция реализует алгоритм 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)

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

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

Возвращает регулярное выражение для шаблона подстановок 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 расположен перед первым результатом совпадения (если таковой есть).

Примечание: Данные, к которым ссылается subjectView, должны оставаться валидными, пока существуют объекты QRegularExpressionMatchIterator или QRegularExpressionMatch, использующие их.

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

Примечание: Данные, к которым ссылается subjectView, должны оставаться валидными, пока существуют объекты 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 есть имя "day", у группы захвата #2 есть имя "month" и т.д.

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

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

[static, since 5.15] QString QRegularExpression::wildcardToRegularExpression(QStringView pattern, QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

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

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

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

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

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

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

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

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

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

[static, since 5.12] 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!=().