QRegularExpression Class

상세 설명

정규식 또는 정규식은 문자열과 텍스트를 처리하는 매우 강력한 도구입니다. 다음과 같은 여러 상황에서 유용합니다,

이 문서는 정규식을 사용한 패턴 매칭에 대한 완전한 참조서가 아니며, 다음 부분을 읽으려면 Perl과 유사한 정규식과 그 패턴 구문에 대한 기본적인 지식이 필요합니다.

정규식에 대한 좋은 참고 자료는 다음과 같습니다:

• 정규 표현식 마스터하기 (제3판)(Jeffrey E. F. Friedl 저, 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() 함수를 호출하여 일치시킬 문자열을 전달하면 됩니다. 이 문자열을 제목 문자열이라고 합니다. 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 는 결과를 반복하는 데 사용할 수 있는 Java와 유사한 정방향 이터레이터인 QRegularExpressionMatchIterator 를 반환합니다. 예를 들어

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

Java와 유사한 반복자이기 때문에 QRegularExpressionMatchIterator 은 첫 번째 결과 바로 앞을 가리킵니다. 모든 결과는 QRegularExpressionMatch 객체로 반환됩니다. hasNext () 함수는 결과가 하나 이상 더 있는 경우 참을 반환하고 next()은 다음 결과를 반환하고 반복기를 진행합니다. 이전 예제에서 계속합니다:

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

peekNext()를 사용하여 반복기를 진행하지 않고 다음 결과를 가져올 수도 있습니다.

예를 들어 다음과 같이 범위 기반 for 루프에서 QRegularExpression::globalMatch 의 결과를 간단히 사용할 수도 있습니다:

// 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() 함수는 참을 반환하고, 그렇지 않으면 거짓을 반환합니다:

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)를 사용하여 매칭 알고리즘의 실행을 최적화합니다. JIT는 자체 수정 코드를 광범위하게 사용하므로 Valgrind와 같은 디버깅 도구가 충돌할 수 있습니다. QRegularExpression(예: Valgrind의 --smc-check 명령줄 옵션)을 사용하여 프로그램을 디버깅하려면 자체 수정 코드에 대한 모든 검사를 활성화해야 합니다. 이러한 검사를 활성화하면 프로그램 실행 속도가 상당히 느려진다는 단점이 있습니다.

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