Класс QRegularExpression

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

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

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

Типы public

Функции public

Статические public члены

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

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

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

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

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

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

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

Введение

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

В функцию 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::exactMatch()

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

Перенос из точного соответствия QRegExp

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

Точное соответствие не отражено в QRegularExpression. Если вы хотите убедиться, что строка-предмет точно соответствует регулярному выражению, вы можете заключить шаблон в пару выражений привязки. В большинстве случаев достаточно поместить шаблон между ^ и $ якорями:

QRegularExpression re("^this pattern must match exactly$");

Однако, помните, что якорь $ соответствует не только концу строки, но и символу новой строки непосредственно перед концом строки; то есть, предыдущий шаблон соответствует строке "this pattern must match exactly\n". Кроме того, поведение обоих якорей ^ и $ изменяется, если параметр MultiLineOption установлен явно (как параметр шаблона) или неявно (как директива внутри строки шаблона).

Поэтому, в наиболее общем случае, вы должны заключить шаблон в \A и \z якоря:

QString p("a .*|pattern");
QRegularExpression re("\\A(?:" + p + ")\\z"); // re matches exactly the pattern string p

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

Метод-помощник QRegularExpression::anchoredPattern() делает это за вас.

Перенос из частичного соответствия 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 в ненулевое или нулевое значение, соответственно.

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

Создает объект QRegularExpression с пустым шаблоном и без параметров шаблона.

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

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

Создает объект QRegularExpression с заданным pattern как шаблоном и options как параметрами шаблона.

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

QRegularExpression::QRegularExpression(const QRegularExpression &re)

Создает объект QRegularExpression как копию re.

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

QRegularExpression::~QRegularExpression()

Удаляет объект QRegularExpression.

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

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

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

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

int QRegularExpression::captureCount() const

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

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

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

QString QRegularExpression::errorString() const

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

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

[static] QString QRegularExpression::escape(const QString &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);

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

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(const QString &pattern)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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