Modified ECMAScript regular expression grammar

이 페이지는 std::basic_regex 가 syntax_option_type 이 ECMAScript (기본값)로 설정된 상태에서 생성될 때 사용되는 정규 표현식 문법을 설명합니다. 다른 지원되는 정규 표현식 문법에 대해서는 syntax_option_type 을 참조하십시오.

C++의 ECMAScript 3 정규 표현식 문법은 아래 (C++ only) 로 표시된 수정 사항이 적용된 ECMA-262 문법 입니다.

개요

수정된 정규 표현식 문법 은 대부분 ECMAScript RegExp 문법에 ClassAtom 아래의 로케일에 대한 POSIX-타입 확장을 더한 것입니다. 동등성 검사와 숫자 파싱에 대한 몇 가지 명확화가 이루어졌습니다. 여기 있는 많은 예제들은 브라우저 콘솔에서 이와 동등한 것을 시도해 볼 수 있습니다:

function match(s, re) { return s.match(new RegExp(re)); }

표준의 "규범적 참조"는 ECMAScript 3를 명시합니다. 여기서 ECMAScript 5.1 사양으로 링크하는 이유는 ECMAScript 3에서 사소한 변경만 있는 버전이며 HTML 버전도 갖추고 있기 때문입니다. 해당 방언 기능에 대한 개요는 MDN Guide on JavaScript RegExp 를 참조하십시오.

대안

정규 표현식 패턴은 하나 이상의 Alternative 들이 분리 연산자 | 로 구분된 수열입니다 (다시 말해, 분리 연산자는 가장 낮은 우선순위를 가집니다).

Pattern ::

논리합

논리합 ::

대안

대안 | 분리

패턴은 먼저 Disjunction 을 건너뛰고 왼쪽 Alternative 와 정규 표현식의 나머지 부분(Disjunction 이후)을 매칭하려 시도합니다.

실패할 경우, 왼쪽 Alternative 를 건너뛰고 오른쪽 Disjunction (정규 표현식의 나머지 부분이 뒤따름)와 일치시키려 시도합니다.

왼쪽 Alternative , 오른쪽 Disjunction , 그리고 정규 표현식의 나머지 부분 모두에 선택 지점이 있는 경우, 왼쪽 Alternative 의 다음 선택으로 이동하기 전에 표현식 나머지 부분의 모든 선택이 시도됩니다. 왼쪽 Alternative 의 선택을 모두 소진하면, 왼쪽 Alternative 대신 오른쪽 Disjunction 이 시도됩니다.

건너뛴 Alternative 내부의 모든 캡처링 괄호는 빈 부분 일치를 생성합니다.

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    show_matches("abcdef", "abc|def");
    show_matches("abc", "ab|abc"); // 왼쪽 Alternative가 먼저 매칭됨
    // 입력값이 왼쪽 Alternative(a)와 나머지 정규식(c|bc)에 대해
    // 매칭에 성공하여 m[1]="a"와 m[4]="bc"가 생성됨
    // 건너뛴 Alternatives (ab)와 (c)는 해당 부분 매칭
    // m[3]과 m[5]를 비워둠
    show_matches("abc", "((a)|(ab))((c)|(bc))");
}

input=[abcdef], regex=[abc|def]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[def]
input=[abc], regex=[ab|abc]
  prefix=[]
  smatch: m[0]=[ab]
  suffix=[c]
input=[abc], regex=[((a)|(ab))((c)|(bc))]
  prefix=[]
  smatch: m[0]=[abc] m[1]=[a] m[2]=[a] m[3]=[] m[4]=[bc] m[5]=[] m[6]=[bc]
  suffix=[]

용어

각 Alternative 는 비어 있거나 Term 들의 시퀀스입니다 ( Term 들 사이에 구분자가 없음)

Alternative ::

[비어 있음]

대안 용어

빈 Alternative 는 항상 일치하며 어떤 입력도 소비하지 않습니다.

연속된 Term 들은 입력의 연속된 부분을 동시에 매칭하려고 시도합니다.

