QRegularExpression Class

상세 설명

정규 표현식( regex)은 문자열과 텍스트를 처리하는 데 매우 강력한 도구입니다. 이는 다음과 같은 다양한 상황에서 유용하게 사용됩니다. 예를 들어,

이 문서는 정규식을 사용한 패턴 매칭에 대한 완전한 참고 자료가 아니며, 다음 부분들을 이해하려면 독자가 Perl 계열 정규식과 그 패턴 구문에 대한 기본적인 지식을 갖추고 있어야 합니다.

정규 표현식에 대한 유용한 참고 자료로는 다음이 있습니다:

• Jeffrey E. F. Friedl의『Mastering Regular Expressions 』(제3판), ISBN 0-596-52812-4;
• PCRE(Perl 호환 정규 표현식의 참조 구현체)에서 지원하는 패턴 구문을 설명하는 pcrepattern(3) 매뉴얼 페이지;
• Perl 정규 표현식 문서와 Perl 정규 표현식 튜토리얼.

서론

QRegularExpression은 Perl 호환 정규식을 구현합니다. 이 라이브러리는 유니코드를 완벽하게 지원합니다. 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);

또는 기존 QRegularExpressionObject에 대해 setPatternOptions() 함수를 사용할 수도 있습니다:

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

patternOptions() 함수를 사용하면 QRegularExpression 객체에 현재 설정된 패턴 옵션을 가져올 수 있습니다:

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 일치 유형(기본값)을 사용하여 선택됩니다. 또한 대상 문자열에 대한 정규식의 부분 일치를 활성화할 수도 있습니다. 자세한 내용은 partial matching 섹션을 참조하십시오.

일치 옵션은 하나 이상의 QRegularExpression::MatchOption 값으로 구성된 집합입니다. 이 옵션들은 대상 문자열에 대한 정규식의 특정 일치 방식을 변경합니다. 자세한 내용은 QRegularExpression::MatchOption 열거형 문서를 참조하십시오.

일반 일치

일치 처리를 수행하려면, 일치시킬 문자열을 인수로 전달하여 ` match()` 함수를 호출하기만 하면 됩니다. 이 문자열을 ‘대상 문자열(subject string)’이라고 합니다. ` 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을 사용하여 전체 패턴과 일치하는 부분 문자열을 가져올 수 있습니다( extracting captured substrings 에 대한 섹션도 참조하십시오):

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

자바 스타일의 반복자이므로, ` 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)) {
    // ...
}

match()을 사용한 일반적인 매칭과 똑같이, globalMatch() 함수에 시작 오프셋과 하나 이상의 매칭 옵션을 전달할 수 있습니다.

부분 일치

부분 일치는 대상 문자열의 끝까지 도달했으나, 일치를 성공적으로 완료하기 위해 더 많은 문자가 필요한 경우에 발생합니다. 부분 일치는 일치 알고리즘의 많은 최적화 기법을 적용할 수 없기 때문에, 일반적으로 일반 일치보다 훨씬 비효율적이라는 점에 유의하십시오.

부분 일치를 수행하려면 QRegularExpression::match 또는 QRegularExpression::globalMatch 를 호출할 때 일치 유형으로 PartialPreferCompleteMatch 또는 PartialPreferFirstMatch 를 명시적으로 지정해야 합니다. 부분 일치가 발견된 경우, match()에서 반환된 QRegularExpressionMatch 객체에 대해 hasMatch() 함수를 호출하면 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은 내부적으로 JIT(Just-In-Time) 컴파일러를 사용하여 일치 알고리즘의 실행을 최적화합니다. JIT는 자가 수정 코드를 광범위하게 사용하며, 이로 인해 Valgrind와 같은 디버깅 도구가 충돌할 수 있습니다. QRegularExpression을 사용하는 프로그램을 디버깅하려면 자체 수정 코드에 대한 모든 검사를 활성화해야 합니다(예: Valgrind의 --smc-check 명령줄 옵션). 이러한 검사를 활성화하면 프로그램 실행 속도가 상당히 느려진다는 단점이 있습니다.

이를 방지하기 위해, Qt를 디버그 모드로 컴파일할 경우 JIT는 기본적으로 비활성화됩니다. QT_ENABLE_REGEXP_JIT 환경 변수를 0이 아닌 값 또는 0으로 설정함으로써 기본값을 재정의하고 JIT 사용을 활성화하거나 비활성화할 수 있습니다(디버그 모드 및 릴리스 모드 모두에서 가능).