왼쪽 Alternative , 오른쪽 Term , 그리고 정규 표현식의 나머지 부분 모두에 선택 지점이 있는 경우, 표현식의 나머지 부분에 있는 모든 선택 사항들은 오른쪽 Term 의 다음 선택으로 이동하기 전에 시도되며, 오른쪽 Term 의 모든 선택 사항들은 왼쪽 Alternative 의 다음 선택으로 이동하기 전에 시도됩니다.

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    show_matches("abcdef", ""); // 빈 정규식은 단일 빈 Alternative임
    show_matches("abc", "abc|"); // 왼쪽 Alternative가 먼저 매칭됨
    show_matches("abc", "|abc"); // 왼쪽 Alternative가 먼저 매칭되어 abc가 매칭되지 않음
}

input=[abcdef], regex=[]
  prefix=[]
  smatch: m[0]=[]
  suffix=[abcdef]
input=[abc], regex=[abc|]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[]
input=[abc], regex=[|abc]
  prefix=[]
  smatch: m[0]=[]
  suffix=[abc]

수량자

• 각 Term 은 아래에 설명된 Assertion 이거나, 아래에 설명된 Atom 이거나, Quantifier 가 바로 뒤에 오는 Atom 입니다.

용어 ::

단언문

원자

원자 수량자

각 Quantifier 는 greedy 수량자(단일 QuantifierPrefix 로만 구성됨)이거나 non-greedy 수량자(하나의 QuantifierPrefix 뒤에 물음표 ? 가 붙는 형태)입니다.

Quantifier ::

QuantifierPrefix

QuantifierPrefix ?

각 QuantifierPrefix 는 다음과 같이 두 개의 숫자를 결정합니다: 최소 반복 횟수와 최대 반복 횟수.

개별 DecimalDigits 의 값들은 각 숫자들에 대해 std::regex_traits::value (C++ only) 를 호출하여 얻습니다.

Atom 다음에 Quantifier 가 오면 해당 Atom 은 Quantifier 로 지정된 횟수만큼 반복됩니다. Quantifier 는 non-greedy (비탐욕적)일 수 있으며, 이 경우 정규 표현식의 나머지 부분과 일치하는 범위 내에서 Atom 패턴을 최소한으로 반복합니다. 또는 greedy (탐욕적)일 수 있으며, 이 경우 정규 표현식의 나머지 부분과 일치하는 범위 내에서 Atom 패턴을 최대한으로 반복합니다.

Atom 패턴이 반복되는 것이지, 매칭되는 입력이 반복되는 것이 아니므로, Atom 의 서로 다른 반복은 서로 다른 입력 부분 문자열과 매칭될 수 있습니다.

만약 Atom 과 정규식의 나머지 부분 모두에 선택 지점이 있다면, Atom 은 먼저 가능한 한 많이 (또는 non-greedy 인 경우 가능한 한 적게) 매칭됩니다. 정규식 나머지 부분의 모든 선택 사항들은 Atom 의 마지막 반복에서 다음 선택으로 이동하기 전에 시도됩니다. Atom 의 마지막(n번째) 반복에서 모든 선택 사항들은 Atom 의 마지막에서 두 번째(n-1번째) 반복에서 다음 선택으로 이동하기 전에 시도됩니다; 이 시점에서 Atom 의 더 많거나 더 적은 반복이 이제 가능할 수 있음이 밝혀질 수 있습니다; 이러한 것들은 Atom 의 (n-1)번째 반복에서 다음 선택으로 이동하기 전에 (다시, 가능한 한 적게 또는 가능한 한 많이 시작하여) 소진됩니다.

Atom' 의 캡처는 반복될 때마다 지워집니다 (아래 "(z)((a+)?(b+)?(c))*" 예제 참조)

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    // 탐욕적 매칭, [a-z]를 4번 반복
    show_matches("abcdefghi", "a[a-z]{2,4}");
    // 비탐욕적 매칭, [a-z]를 2번 반복
    show_matches("abcdefghi", "a[a-z]{2,4}?");
    // 수량자에 대한 선택점 순서로 인해 두 번의 반복으로 매칭됨,
    // 첫 번째는 "aa" 부분 문자열과 매칭,
    // 두 번째는 "ba" 부분 문자열과 매칭하여 "ac"는 매칭되지 않음
    // ("ba"는 캡처 절 m[1]에 나타남)
    show_matches("aabaac", "(aa|aabaac|ba|b|c)*");
    // 수량자에 대한 선택점 순서로 인해 이 정규식은
    // 10과 15 사이의 최대공약수를 계산함
    // (답은 5이며, m[1]을 "aaaaa"로 채움)
    show_matches("aaaaaaaaaa,aaaaaaaaaaaaaaa", "^(a+)\\1*,\\1+$");
    // 부분 문자열 "bbb"는 캡처 절 m[4]에 나타나지 않음
    // 왜냐하면 원자 (a+)?(b+)?(c)의 두 번째 반복이
    // 부분 문자열 "ac"와 매칭할 때 지워지기 때문
    // 참고: gcc는 이를 잘못 처리함 - ECMA-262 21.2.2.5.1에서 요구하는 대로
    // matches[4] 캡처 그룹을 올바르게 지우지 않아
    // 해당 그룹에 대해 "bbb"를 잘못 캡처함
    show_matches("zaacbbbcac", "(z)((a+)?(b+)?(c))*");
}

input=[abcdefghi], regex=[a[a-z]{2,4}]
  prefix=[]
  smatch: m[0]=[abcde]
  suffix=[fghi]
input=[abcdefghi], regex=[a[a-z]{2,4}?]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[defghi]
input=[aabaac], regex=[(aa|aabaac|ba|b|c)*]
  prefix=[]
  smatch: m[0]=[aaba] m[1]=[ba]
  suffix=[ac]
input=[aaaaaaaaaa,aaaaaaaaaaaaaaa], regex=[^(a+)\1*,\1+$]
  prefix=[]
  smatch: m[0]=[aaaaaaaaaa,aaaaaaaaaaaaaaa] m[1]=[aaaaa]
  suffix=[]
input=[zaacbbbcac], regex=[(z)((a+)?(b+)?(c))*]
  prefix=[]
  smatch: m[0]=[zaacbbbcac] m[1]=[z] m[2]=[ac] m[3]=[a] m[4]=[] m[5]=[c] 
  suffix=[]

어서션

Assertion 은 입력 문자열의 부분 문자열이 아닌 조건과 일치합니다. 이들은 입력에서 어떤 문자도 소비하지 않습니다. 각 Assertion 은 다음 중 하나입니다

Assertion ::

^

$

\ b

\ B

( ? = 분리 )

( ? ! 분리 )

단언문 ^ (줄의 시작)이 일치합니다

단언문 $ (줄 끝)이 일치합니다

위의 두 가지 단언과 아래 Atom . 에서, LineTerminator 는 다음 네 가지 문자 중 하나입니다: U+000A ( \n 또는 줄 바꿈), U+000D ( \r 또는 캐리지 리턴), U+2028 (행 구분자), 또는 U+2029 (단락 구분자)

단언 \b (단어 경계)가 일치합니다

단언문 \B (부정 단어 경계)는 다음을 제외한 모든 것과 일치합니다

단언문 ( ? = Disjunction ) (제로 폭 양성 전방 탐색)은 현재 위치에서 입력이 Disjunction 과 일치할 경우 매칭됩니다

단언문 ( ? ! Disjunction ) (제로-너비 부정 전방탐색)은 현재 위치에서 Disjunction 이 입력과 일치하지 않는 경우에 매칭됩니다.

두 Lookahead 어서션 모두에서 Disjunction 을 매칭할 때, 나머지 정규 표현식을 매칭하기 전에 위치가 진행되지 않습니다. 또한 Disjunction 이 현재 위치에서 여러 방식으로 매칭될 수 있는 경우, 첫 번째 방식만 시도됩니다.

ECMAScript는 전방탐색 분해(Disjunctions)로의 역추적을 금지하며, 이는 정규 표현식의 나머지 부분에서 긍정형 전방탐색으로의 역참조(backreferences) 동작에 영향을 미칩니다(아래 예제 참조). 정규 표현식의 나머지 부분에서 부정형 전방탐색으로의 역참조는 항상 정의되지 않습니다(전방탐색 분해가 진행되기 위해 실패해야 하기 때문).

참고: 전방 탐색 어서션을 사용하여 여러 정규식 간에 논리적 AND를 생성할 수 있습니다 (아래 예제 참조).

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    // 입력 끝의 a와 매칭
    show_matches("aaa", "a$");
    // 첫 번째 단어 끝의 o와 매칭
    show_matches("moo goo gai pan", "o\\b");
    // 전방탐색이 첫 번째 b 바로 뒤의 빈 문자열과 매칭
    // m[0]이 비어있지만 m[1]을 "aaa"로 채움
    show_matches("baaabac", "(?=(a+))");
    // 전방탐색으로의 역추적이 금지되므로
    // aaaba 대신 aba와 매칭
    show_matches("baaabac", "(?=(a+))a*b\\1");
    // 전방탐색을 통한 논리적 AND: 이 패스워드는 다음을 모두 만족할 때 매칭
    // 적어도 하나의 소문자
    // 적어도 하나의 대문자
    // 적어도 하나의 구두점 문자
    // 최소 6자 이상
    show_matches("abcdef", "(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}");
    show_matches("aB,def", "(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}");
}

input=[aaa], regex=[a$]
  prefix=[aa]
  smatch: m[0]=[a] 
  suffix=[]
input=[moo goo gai pan], regex=[o\b]
  prefix=[mo]
  smatch: m[0]=[o] 
  suffix=[ goo gai pan]
input=[baaabac], regex=[(?=(a+))]
  prefix=[b]
  smatch: m[0]=[] m[1]=[aaa] 
  suffix=[aaabac]
input=[baaabac], regex=[(?=(a+))a*b\1]
  prefix=[baa]
  smatch: m[0]=[aba] m[1]=[a] 
  suffix=[c]
input=[abcdef], regex=[(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}]: NO MATCH
input=[aB,def], regex=[(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}]
  prefix=[]
  smatch: m[0]=[aB,def] 
  suffix=[]

원자

Atom 은 다음 중 하나일 수 있습니다:

Atom ::

PatternCharacter

.

\ AtomEscape

CharacterClass

( Disjunction )

( ? : Disjunction )

여기서 AtomEscape ::

DecimalEscape

CharacterEscape

CharacterClassEscape

서로 다른 종류의 원자는 다르게 평가됩니다.

부분 표현식

Atom ( Disjunction ) 은 표시된 부분 표현식입니다: 이는 Disjunction 을 실행하고, Disjunction 에 의해 소비된 입력 부분 문자열의 복사본을 이 시점에서 전체 정규 표현식 내에서 표시된 부분 표현식의 왼쪽 여는 괄호 ( 가 발견된 횟수에 해당하는 인덱스의 부분 일치 배열에 저장합니다.

std::match_results 에 반환되는 것 외에도, 캡처된 서브매치는 백레퍼런스( \1 , \2 , ...)로 접근 가능하며 정규 표현식 내에서 참조될 수 있습니다. std::regex_replace 는 백레퍼런스( $1 , $2 , ...)에 \ 대신 $ 를 사용하며, 이는 String.prototype.replace (ECMA-262, part 15.5.4.11)와 동일한 방식입니다.

Atom ( ? : Disjunction ) (비표시 하위 표현식)은 단순히 Disjunction 을 평가하고 그 결과를 부분 일치에 저장하지 않습니다. 이는 순전히 어휘적 그룹화입니다.

역참조

DecimalEscape ::

DecimalIntegerLiteral [ lookahead ∉ DecimalDigit ]

만약 \ 다음에 첫 번째 숫자가 0 이 아닌 십진수 N 이 오면, 해당 이스케이프 시퀀스는 역참조(backreference) 로 간주됩니다. 값 N 은 각 숫자에 대해 std::regex_traits::value 를 호출하고 10진수 산술을 사용하여 결과를 결합하여 얻습니다. N 이 정규 표현식 전체의 왼쪽 캡처링 괄호 총 개수보다 큰 경우에는 오류입니다. (C++ only)

역참조 \N 가 Atom 으로 나타날 때, 이는 현재 부분 일치 배열의 N번째 요소에 저장된 동일한 부분 문자열과 일치합니다.

십진수 이스케이프 \0 는 역참조가 아닙니다: 이것은 NUL 문자를 나타내는 문자 이스케이프입니다. 이것 뒤에 십진수 숫자가 올 수 없습니다.

앞서 언급한 바와 같이, std::regex_replace 는 역참조( $1 , $2 , ...)에 대해 \ 대신 $ 를 사용합니다.

단일 문자 매칭

Atom . 은(는) 입력 문자열에서 LineTerminator ( U+000D , U+000A , U+2029 , 또는 U+2028 )를 제외한 모든 단일 문자와 일치하고 소비합니다.

Atom PatternCharacter , 여기서 PatternCharacter 는 ^ $ \ . * + ? ( ) [ ] { } | 문자를 제외한 모든 SourceCharacter 를 의미하며, 입력에서 이 PatternCharacter 와 동일한 한 문자를 매칭하고 소비합니다.

이 문자 및 다른 모든 단일 문자 일치에 대한 동등성은 다음과 같이 정의됩니다:

각 Atom 은 이스케이프 문자 \ 뒤에 CharacterEscape 가 오는 형태와 특수한 DecimalEscape \0 로 구성되며, 입력에서 CharacterEscape 가 나타내는 문자와 동일한 경우 해당 문자 하나와 일치하고 소비합니다. 다음과 같은 문자 이스케이프 시퀀스가 인식됩니다:

CharacterEscape ::

ControlEscape

c ControlLetter

HexEscapeSequence

UnicodeEscapeSequence

IdentityEscape

여기서, ControlEscape 는 다음 다섯 가지 문자 중 하나입니다: f n r t v

ControlLetter 는 모든 소문자 또는 대문자 ASCII 문자이며, 이 제어 문자 이스케이프는 ControlLetter 의 코드 유닛 값을 32 로 나눈 나머지와 동일한 코드 유닛을 가진 문자와 일치합니다. 예를 들어, \cD 와 \cd 는 모두 코드 유닛 U+0004 (EOT)와 일치합니다. 왜냐하면 'D'는 U+0044 이고 0x44 % 32 == 4 이며, 'd'는 U+0064 이고 0x64 % 32 == 4 이기 때문입니다.

HexEscapeSequence 는 문자 x 와 정확히 두 개의 HexDigit (여기서 HexDigit 은 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F 중 하나임)이 뒤따르는 형태입니다. 이 문자 이스케이프는 두 자리 16진수 숫자의 수치와 동일한 코드 유닛을 가진 문자와 일치합니다.

UnicodeEscapeSequence 는 문자 u 와 정확히 네 개의 HexDigit 이어지는 형태입니다. 이 문자 이스케이프는 이 네 자리 16진수 숫자의 수치와 코드 유닛이 일치하는 문자와 매칭됩니다. 값이 이 std::basic_regex 의 CharT 에 맞지 않으면, std::regex_error 가 발생합니다 (C++ only) .

IdentityEscape 는 영숫자가 아닌 모든 문자일 수 있습니다: 예를 들어, 다른 백슬래시입니다. 이스케이프는 문자를 있는 그대로 일치시킵니다.

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::wstring& in, const std::wstring& re)
{
    std::wsmatch m;
    std::regex_search(in, m, std::wregex(re));
    if (!m.empty())
    {
        std::wcout << L"input=[" << in << L"], regex=[" << re << L"]\n  "
                      L"prefix=[" << m.prefix() << L"]\n  wsmatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::wcout << L"m[" << n << L"]=[" << m[n] << L"] ";
        std::wcout << L"\n  suffix=[" << m.suffix() << L"]\n";
    }
    else
        std::wcout << L"input=[" << in << "], regex=[" << re << L"]: NO MATCH\n";
}
int main()
{
    // 대부분의 이스케이프는 C++과 유사하지만, 메타문자는 예외입니다. 슬래시에 대해서는
    // 이중 이스케이프를 사용하거나 원시 문자열을 사용해야 합니다.
    show_matches(L"C++\\", LR"(C\+\+\\)");
    // 이스케이프 시퀀스와 NUL.
    std::wstring s(L"ab\xff\0cd", 5);
    show_matches(s, L"(\\0|\\u00ff)");
    // ECMAScript가 UTF-16 아톰을 사용하기 때문에 비-BMP 유니코드에 대한 매칭은 정의되지 않습니다.
    // 이 이모지 바나나가 매칭되는지는 플랫폼에 따라 달라질 수 있습니다:
    // 이것들은 와이드 문자열이어야 합니다!
    show_matches(L"\U0001f34c", L"[\\u0000-\\ufffe]+");
}

input=[C++\], regex=[C\+\+\\]
  prefix=[]
  wsmatch: m[0]=[C++\]
  suffix=[]
input=[ab?c], regex=[(\0{{!}}\u00ff)]
  prefix=[ab]
  wsmatch: m[0]=[?] m[1]=[?]
  suffix=[c]
input=[?], regex=[[\u0000-\ufffe]+]: NO MATCH

문자 클래스

Atom은 문자 클래스를 나타낼 수 있으며, 즉 미리 정의된 문자 그룹 중 하나에 속하는 문자와 일치하고 소비합니다.

문자 클래스는 문자 클래스 이스케이프를 통해 도입될 수 있습니다:

Atom ::

\ 문자 클래스 이스케이프

또는 직접

Atom ::

문자 클래스

문자 클래스 이스케이프는 다음과 같이 일반적인 문자 클래스에 대한 단축 표현입니다:

CharacterClass 는 대괄호로 둘러싸인 ClassRanges 의 연속으로, 선택적으로 부정 연산자 ^ 로 시작합니다. 만약 ^ 로 시작한다면, 이 Atom 은 모든 ClassRanges 의 합집합으로 표현되는 문자 집합에 포함되지 않는 모든 문자와 일치합니다. 그렇지 않다면, 이 Atom 은 모든 ClassRanges 의 합집합으로 표현되는 문자 집합에 포함되는 모든 문자와 일치합니다.

CharacterClass ::

[ [ lookahead ∉ { ^ }] ClassRanges ]

[ ^ ClassRanges ]

ClassRanges ::

[비어 있음]

NonemptyClassRanges

NonemptyClassRanges ::

ClassAtom

ClassAtom NonemptyClassRangesNoDash

ClassAtom - ClassAtom ClassRanges

비어 있지 않은 클래스 범위가 ClassAtom - ClassAtom 형태를 가질 경우, 다음과 같이 정의된 범위의 모든 문자와 일치합니다: (C++ only)

첫 번째 ClassAtom 은 단일 데이터 정렬 요소 c1 과 일치해야 하며, 두 번째 ClassAtom 은 단일 데이터 정렬 요소 c2 와 일치해야 합니다. 입력 문자 c 가 이 범위에 일치하는지 테스트하기 위해 다음 단계를 수행합니다:

문자 - 는 다음과 같은 경우에 문자 그대로 처리됩니다

• ClassRanges 의 첫 번째 또는 마지막 문자
• 대시로 구분된 범위 지정의 시작 또는 끝 ClassAtom
• 대시로 구분된 범위 지정 바로 뒤에 위치
• 백슬래시로 이스케이프된 CharacterEscape

NonemptyClassRangesNoDash ::

ClassAtom

ClassAtomNoDash NonemptyClassRangesNoDash

ClassAtomNoDash - ClassAtom ClassRanges

ClassAtom ::

-

ClassAtomNoDash

ClassAtomExClass (C++ only)

ClassAtomCollatingElement (C++ only)

ClassAtomEquivalence (C++ only)

ClassAtomNoDash ::

SourceCharacter 이지만 다음 중 하나가 아닌 경우 \ or ] or -

\ ClassEscape

각 ClassAtomNoDash 는 단일 문자를 나타냅니다 -- SourceCharacter 그대로이거나 다음과 같이 이스케이프된 형태입니다:

ClassEscape ::

DecimalEscape

b

CharacterEscape

CharacterClassEscape

특수한 ClassEscape \b 는 코드 유닛 U+0008(백스페이스)에 일치하는 문자 집합을 생성합니다. CharacterClass 외부에서는 단어 경계 Assertion 입니다.

\B 의 사용과 CharacterClass 내부에서의 모든 역참조(0이 아닌 DecimalEscape ) 사용은 오류입니다.

문자 - 와 ] 는 일부 상황에서 원자(atom)로 처리되기 위해 이스케이프가 필요할 수 있습니다. CharacterClass 외부에서 특별한 의미를 갖는 다른 문자들, 예를 들어 * 나 ? 같은 문자들은 이스케이프할 필요가 없습니다.

POSIX 기반 문자 클래스

이러한 문자 클래스는 ECMAScript 문법에 대한 확장이며, POSIX 정규 표현식에서 찾을 수 있는 문자 클래스와 동등합니다.

ClassAtomExClass (C++ 전용) ::

[: ClassName :]

명명된 문자 클래스 ClassName 의 구성원인 모든 문자를 나타냅니다. 이 이름은 std::regex_traits::lookup_classname 이 해당 이름에 대해 0이 아닌 값을 반환할 때만 유효합니다. std::regex_traits::lookup_classname 에서 설명된 대로, 다음 이름들은 인식이 보장됩니다: alnum, alpha, blank, cntrl, digit, graph, lower, print, punct, space, upper, xdigit, d, s, w . 추가 이름들은 시스템 제공 로캘(예: 일본어에서 jdigit 또는 jkanji )에 의해 제공되거나 사용자 정의 확장으로 구현될 수 있습니다.

ClassAtomCollatingElement (C++ only) ::

[. ClassName .]

명명된 조합 요소를 나타내며, 이는 임뷰드 로케일에서 단일 단위로 조합되는 단일 문자 또는 문자 시퀀스를 나타낼 수 있습니다. 예를 들어 체코어에서 [.tilde.] 또는 [.ch.] 와 같습니다. 이 이름은 std::regex_traits::lookup_collatename 이 빈 문자열이 아닌 경우에만 유효합니다.

std::regex_constants::collate 를 사용할 때, 콜레이팅 요소는 항상 범위의 끝점으로 사용될 수 있습니다(예: 헝가리어에서 [[.dz.]-g] ).

ClassAtomEquivalence (C++ only) ::

[= ClassName =]

명명된 조합 요소와 동일한 동등 클래스에 속하는 모든 문자, 즉 주 조합 키가 조합 요소 ClassName 의 주 조합 키와 동일한 모든 문자를 나타냅니다. 이 이름은 해당 이름에 대한 std::regex_traits::lookup_collatename 이 빈 문자열이 아니고, std::regex_traits::lookup_collatename 호출 결과에 대한 std::regex_traits::transform_primary 이 반환한 값이 빈 문자열이 아닌 경우에만 유효합니다.

기본 정렬 키는 대소문자, 악센트 또는 로케일별 맞춤을 무시하는 키입니다. 예를 들어 [[=a=]] 는 다음 문자들 중 어느 하나와 일치합니다: a, À, Á, Â, Ã, Ä, Å, A, à, á, â, ã, ä and å.

ClassName (C++ 전용) ::

ClassNameCharacter

ClassNameCharacter ClassName

ClassNameCharacter (C++ 전용) ::

SourceCharacter 이지만 . = : 중 하나는 아닌 문자