278 번째 수정본 소스 보기 : Perl/정규표현식

내용출력
로그인[l]
수정할 수 없습니다: Perl/정규표현식 는 읽기 전용 페이지입니다.
= Perl 정규표현식 Regular Expression =

<toc>

== # perlretut (Perl regular expressions tutorial) 번역 ==

Perl 정규표현식 튜토리알 문서 번역, 정리
* 원문: Perldoc:perlretut
** 현재 Perl <ix(Perl:::5.14.1)> 버전 기반
* 주인장 의견이나 보충은 짧은 것은 각주로 달고, 긴 내용은 본문 사이에 삽입하였음


=== Description ===

정규표현식은 패턴을 묘사하는 문자열이다. Perl에서 패턴은 문자열을 검색하거나, 문자열에서 원하는 부분을 추출하거나, 검색 및 치환 연산을 하는 데 사용된다.


=== # Part 1: 기본 The basics ===
==== # 간단한 단어 매칭 Simple word matching ====

가장 단순한 정규식은 하나의 단어, 좀 더 일반적으로 말하면 문자들로 이뤄진 스트링이다. 한 단어로 아뤄진 정규식은 그 단어를 포함하고 있는 스트링에 매치된다:

<ix(matching operator:::/regexp/)>, <ix(=~)>, <ix(=~:::!~)>
* <code>//</code>는 일치하는 정규식을 검색하라고 Perl에게 지시한다.
* <code>=~</code> 연산자는 좌변의 문자열과 우변의 정규식을 비교하여 정규식이 매치될 경우 참을 반환하고 그렇지 않을 경우 거짓을 반환한다.
* <code>!~</code>는 반대로 매치하지 않을 경우 참을 반환한다.
{{{#!vim perl
"Hello World" =~ /World/;   # 단순한 단어의 일치 여부 검색. 일치하므로 위 expression은 true
"Hello World" !~ /World/;   # 반대

if ("Hello World" =~ /World/) {
	print "It matches\n";
}
else {
	print "It doesn't match\n";
}
}}}

문자열 리터럴이 들어갈 자리에 변수를 사용할 수 있다:
{{{#!vim perl
$greeting = "World";
if ("Hello World" =~ /$greeting/) {   # 스트링 자리에 변수 사용 가능
    print "match\n";
} else {
    print "not match\n";
}
}}}

스페샬 변수 <index($_)>에 대해 매치검사를 하는 경우, <code>$_ =~</code> 부분을 생략할 수 있다:
{{{#!vim perl
$_ = "Hello World";
if (/World/) {               # "$_ =~" 는 생략가능
    print "match\n";
} else {
    print "not match\n";
}
}}}

앞에 <code>m</code>을 붙이면 <code>//</code> 대신에 임의의 구분자를 쓸 수 있다:
<ix(matching operator:::m!regexp!)>
{{{#!vim perl
"Hello World" =~ m!World!;   # 매치됨, 구분자는 '!'
"Hello World" =~ m{World};   # 매치됨, 구분자는 '{}'
"/usr/bin/perl" =~ m"/perl"; # '/usr/bin' 뒷부분에 매치됨, '/'는 평범한 문자로 간주됨.
}}}

정규식은 스트링의 일부에 ''정확하게'' 매치되어야 구문이 참이 된다:
{{{#!vim perl
"Hello World" =~ /world/;  # 일치하지 않음. 대소문자가 구분된다.
"Hello World" =~ /o W/;    # 일치함
"Hello World" =~ /oW/;     # 일치하지 않음
"Hello World" =~ /World /; # 일치하지 않음
}}}

<index(스트링)>의 두 곳 이상에서 정규식이 매치될 경우, 항상 가장 먼저 일치하는 곳에서 매치된다.

{{{#!vim perl
"Hello World" =~ /o/;       # 'Hello'의 'o'에 매치됨
"That hat is red" =~ /hat/; # 'That'의 'hat'에 매치됨
}}}

<index(metacharacter)>s

다음 캐릭터들은 문자 그대로 매치되지 않고, 정규식 표기에 사용하도록 예약되어있다:
{{{
{}[]()^$.|*+\? 
}}}

메타캐릭터를 일치시킬 때는 앞에 백슬래쉬를 붙인다:
{{{#!vim perl
"2+2=4" =~ /2+2/;    # 매치되지 않는다, + 는 메타캐릭터
"2+2=4" =~ /2\+2/;   # 매치된다, \+는 평범한 +로 간주된다
"The interval is [0,1)." =~ /[0,1)./     # 문법 에러!
"The interval is [0,1)." =~ /\[0,1\)\./  # 매치됨
"#!/usr/bin/perl" =~  /#!\/usr\/bin\/perl/;  # 매치됨
"#!/usr/bin/perl" =~ m!#\!/usr/bin/perl!;    # 이렇게 하는 게 읽기 더 좋다
'C:\WIN32' =~ /C:\\WIN/;   # 백슬래쉬도 메타캐릭터
}}}

<index(Escape Sequences)>
* <code>\t</code> 탭, <code>\n</code> 뉴 라인, <code>\r</code> 캐리지 리턴 등
* 스트링이 임의의 바이트의 조합일 경우 8진수로 표기하거나(<code>\033</code>), 16진수로 표기(<code>\x1B</code>)할 수 있다:
{{{#!vim perl
"1000\t2000" =~ m(0\t2)   # 매치됨
"1000\n2000" =~ /0\n20/   # 매치됨
"1000\t2000" =~ /\000\t2/ # 매치되지 않음, "0"과 "\000"는 같지 않다
"cat"   =~ /\o{143}\x61\x74/ # ASCII 시스템에서 매치되나, cat을 표기하는 이상한 방법이다.
}}}

Perl에서 정규식은 대부분 이중 따옴표로 표시된 스트링(double-quoted string)으로 간주된다. 이스케이프 시퀀스나 변수를 처리할 때도 마찬가지이다. 정규식에 포함된 변수는 정규식의 매치 검사를 하기 전에 변수의 값으로 먼저 치환된다.
{{{#!vim perl
$foo = 'house';
'housecat' =~ /$foo/;      # 매치됨
'cathouse' =~ /cat$foo/;   # 매치됨
'housecat' =~ /${foo}cat/; # 매치됨
}}}

예제: 간단한 Unix의 grep 프로그램을 흉내내는 매우 간단한 형태
{{{#!vim perl
#!/usr/bin/perl
$regexp = shift;           # 첫번째 명령행 인자를 취함
while (<>) {               # 두번째 인자를 파일명으로 하여 파일을 읽음
    print if /$regexp/;    # print $_ if $_ =~ /$regexp/;
}
}}}
{{{#!vim
% simple_grep abba /usr/dict/words
Babbage
cabbage
cabbages
sabbath
Sabbathize
Sabbathizes
sabbatical
scabbard
scabbards
}}}



<index(anchor)> <index(metacharacter)>

스트링의 '어느 지점'에 매치시킬지를 지정
* <ix(anchor:::^)> : <index(스트링)>의 시작
* <ix(anchor:::$)> : <index(스트링)>의 끝 또는 <index(스트링)>의 끝 바로 앞의 "\n"
{{{#!vim perl
"housekeeper" =~ /keeper/;    # 매치됨
"housekeeper" =~ /^keeper/;   # 매치되지 않음
"housekeeper" =~ /keeper$/;   # 매치됨
"housekeeper\n" =~ /keeper$/; # 매치됨
}}}

<code>^</code>와 <code>$</code>가 동시에 쓰이면 스트링의 시작과 끝에 매치되어야 하므로, 정규식이 스트링 전체에 매치된다.
{{{#!vim perl
"keeper" =~ /^keep$/;      # 매치되지 않음
"keeper" =~ /^keeper$/;    # 매치됨
""       =~ /^$/;          # ^$ 는 빈 스트링에 매치됨
}}}

bert라는 이름의 친구를 찾고 있다고 가정하자:
{{{#!vim perl
"dogbert" =~ /bert/;   # 매치되지만, 우리가 원하는 게 아님
"dilbert" =~ /^bert/;  # 이런 건 매치되지 않게 했음, 그러나..
"bertram" =~ /^bert/;  # 이런 게 매치됨, 여전히 문제가 있음
"bertram" =~ /^bert$/; # 매치되지 않음, 좋다
"dilbert" =~ /^bert$/; # 매치되지 않음, 좋다
"bert"    =~ /^bert$/; # 매치됨, 완벽하군
}}}
* 물론 이렇게 리터럴 스트링을 찾는 경우라면 <code>$string eq 'bert'</code>와 같이 스트링 비교 연산을 하는게 더 효율적인다. <code>^...$</code> 정규식은 아래에 나올 더 강력한 정규식 도구들을 같이 쓸 때 비로소 유용해진다.




==== # 캐릭터 클래스 Using character classes ====

<index(character class)> : <code>[...]</code> 형태

매치될 수 있는 하나 이상의 캐릭터들의 집합을 표시

{{{#!vim perl
/cat/;       # matches 'cat'
/[bcr]at/;   # matches 'bat, 'cat', or 'rat'
/item[0123456789]/;  # matches 'item0' or ... or 'item9'
"abc" =~ /[cab]/;    # matches 'a' ([cab]의 순서라고 해서 'c'가 매치하는 게 아님)
/[yY][eE][sS]/;      # 'yes', 'Yes', 'YES' 등, 대소문자를 구분하지 않고 'yes'에 매치 
}}}
* 마지막 예는 대소문자를 구분하지 않음을 의미하는 <ix(modifier::://i)>를 사용하여 <code>/yes/i</code>로도 쓸 수 있다.

<index(character class)> 내의 특수문자는 앞에서 봤던 경우와 다르다:
{{{
-]\^$
}}}
* <index(character class:::-)> : 범위(range) 연산자로 동작
* <index(character class:::])> : 캐릭터 클래스의 끝을 표시할 때 사용됨
* <index(character class:::\)> : 이스케이프 시퀀스에 사용됨
* <index(character class:::^)> : 네거티브(negative) 캐릭터 클래스
* <index(character class:::$)> : 스칼라 변수를 나타날 때 사용됨
* 정규식 패턴 구분자로 사용된 문자
{{{#!vim perl
/[\]c]def/; # ']def' or 'cdef'에 매치됨
$x = 'bcr';
/[$x]at/;   # 'bat', 'cat', or 'rat'에 매치됨
/[\$x]at/;  # '$at' or 'xat'에 매치됨
/[\\$x]at/; # '\at', 'bat, 'cat', or 'rat'에 매치됨
}}}

<index(character class:::-)>를 사용하여 연속된 문자들의 집합을 표시:
{{{#!vim perl
/item[0-9]/;    # 'item0' or ... or 'item9'에 매치됨
/[0-9bx-z]aa/;  # '0aa', ..., '9aa',
                # 'baa', 'xaa', 'yaa', or 'zaa'에 매치됨
/[0-9a-fA-F]/;  # 16진수 숫자들에 매치됨
/[0-9a-zA-Z_]/; # Perl의 변수명 등에 쓰이는 "word" 캐릭터들에 매치됨
}}}

<code>-</code>가 클래스 제일 앞 또는 제일 뒤에 오면 일반 문자 "-"
* <code>[-ab]</code>, <code>[ab-]</code>, <code>[a\-b]</code> 는 같은 의미


<index(character class:::^)>가 클래스 제일 앞에 오면 negated character class. 대괄호 안에 있는 문자들을 제외한 모든 문자들을 의미
{{{#!vim perl
/[^a]at/;  # 'aat'와 'at'에는 매치되지 않고,
           # 그 외 모든 경우 'bat', 'cat, '0at', '%at' 등에 매치
/[^0-9]/;  # 숫자가 아닌 캐릭터들에 매치
/[a^]at/;  # 'aat' 또는 '^at'에 매치됨; 여기서 '^'는 보통의 문자
}}}


보편적으로 사용되는 캐릭터 클래스들에 대해 별도의 축약형 제공. <index(Perl:::5.10.0)>부터는 이 클래스는 ASCII범위 밖의 <index(Unicode)> 문자에도 매치된다. <index(Perl:::5.14.0)>이상에서는 <index(modifier::://a)> 변경자를 사용하여 ASCII범위로 매치를 국한시킬 수 있다.
* <index(character class:::\d)> : 숫자에 매치됨. [0-9]와, 비로마권 스크립트에 있는 숫자들
* <index(character class:::\s)> : whitespace. [\ \t\r\n\f] 등
* <index(character class:::\w)> : word character. [0-9a-zA-Z_]와 비로마권 스크립트에 사용되는 문자들
* <index(character class:::\D)> : \d에 속하지 않는 문자들. [^\d]
* <index(character class:::\S)> : \s에 속하지 않는 문자들. [^\s]
* <index(character class:::\W)> : \w에 속하지 않는 문자들. [^\w]
* <index(character class:::.)>  : 임의의 캐릭터 하나. "<index(new line:::\n)>"은 제외(<index(modifier::://s)> 옵션이 적용되지 않았을 때)
* <index(character class:::\N)> : "<index(new line:::\n)>"을 제외한 임의의 캐릭터 하나.(<index(modifier::://s)> 옵션 여부에 무관하게) Perl <ix(Perl:::5.12.0)>부터.

Perl <ix(Perl:::5.14.0)>부터 제공되는 <ix(modifier::://a)>를 사용하면 \d,\s,\w가 ASCII범위에 있는 문자에만 매치되도록 제한할 수 있다. 영어권 텍스트만 처리하는 경우 전체 <ix(Unicode)>에 노출되지 않도록 하는데 유용하다. ("a"를 두번 써서 <code>//aa</code>처럼 할 경우 더 강한 제한을 두어, ASCII문자와 비ASCII문자가 대소문자 구분없는 매치 검사에 매치되는 것을 방지할 수 있다; 이 옵션을 주지 않을 경우 유니코드 "Kelvin Sign"문자가 "k"나 "K"에 매치되게 된다)
<blockquote>
[[주인장]] 보충: Kelvin Sign을 구글링해보니 유니코드 U+212A에 해당하고, 생김새는 "K"와 비슷하다[http://www.fileformat.info/info/unicode/char/212a/index.htm]. 이것이 /i 옵션을 주었을 때는 알파벳 'k'나 'K'에 매치된다. (Perl 5.8.8에서도 마찬가지임을 확인했음)

Strawberry Perl 5.12에서 테스트:
{{{#!vim perl
use 5.012;
$_ = chr(0x212A);   # Kelvin Sign
say "match /k/"  if /k/;
say "match /K/"  if /K/;
say "match /k/i" if /k/i;
say "match /K/i" if /K/i;
}}}

{{{#!vim
match /k/i
match /K/i
}}}
</blockquote>


이런 축약형 <code>\d\s\w\D\S\W</code>는 캐릭터 클래스 안과 밖 양쪽에서 다 사용가능:
{{{#!vim perl
/\d\d:\d\d:\d\d/; # matches a hh:mm:ss time format
/[\d\s]/;         # matches any digit or whitespace character
/\w\W\w/;         # matches a word char, followed by a
                  # non-word char, followed by a word char
/..rt/;           # matches any two chars, followed by 'rt'
/end\./;          # matches 'end.'
/end[.]/;         # same thing, matches 'end.'
}}}
* 마침표는 메타캐릭터이므로, 마침표 문자로 매치시키려면 이스케이프해줘야 한다.
* (예를 들어) <code>\d</code>와 <code>\w</code>는 캐릭터들의 집합이므로, <code>[^\d\w]</code>는 <code>[\D\W]</code>와 같지 않다. 실제로 <code>[^\d\w]</code>는 <code>[^\w]</code>와 같고 이것은 <code>[\W]</code>와 같다.


<index(metacharacter:::Word anchor)> <index(anchor:::\b)>
* 두 캐릭터 사이의 지점에 해당되는데, 이 때 두 캐릭터 중 하나는 <code>\w</code>에, 다른 하나는 <code>\W</code>에 매치되는 곳
* 스트링의 제일 처음과 끝에도 <code>\W</code>에 해당하는 가상의 캐릭터가 있다고 간주
* 반대는 <index(anchor:::\B)>
{{{#!vim perl
$x = "Housecat catenates house and cat";
$x =~ /cat/;     # 'housecat'의 cat에 매치
$x =~ /\bcat/;   # 'catenates'의 cat에 매치
$x =~ /cat\b/;   # 'housecat'의 cat에 매치
$x =~ /\bcat\b/; # 스트링 마지막 'cat'의 cat에 매치
}}}


어째서 <code>.</code>가 매치되는 것 중 <code>\n</code>는 제외되는가? 그 이유는 종종 사용자는 여러 줄에 대해 매칭을 수행하며 뉴라인 캐릭터를 무시하고자 할 때가 있기 때문이다. 예를 들어 스트링은 <code>"\n"</code> 한 줄을 나타내지만, 이것을 비어 있는 걸로 간주하고 싶은 것이다. 따라서 다음과 같이 판정된다:
{{{#!vim perl
""   =~ /^$/;     # 매치됨
"\n" =~ /^$/;     # 매치됨, $는 "\n" 앞에 걸린다

""   =~ /./;      # 매치되지 않음; 캐릭터 하나가 필요함
""   =~ /^.$/;    # 매치되지 않음; 캐릭터 하나가 필요함
"\n" =~ /^.$/;    # 매치되지 않음; "\n" 이외의 캐릭터 하나가 필요함
"a"  =~ /^.$/;    # 매치됨
"a\n"  =~ /^.$/;  # 매치됨, $는 "\n" 앞에 걸린다
}}}

매칭할 때 개행 문자(<index(new line:::\n)>)를 고려하거나, <code>^</code>와 <code>$</code>가 전체 스트링이 아니라 각 라인의 시작과 끝에 매치되길 바랄 때가 있다.
* <index(modifier::://s)> 와 <index(modifier::://m)> <index(modifier)> 사용
* 다음 두 가지 관점에서 동작이 달라짐
** "<ix(character class:::.)>"를 어떻게 정의하는가
** "<ix(anchor:::^)>"와 "<ix(anchor:::$)>"가 어디에 매치되는가
* 네 가지 조합
** // : 디폴트 동작.
*** '.'는 "\n"을 제외한 모든 문자에 매치.
*** '^'는 스트링의 처음에 매치.
*** '$'는 스트링의 제일 끝, 또는 제일 끝에 있는 newline 직전에 매치.
** //s : single line - 스트링을 하나의 긴 라인으로 취급
*** '.'는 "\n"을 포함하는 모든 문자에 매치
*** '^'는 스트링의 처음에 매치.
*** '$'는 스트링의 제일 끝, 또는 제일 끝에 있는 newline 직전에 매치.
** //m : multi-line - 스트링을 여러 라인들의 집합으로 취급.
*** '.'는 "\n"을 제외한 모든 문자에 매치.
*** '^'는 스트링 안의 '''각 라인'''의 시작에 매치
*** '$'는 스트링 안의 '''각 라인'''의 끝에 매치
** //ms : 스트링을 하나의 긴 라인으로 취급하되, 라인들을 구분.
*** '.'는 "\n"을 포함하는 모든 문자에 매치
*** '^'는 스트링 안의 '''각 라인'''의 시작에 매치
*** '$'는 스트링 안의 '''각 라인'''의 끝에 매치
* 예문
{{{#!vim perl
$x = "There once was a girl\nWho programmed in Perl\n";

$x =~ /^Who/;   # 매치되지 않음, "Who"가 스트링의 시작 부분에 있지 않음
$x =~ /^Who/s;  # 매치되지 않음, "Who"가 스트링의 시작 부분에 있지 않음
$x =~ /^Who/m;  # 매치됨, "Who"가 두번째 라인의 시작 부분에 있음
$x =~ /^Who/sm; # 매치됨, "Who"가 두번째 라인의 시작 부분에 있음

$x =~ /girl.Who/;   # 매치되지 않음, "."가 "\n"에 매치되지 않음
$x =~ /girl.Who/s;  # 매치됨, "."가 "\n"에 매치됨
$x =~ /girl.Who/m;  # 매치되지 않음, "."가 "\n"에 매치되지 않음
$x =~ /girl.Who/sm; # 매치됨, "."가 "\n"에 매치됨
}}}
* <index(modifier::://m)> 을 사용할 경우, 전체 <index(스트링)>의 시작과 끝은 다음 앵커로 지시할 수 있다.
** <ix(anchor:::\A)> : 스트링의 처음
** <ix(anchor:::\Z)> : 스트링의 끝 또는 스트링의 끝 바로 앞의 "<index(new line:::\n)>"
** <ix(anchor:::\z)> : 스트링의 끝
{{{#!vim perl
$x = "There once was a girl\nWho programmed in Perl\n";

$x =~ /^Who/m;   # matches, "Who" at start of second line
$x =~ /\AWho/m;  # doesn't match, "Who" is not at start of string

$x =~ /girl$/m;  # matches, "girl" at end of first line
$x =~ /girl\Z/m; # doesn't match, "girl" is not at end of string

$x =~ /Perl\Z/m; # matches, "Perl" is at newline before end
$x =~ /Perl\z/m; # doesn't match, "Perl" is not at end of string
}}}




==== # 이것 아니면 저것에 매치 Matching this or that ====

서로 다른 단어들 또는 캐릭터 스트링들에 동시에 매치될 수 있는 정규식.

'''<index(metacharacter:::alternation)>''' <index(metacharacter)> <index(metacharacter:::|)>을 사용
* 이 경우도 항상 스트링에서 매치할 수 있는 가장 앞부분에서 매치하려 한다. 스트링의 첫번째 캐릭터의 위치에서 Perl은 첫번째 후보를 매치하려 시도하고, 실패할 경우 다음 후보를 매치하려 시도함. 모든 후보가 다 매치되지 않을 경우 다음 위치로 이동
{{{#!vim perl
"cats and dogs" =~ /cat|dog|bird/;  # "cat"에 매치됨
"cats and dogs" =~ /dog|cat|bird/;  # "cat"에 매치됨
}}}
* 위 두번째 예에서는 <code>dog</code>가 정규식의 첫번째 후보이지만, <code>cat</code>이 스트링의 더 앞쪽에서 매치가 된다.
{{{#!vim perl
"cats"          =~ /c|ca|cat|cats/; # matches "c"
"cats"          =~ /cats|cat|ca|c/; # matches "cats"
}}}
* 위 경우는 모든 후보가 다 첫번째 위치에서 매치 가능하므로, 첫번째 후보에 매치된다. 한 후보가 다른 후보의 뒷부분을 절단한 형태라면, 가장 긴 패턴을 제일 앞에 적어주어야 매치될 수 있다.
{{{#!vim perl
"cab" =~ /a|b|c/ # "c"에 매치됨
                 # /a|b|c/ == /[abc]/
}}}
* 캐릭터 클래스는 캐릭터들의 alternation과 비슷하다.



==== # 그룹짓기와 계층적 매칭 Grouping things and hierarchical matching ====

정규식의 일부에 대해서만 alternation을 적용하고 싶은 경우.

'''<index(metacharacter:::grouping)>''' metacharacter <index(metacharacter:::( ))> - 정규표현식의 일부분을 하나의 유닛으로 최급
{{{#!vim perl
/(a|b)b/;    # matches 'ab' or 'bb'
/(ac|b)b/;   # matches 'acb' or 'bb'
/(^a|b)c/;   # matches 'ac' at start of string or 'bc' anywhere
/(a|[bc])d/; # matches 'ad', 'bd', or 'cd'

/house(cat|)/;  # matches either 'housecat' or 'house'
/house(cat(s|)|)/;  # matches either 'housecats' or 'housecat' or
                    # 'house'.  그룹은 중첩될 수 있다.

/(19|20|)\d\d/;  # 년도를 나타내는 19xx, 20xx, 또는 xx에 매치
"20" =~ /(19|20|)\d\d/;  # "20"은 null alternative '()\d\d'에 매치된다,
                         # 왜냐하면 '20\d\d'은 매치될 수 없기 때문이다.
}}}
* 마지막 예에서 첫번째 위치에서 "20"은 두번째 후보에 매치되긴 하지만, 그 다음 <code>\d\d</code>에 매치될 것이 남아 있지 않다. 따라서 다음 후보인 빈(null) 후보로 이동하고, 이것은 <code>"20"</code>이 두개의 숫자에 매치되기 때문에 성공한다.

한 후보가 매치되는지 살펴보고, 매치되지 않을 경우, 스트링에서 그 후보를 테스트했던 지점으로 되돌아와서 다음 후보를 테스트하기 위해 준비하는 과정을 ''backtracking''이라고 부른다. 이 용어는 정규식을 매치시키는 과정이 숲에서 걷는 것과 비슷하다는 데에서 나왔다. 정규식을 성공적으로 매치하는 것은 목적지에 도달하는 것과 같다. 숲에서는 수많은 시작지점이 있고 각각은 스트링의 각 위치에 대응되며, 왼쪽에서 오른쪽 순서로 테스트된다. 각 시작점마다 수많은 경로가 있을 수 있고, 그 중 일부는 목적지에 이어지며, 일부는 막다른 길이다. 한 길을 따라 걷다가 막다른 길에 도달하면, 그 길을 따라 되돌아나와(backtrack) 시작지점으로 와서 다음 길을 시도해본다. 목적지에 도달할 경우, 그 즉시 나머지 경로에 대해서는 잊어버린다. 모든 시작점에서 출발하는 모든 경로를 다 시도해보고 끝내 목적지에 도달하지 못했을 경우 실패를 선언한다.

정규표현식을 매칭하는 단계별 분석:
{{{#!vim perl
"abcde" =~ /(abd|abc)(df|d|de)/;
}}}
* 0 스트링의 첫번째 글자인 'a'에서 시작
* 1 첫번째 그룹의 첫번째 후보인 'abd'를 테스트
* 2 'a'와 그 다음 'b'까지 매치됨. 여기까진 좋음
* 3 정규식의 'd'가 스트링의 'c'와 매치되지 않음 - 막다른 길. 두 개의 캐릭터를 백트랙한 후 첫번째 그룹의 두번째 후보를 테스트
* 4 정규식의 'a'와 다음 'b'와 다음 'c'까지 매치. 순조롭게 첫번째 그룹을 만족했음. $1변수를 'abc'로 설정
* 5 다음 그룹으로 이동하여 첫번째 후보인 'df'를 테스트
* 6 'd'에 매치
* 7 정규식의 'f'가 스트링의 'e'와 매치되지 않음. 막다른 길. 한 개의 캐릭터를 백트랙한 후 두번째 후보인 'd'를 선택
* 8 'd'가 매치됨. 두번째 그룹을 성공했음. $2변수를 'd'로 설정
* 9 정규식의 끝까지 도착했음. 성공! 스트링 "abcde"에서 'abcd'를 매치하였음

이 과정에서 눈여겨 볼 것들.
* 두번째 그룹의 세번째 후보인 'de'도 매치가 가능했지만, 거기까지 시도하기 전에 종료하였음 - 특정한 캐릭터 위치에서, 가능한 후보 중 가장 왼쪽의 것이 선택됨
* 위에서는 스트링의 첫번째 캐릭터 위치인 'a'자리에서 매치를 할 수 있었음. 만일 그 자리에서 가능한 매치가 전혀 없었다면, 두번째 위치인 'b'로 이동한 후 전 과정을 처음부터 다시 하였을 것임
* 모든 캐릭터 위치에서 모든 가능한 경로를 테스트해 본 후에야 매치가 실패했다고 선언하게 됨




==== # 매치된 부분 추출 Extracting matchers ====

<index(metacharacter:::( ))>의 또다른 용도: 매치된 부분을 추출해낸다. 각 괄호에 해당하는 값이 <ix(matching variable)> <index(matching variable:::$1)>,$2, ...에 들어감.
{{{#!vim perl
# 시, 분, 초를 추출
if ($time =~ /(\d\d):(\d\d):(\d\d)/) {  # match hh:mm:ss format
    $hours = $1;
    $minutes = $2;
    $seconds = $3;
}
}}}
<ix(=~)> 구문은 <index(context:::scalar context)>에서는 참/거짓을 반환하며 <index(context:::list context)>에서는 매치 변수들의 리스트를 반환한다. 따라서 다음과 같이 할 수 있다:
{{{#!vim perl
# 시, 분, 초를 추출
($hours, $minutes, $second) = ($time =~ /(\d\d):(\d\d):(\d\d)/);
}}}

그룹이 중첩되는 경우, 제일 왼쪽에 있는 여는 괄호에 의해 생긴 그룹이 <code>$1</code>에 대응되고, 두번째로 나오는 여는 괄호가 <code>$2</code>에 대응된다.
{{{#!vim perl
    /(ab(cd|ef)((gi)|j))/;
     1  2      34
}}}
* 위 정규식이 매치에 성공하면, <code>$1</code>에는 'ab'로 시작하는스트링이 들어가고, <code>$2</code>에는 'cd'또는 'ef'가 들어가고, <code>$3</code>에는 'gi'또는 'j'가 들어가고, <code>$4</code>는 $3과 마찬가지로 'gi'가 되거나, 정의되지 않는 상태로 남게 된다.

<index(matching variable:::$+)>와 <index(matching variable:::$^N)>
* $+ : 할당된 $1,$2,... 매치 변수 중 가장 높은 번호에 해당하는 변수의 값
* $^N : 가장 마지막에 할당된 값 (가장 우측에 있는 닫는 괄호에 해당하는 값)
<blockquote>
주인장 추가:

테스트 결과, 위의 예제에서 $4가 undef일 경우 $+는 $3에 대응된다. 다만 상황에 따라 매치 변수의 값이 빈 스트링 ""일 때도 있고 이 때는 $+도 이 변수에 대응된다. undef인 경우와 구분해야 함

추가로 작성해 본 예문
{{{#!vim perl
$time = "12:34:56";
$time =~ /(\d\d):(\d\d):((\d)\d)/;
          1      2      34
print "$1-$2-$3-$+-$^N";           # 12-34-56-5-56
}}}
</blockquote>



==== # 백레퍼런스 Backreferences ====


<index(backreference)> <index(backreference:::\g1)>, \g2... - 정규표현식 내부에서 쓸 수 있는 매칭변수. 앞에 무엇이 매치되었느냐에 따라 뒤에 매치할 것이 달라지게 만들 수 있다.
<blockquote>
주인장 추가: 이전 버전에서는 <code>\1</code>, <code>\2</code> 이런 식이었는데, Perl <index(Perl:::5.14.0)> 문서에서부터 표기법이 이렇게 바뀌었다. <code>\g{N}</code> 형태 자체는 Perl <index(Perl:::5.10.0)>에서부터 생겼음[http://search.cpan.org/~flora/perl-5.14.2/pod/perl5100delta.pod]
</blockquote>


3글자짜리 단어가 공백을 사이에 두고 두 번 연속으로 나오는 경우에 매치되는 정규식:
{{{#!vim perl
/\b(\w\w\w)\s\g1\b/;    # "hey hey" "wow wow" 등에 매치
}}}

같은 말이 두 번 반복된 단어를 골라내는 예:
{{{#!vim
% simple_grep '^(\w\w\w\w|\w\w\w|\w\w|\w)\g1$' /usr/dict/words
beriberi
booboo
coco
mama
murmur
papa
}}}

<code>$1</code>,<code>$2</code>,..는 정규표현식 바깥에서만, <code>\1</code>,<code>\2</code>,..는 정규표현식 안에서만 사용할 것.



==== # 상대적 백레퍼런스 Relative backreferences ====

여는 괄호를 앞에서부터 세어서 백레퍼런스의 번호를 매기는 것은, 괄호를 사용한 캡처 그룹 둘 이상 있으면 오류를 범하기 쉽다. Perl <index(Perl:::5.10.0)>부터는 상대적 백레퍼런스(<index(backreference:::relative backreference)>를 사용할 수 있음.

현재 위치에서 바로 앞에 있는 캡처 그룹을 가리킬 때는 <index(backreference:::\g{-1})>로 표기. 그 앞에 있는 것은 <code>\g{-2}</code>, 등.

가독성 뿐 아니라 코딩 시의 에러도 줄일 수 있다. 다음 패턴을 살펴보자:
{{{#!vim perl
$a99a = '([a-z])(\d)\g2\g1'; # a11a, g22g, x33x, 등에 매치됨
}}}

패턴을 간편하게 스트링으로 변수에 저장했으니, 다른 패턴의 일부로 사용을 할 수 있다:
{{{#!vim perl
$line = "code=e99e";
if ($line =~ /^(\w+)=$a99a$/){      # 기대와 다르게 동작!
	print "$1 is valid\n";
} else {
	print "bad line: '$line'\n";
}
}}}

위 코드는 의도한 대로 동작하지 않는다. <code>(\w+)</code>가 1번 그룹이 되어 버리고 $a99a에 있는 그룹들은 번호가 1씩 뒤로 밀린다. 상대적 백레퍼런스를 사용하면 이 문제를 피할 수 있다:

{{{#!vim perl
$a99a = '([a-z])(\d)\g{-1}\g{-2}';  # 다른 곳에 삽입되어도 안전함
}}}



==== # 이름을 붙인 백레퍼런스 Named backreferences ====


Perl <index(Perl:::5.10.0)>부터 <index(backreference:::named backreference)> 지원
* 캡처 그룹과 백레퍼런스에 이름을 붙일 수 있음.
* <index(backreference:::(?<name>))> 또는 <index(backreference:::(?'name'))> 로 그룹에 이름을 붙임
* <index(backreference:::\g{name})> 형태로 백레퍼런스에 이름을 붙임
* 패턴 바깥에서는 이름붙은 캡처 그룹에 <index(matching variable:::%+)> 해시를 통해 접근 가능

세 가지 패턴 yyyy-mm-dd, mm/dd/yyyy, dd.mm.yyyy 로 주어지는 달력의 날짜를 매치하여 년월일을 추출하는 예:
{{{#!vim perl
$fmt1 = '(?<y>\d\d\d\d)-(?<m>\d\d)-(?<d>\d\d)';
$fmt2 = '(?<m>\d\d)/(?<d>\d\d)/(?<y>\d\d\d\d)';
$fmt3 = '(?<d>\d\d)\.(?<m>\d\d)\.(?<y>\d\d\d\d)';
for my $d qw( 2006-10-21 15.01.2007 10/31/2005 ){
	if ( $d =~ m{$fmt1|$fmt2|$fmt3} ){
		print "day=$+{d} month=$+{m} year=$+{y}\n";
	}
}
}}}



===== # 이름을 붙인 백레퍼런스 보충 =====

<blockquote>
자동으로 부여되는 번호와 달리, 프로그래머가 이름을 붙이면 다음 두 가지 문제를 생각해 볼 수 있다.
* 한 패턴 안에 동일한 이름의 캡처 그룹이 둘 이상 있으면 어떻게 되는가?
* 이름이 붙은 그룹에도 번호가 붙는가?

이 두 사안에 대해서 프로그래밍 언어나 라이브러리에 따라 다르게 처리한다. 자세한 것은 [http://www.regular-expressions.info/named.html Regex Tutorial - Named Capturing Groups - Backreference Names] 참고. Perl의 경우는 Perldoc:perlre 에서 짧게 언급하고 있다.

첫번째 문제의 경우, 두번 이상 사용된 이름을 가리키는 백레퍼런스는, "정의된 그룹 중 가장 왼쪽에 있는 그룹"을 가리키게 된다.
{{{#!vim perl
'abcd' =~ /(a)(?<x>b)?(c)(?<x>d)/;
print "x[$+{x}]\n";                 # "b"

'acd' =~ /(a)(?<x>b)?(c)(?<x>d)/;   # 여기선 두번째 그룹이 매치가 안 되고, 해당 캡처 그룹에 대한 레퍼런스는 정의되지 않음.
print "x[$+{x}]\n";                 # "d"
}}}

두번째 문제의 경우, Perl에서는 이름이 붙은 그룹도 이름이 없는 그룹들과 함께 처리되어 왼쪽에서부터 번호가 부여된다. (위 참고 링크에 따르면 .NET 스타일 정규식의 경우 일단 이름없는 그룹들부터 번호를 부여한 후, 그 다음 이름 붙은 그룹들 번호를 매긴다고)
{{{#!vim perl
'acd' =~ /(a)(?<x>b)?(c)(?<x>d)/;
print "[$1][$2][$3][$4]\n";      # [a][b][c][d], .NET스타일 정규식에선 [a][c][b][d]
}}}
</blockquote>


==== # 캡처 그룹 번호 리셋 Alternative capture group numbering ====


캡처 그룹에 번호를 매기는 또다른 방법. 역시 Perl <index(Perl:::5.10.0)>에서 추가됨. 여러 후보 패턴들의 집합 안에 있는 그룹을 가리킬 때 요긴. (branch-reset group 이라고도 부름)

민간(hh:mm)또는 군대(hhmm) 스타일로 된 시각을 매치하는 패턴의 예:
{{{#!vim perl
if ( $time =~ /(\d\d|\d):(\d\d)|(\d\d)(\d\d)/ ){
	# 시와 분을 추출하여 처리
}
}}}
위 코드에서는, $1과 $2, 또는 $3과 $4 중 어느쪽이 데이타를 담고 있는지를 검사하기 위해 추가로 if 구문이 필요하다. 두번째 후보에 있는 그룹에도 번호1과 2를 부여할 수 있으면 편할 것이다.

<index(capture group number reset:::(?|...))> 내에 있는 각 캡처 그룹은, 각 후보들마다 동일한 번호로 시작한다. 그룹이 끝난 후에는, 후보들 중 가장 번호가 많이 부여된 그룹의 번호 다음번호부터 부여된다.
{{{#!vim perl
if ( $time =~ /(?|(\d\d|\d):(\d\d)|(\d\d)(\d\d))\s+([A-Z][A-Z][A-Z])/ ){
	print "hour=$1 minute=$2 zone=$3\n";
}
}}}



===== # 그룹 번호 리셋 내용 보충 =====

<blockquote>
주인장 보충:

* Perldoc:perlre 에 있는 예:
{{{#!vim perl
# before  ---------------branch-reset----------- after
/ ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
# 1            2         2  3        2     3     4
}}}

* [http://www.effectiveperlprogramming.com/blog/559 Use branch reset grouping to number captures in alternations | The Effective Perler]에 있는 예
{{{#!vim perl
/
(?|
	(Buster)       |  # $1, $2는 undef
	(Mimi)(Roscoe) |  # $1, $2
	(Ella)            # $1, $2는 undef
)
(                         # $3
	Ginger
)
/x
}}}
* 위 블로그 글 하단에 있는 요점:
** Perl 은 왼쪽괄호가 코드에서 나타나는 순서에 따라 캡처 그룹에 번호를 매긴다
** alternation 안에 있는 모든 그룹에 대해 캡처 버퍼가 생성된다
** 패턴 리셋 그룹핑 <code>(?|...)</code>을 사용하면 alternation 내의 각 대체 패턴마다 버퍼의 번호를 새로 시작한다
** alternation 내에 named group 을 사용할 경우는 같은 번호가 매겨지는 그룹에는 같은 라벨을 붙일 것
</blockquote>

<blockquote>
그런데 <index(Perl:::5.14.0)> 이전 버전에는 버그가 있다.

아래 코드는 단지 그룹 내 부분 그룹의 순서를 바꿨을 뿐인데, 결과가 달라진다.
{{{#!vim perl
while (1) {
    my $input = <STDIN>;
    chomp $input;
    if ( $input =~ /(?|(a)(b)|(c))(d)/ ) {
#    if ( $input =~ /(?|(c)|(a)(b))(d)/ ) {
        print "1[$1] 2[$2] 3[$3]\n";
    }
}
}}}

{{{#!vim
(첫번째 if 문을 사용했을 때)
abd
1[a] 2[b] 3[d]
cd
Use of uninitialized value $2 in concatenation (.) or string at d:\Temp\test.pl line 13, <STDIN> line 2.
1[c] 2[] 3[d]

(두번째 if 문을 사용했을 때)
abd
Use of uninitialized value $3 in concatenation (.) or string at d:\Temp\test.pl line 13, <STDIN> line 1.
1[a] 2[d] 3[]
cd
Use of uninitialized value $3 in concatenation (.) or string at d:\Temp\test.pl line 13, <STDIN> line 2.
1[c] 2[d] 3[]
}}}

이 문제를 피하려면, 그룹에 부여되는 번호가 가장 큰 (즉 캡처 그룹의 수가 가장 많은) 후보를 제일 마지막에 쓰면 안 된다. 또는 빈 그룹 <code>()</code>을 채워넣어서 모든 후보의 그룹 갯수를 똑같이 맞춰주거나.

5.13.11에서 고쳐졌다고 함. (thanks to Twitter:am0c)

참고링크:
* [http://perl5.git.perl.org/perl.git/commit/fd4be6f07df0e6a021290ef721c5d73550e0248c Perl git commit log]
* [http://groups.google.com/group/comp.lang.perl.misc/browse_thread/thread/19ba20491f18d5b6?hl=ko# 뉴스그룹에 질문]
* [http://pastebin.com/mMMVts6T 5.14에서 실행결과]
</blockquote>



==== # 매치 위치 정보 Position information ====


매치되는 위치를 추출하는 방법: <index(matching postion:::@-)>, <index(matching postion:::@+)>
* <code>$-[0]</code> : 전체 표현식이 매치되는 시작 위치
* <code>$+[0]</code> : 전체 표현식이 매치되는 끝 위치
* <index(matching postion:::$-[n])> : $n에 해당하는 스트링의 시작 위치
* <index(matching postion:::$+[n])> : $n에 해당하는 스트링의 끝 위치
** <code>$n</code>이 정의되지 않은 경우는 <code>$-[n]</code>과 <code>$+[n]</code>도 정의되지 않음
{{{#!vim perl
$x = "Mmm...donut, thought Homer";
$x =~ /^(Mmm|Yech)\.\.\.(donut|peas)/;
foreach $expr (1..$#-) {
    print "Match $expr: '${$expr}' at position ($-[$expr],$+[$expr])\n";
}

출력:
Match 1: 'Mmm' at position (0,3)
Match 2: 'donut' at position (6,11)
}}}

<index(matching variable:::$`)> <index(matching variable:::$&)> <index(matching variable:::$')> - 패턴 일치 후 다음 변수를 써서, 일치된 부분과 그 앞뒤의 부분을 얻어낼 수 있다.
{{{#!vim perl
$x = "the cat caught the mouse";
$x =~ /cat/;  # $` = 'the ', $& = 'cat', $' = ' caught the mouse'
$x =~ /the/;  # $` = '', $& = 'the', $' = ' cat caught the mouse'
}}}
* 두번째 예에서, 정규식이 스트링의 첫번째 캐릭터부터 매치되므로 <code>$`</code>는 <code>''</code>가 된다.
* 단 $`와 $'는 매칭을 매우 느리게 하니 쓰는 것을 지양. $&는 그보다는 덜 느려진다.
** 이 변수들을 한 번이라도 사용하면, 프로그램 내의 모든 정규식에 대해 이 변수들이 설정되기 때문이다.
** <index(Perl:::5.10.0)>부터는 <index(matching variable:::${^PREMATCH})>, <index(matching variable:::${^MATCH})>, <index(matching variable:::${^POSTMATCH})> 변수를 사용할 수 있다. 이 변수들은 <index(modifier::://p)> modifier를 주었을 때만 사용가능하다.
** (더 자세한 것은 아래의 [[#matchvariable|매치 변수와 성능 문제]] 참조)



==== # 캡처되지 않는 그룹 Non-capturing groupings ====

<index(non-capturing)> : <ix(non-capturing:::(?:regexp))>

그룹 내의 정규식을 하나의 유닛으로 처리하게 하는 것은 같지만, 캡처 그룹을 생성하지 않는다. 즉 매치된 내용이 추출되지 않으며 <code>$1</code>등의 <ix(matching variable)>에 할당되지도 않는다. 따라서 속도가 더 빠르고, 정규식 내에서 추출되어야 할 부분과 아닌 부분을 정확히 표기하는데도 유용하다:

{{{#!vim perl
    # 숫자에 매치, $1-$4가 설정되지만, 우리는 단지 $1만 필요
    /([+-]?\ *(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?)/;
    # 숫자에 매치, $1만 설정됨
    /([+-]?\ *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)/;
    # 숫자에 매치, $1 = 전체 숫자, $2 = 지수부
    /([+-]?\ *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE]([+-]?\d+))?)/;
}}}

<index(split)>에서 <ix(metacharacter:::grouping)>이나 <ix(metacharacter:::alternation)>을 위해 괄호를 사용하면서 구분자 자체를 배열에 포함하지 않게 하는 데도 쓰임
{{{#!vim perl
        $x = '12aba34ba5';
        @num = split /(a|b)+/, $x;    # @num = ('12','a','34','a','5')
        @num = split /(?:a|b)+/, $x;  # @num = ('12','34','5')
}}}

<ix(extended pattern)>과 같이 사용: (?i-m:regexp) 등



==== # 반복 매치 Matching repetitions ====


'''<index(quantifier)>''' <index(metacharacter)> : <code>?</code>, <code>*</code>, <code>+</code>, <code>{ }</code>
* 정규식의 특정 부분이 반복될 횟수를 지정
* 캐릭터, 캐릭터 클래스, 그룹의 바로 뒤에 명시

* a<index(quantifier:::?)> : 'a'가 1회 또는 0회 매치
* a<index(quantifier:::*)> : 'a'가 0회 또는 그 이상 매치, 즉 임의의 횟수만큼 반복
* a<index(quantifier:::+)> : 'a'가 1회 또는 그 이상 매치, 즉 최소 한 번 이상 반복
* a<index(quantifier:::{n,m})> : 최소 n회, 최대 m회 반복
* a<index(quantifier:::{n,})> : 최소 n회 이상 반복
* a<index(quantifier:::{n})> : 정확히 n회 반복
{{{#!vim perl
/[a-z]+\s+\d*/;  # 소문자로 된 단어, 하나 이상의 공백, 그 다음 임의 갯수의 숫자들
/(\w+)\s+\g1/;   # 임의 글자의 단어가 두 번 반복되는 형태
/y(es)?/i;       # 'y', 'Y', 또는 대소문자 구분없이 'yes'에 매치
$year =~ /^\d{2,4}$/;        # 년도는 최소 2자리 최대 4자리
$year =~ /^\d{4}$|^\d{2}$/;  # 더 나은 형태. 3자리 숫자는 매치되지 않게 함
$year =~ /^\d{2}(\d{2})?$/;  # 다른 형태. 이 경우는 마지막 두 자리가 $1에 캡처됨
}}}

{{{#!vim
% simple_grep '^(\w+)\g1$' /usr/dict/words   # 더 쉬워졌죠?
beriberi
booboo
coco
mama
murmur
papa
}}}

이 수량자들은 <index(quantifier:::maximal match)> (or, <index(quantifier:::greedy)>) quantifier 이다 - 전체 정규식 매치가 성공할 수 있는 선에서, 가능한 가장 긴 <index(스트링)>에 매치된다.

다음 두 매치를 비교:
{{{#!vim perl
$x = "the cat in the hat";
$x =~ /^(.*)(cat)(.*)$/; # 매치됨,
                         # $1 = 'the '
                         # $2 = 'cat'
                         # $3 = ' in the hat'

$x = "the cat in the hat";
$x =~ /^(.*)(at)(.*)$/;   # 매치됨,
                          # $1 = 'the cat in the h'
                          # $2 = 'at'
                          # $3 = ''   (0개의 캐릭터가 매치)
}}}
* 정규식에 두 개 이상의 원소가 있을 때, 제일 왼쪽에 있는 수량자가 최대한 많은 스트링에 매치되고 정규식의 나머지 부분은 남은 스트링을 가지고 매치를 시도하게 된다.

정규표현식이 둘 이상의 방식으로 매치가 가능할 때는, 아래 원칙에 따라 어떤 방식이 선택될지 알 수 있다.
* 원칙 0: 전체 정규식은, <index(스트링)>에서 가능한 한 가장 앞부분부터 매치된다.
* 원칙 1: <code>a|b|c...</code> 형태의 <index(metacharacter:::alternation)>에서, 전체 정규식이 일치하게 할 수 있는 후보들 중 가장 왼쪽에 있는 것을 사용한다.
* 원칙 2: ?, *, +, {n,m} 등의 maximal matching <index(quantifier)>는, 전체 정규식이 일치하게 할 수 있는 한 최대한 많은 스트링을 사용한다.
* 원칙 3: 정규표현식 안에 둘 이상의 요소가 있을 때, 가장 왼쪽에 있는 greedy quantifier는 전체 정규식이 일치하게 할 수 있는 한 최대한 긴 스트링에 매치된다. 그 다음으로 왼쪽에 있는 greedy quantifier는 남아있는 스트링 중에서 역시 전체 정규식이 일치하게 할 수 있는 한 최대한 긴 스트링에 매치된다. 정규식 내의 모든 요소가 매치될 때까지 위 과정을 반복한다.

예제:
{{{#!vim perl
$x = "The programming republic of Perl";
$x =~ /^(.+)(e|r)(.*)$/;  # matches,
                          # $1 = 'The programming republic of Pe'
                          # $2 = 'r'     (e|r)에서 r이 사용된다.
                          # $3 = 'l'
}}}
: 정규식은 <code>'T'</code>에서부터 매치되고, 첫번째 수량자 부분이 가장 긴 스트링을 사용하게 되므로 두번째 그룹에서 왼쪽 후보인 <code>e</code>가 아니라 <code>r</code>이 매치된다.


{{{#!vim perl
$x =~ /(m{1,2})(.*)$/;  # matches,
                        # $1 = 'mm'
                        # $2 = 'ing republic of Perl'
}}}
: 'programming'의 첫번째 'm'에서부터 매치가 되고, <code>m{1,2}</code>는 최대로 매치할 수 있는 <code>mm</code>에 매치된다.

{{{#!vim perl
$x =~ /.*(m{1,2})(.*)$/;  # matches,
                          # $1 = 'm'
                          # $2 = 'ing republic of Perl'
}}}
: 이 경우는 스트링의 시작부분부터 매치되고, 첫번째 수량자 <code>.*</code>가 최대한 많이 사용하므로 두번째 수량자 <code>m{1,2}</code>에는 한 글자 <code>'m'</code>만 매치된다.

{{{#!vim perl
$x =~ /(.?)(m{1,2})(.*)$/;  # matches,
                            # $1 = 'a'
                            # $2 = 'mm'
                            # $3 = 'ing republic of Perl'
}}}
: <code>.?</code>는 매치가 가능한 위치에서 최댓값인 한 글자를 사용하므로 'programming'의 <code>'a'</code>에 매치가 되고, <code>m{1,2}</code>는 두 <code>m</code>에 매치된다.

{{{#!vim perl
"aXXXb" =~ /(X*)/; # 매치됨, $1 = ''
}}}
: <code>X*</code>는 스트링의 시작 부분에서 <code>'X'</code>의 0회 반복에 매치되어 버린다. 최소 하나의 'X'에 매치되길 원하면 <code>X+</code>를 사용하라.


<index(quantifier:::minimal match)> (or, <index(quantifier:::non-greedy)>) quantifier - 일치하는 가장 짧은 <index(스트링)>에 매치
* a<index(quantifier:::??)> : 'a'가 1회 또는 0회 매치. 0회를 먼저 시도하고, 그 다음 1회 매치를 시도
* a<index(quantifier:::*?)> : 'a'가 0회 또는 그 이상 매치, 즉 임의의 횟수만큼 반복, 가능한 한 최소로
* a<index(quantifier:::+?)> : 'a'가 1회 또는 그 이상 매치, 즉 최소 한 번 이상 반복, 가능한 한 최소로
* a<index(quantifier:::{n,m}?)> : 최소 n회, 최대 m회 반복, 가능한 한 최소로
* a<index(quantifier:::{n,}?)> : 최소 n회 이상 반복, 가능한 한 최소로
* a<index(quantifier:::{n}?)> : 정확히 n회 반복, a{n}?는 a{n}과 동일하며, 단지 표기법의 일관성을 위해 존재

minimal quantifier 예:
{{{#!vim perl
$x = "The programming republic of Perl";
$x =~ /^(.+?)(e|r)(.*)$/; # matches,
                          # $1 = 'Th'
                          # $2 = 'e'
                          # $3 = ' programming republic of Perl'
}}}
: 스트링의 시작 <code>^</code>와 두번째 그룹의 alternation을 만족시킬 수 있는 최소 길이 스트링은 <code>Th</code>이고, <code>e|r</code>은 <code>e</code>가 매치되고, 마지막 <code>.*</code>는 나머지 스트링 전부를 사용한다.

{{{#!vim perl
$x =~ /(m{1,2}?)(.*?)$/;  # matches,
                          # $1 = 'm'
                          # $2 = 'ming republic of Perl'
}}}
: 첫번째 'm'부터 매치되고, <code>m{1,2}?</code>는 하나의 'm'만 매치된다. 두번째 수량자 <code>.*?</code>는 0개의 캐릭터에 매치되는 걸 더 원했겠지만, 여기서는 <index(anchor:::$)> 때문에 제약을 받아 나머지 스트링 전부에 매치된다.

{{{#!vim perl
$x =~ /(.*?)(m{1,2}?)(.*)$/;  # matches,
                              # $1 = 'The progra'   (.*?)이지만 $1=''가 아니다!! 원칙0이 적용
                              # $2 = 'm'
                              # $3 = 'ming republic of Perl'
}}}
: 이 경우, <code>^</code>앵커가 없기 때문에 첫번째 minimal quantifier <code>.*?</code>가 (첫번째 'm'바로 앞에 있는) 빈 스트링에 매치될 거라 기대했을 수 있지만, 원칙0이 적용된다. 전체 정규식을 스트링의 제일 첫부분부터 매치시키는 게 가능하기 때문에 실제로 그렇게 매치시키고, 첫번째 수량자는 첫번째 'm'바로 앞 부분까지 스트링 전부에 대응된다. 두번째 수량자는 하나의 'm'에 매치되고, 세번째 것은 나머지 스트링 전부에 매치된다.

{{{#!vim perl
$x =~ /(.??)(m{1,2})(.*)$/;  # matches,
                             # $1 = 'a'
                             # $2 = 'mm'
                             # $3 = 'ing republic of Perl'
}}}
: 직전 예와 마찬가지로, <code>.??</code>가 매치될 수 있는 가장 앞부분이 <code>'a'</code>이므로 거기에 매치된다.

non-greedy quantifier 를 고려하여, 원칙3을 다음과 같이 수정할 수 있다:
* 원칙 3: 정규표현식 안에 둘 이상의 요소가 있을 때, 가장 왼쪽에 있는 greedy (non-greedy) quantifier는 전체 정규식이 일치하게 할 수 있는 한 최대한 긴 (짧은) 스트링에 매치된다. 그 다음으로 왼쪽에 있는 greedy (non-greedy) quantifier는 남아있는 스트링 중에서 역시 전체 정규식이 일치하게 할 수 있는 한 최대한 긴 (짧은) 스트링에 매치된다. 정규식 내의 모든 요소가 매치될 때까지 위 과정을 반복한다.


alternation처럼 quantifier도 backtracking에 연관된다. 다음 예제 참고
{{{#!vim perl
$x = "the cat in the hat";
$x =~ /^(.*)(at)(.*)$/; # matches,
                        # $1 = 'the cat in the h'
                        # $2 = 'at'
                        # $3 = ''   (0 matches)
}}}
* 0 스트링의 첫번째 글자인 't'에서 시작
* 1 첫번째 수량자 '.*'는 전체 스트링 'the cat in the hat'에 매치되는 것부터 시작
* 2 정규식의 'at'에 있는 'a'가 스트링의 끝에 매치되지 않음. 한 글자 되돌아옴
* 3 정규식의 'at'에 있는 'a'가 여전히 스트링의 마지막 글자 't'에 매치되지 않음. 한 글자 더 되돌아옴
* 4 이제 'a'와 't'를 매치시킬 수 있음
* 5 정규식의 세번째 요소인 '.*'로 이동. 현재 스트링의 제일 끝에 와 있으므로, '.*'를 0회 반복에 매치시킬 수 있음. 빈 스트링을 할당
* 6 완료

대부분의 경우 이러한 정규식 매칭 과정은 매우 빠르게 수행되지만, 정확한 숫자가 지정되지 않은 <index(quantifier)> (*, +, {n,m}등) 가 '''중첩되어''' 사용될 경우, 검색 시간은 <index(스트링)> 길이의 지수함수로 증가한다. 따라서 사용을 자제할 것.
{{{#!vim perl
/(a|b+)*/;
}}}
* Jeffrey Friedl의 ''Mastering Regular Expressions''에서는 이 문제와 그 외 정규식의 효율에 관한 이슈에 대해 깊이 논의하고 있다.



==== # 독점적 수량자 Possessive quantifiers ====

매치될 부분을 찾기 위해 반복적으로 백트래킹하는 것은 시간낭비일 수 있다. 특히 매치가 실패할 운명일 때 더욱 그렇다. 다음 예를 보자:
{{{#!vim perl
/^\w+\s+\w+$/; # 단어, 공백, 단어
}}}

우리가 찾고자 하는 패턴에 해당되지 않는 <code>"abc "</code>나 <code>"abcdef "</code> 등에 이 정규식을 적용할 경우, 스트링의 각 캐릭터마다 백트랙하게 될 것이다. 그러나 절대 매치되지 않을 것을 알고 있다.

<index(Perl:::5.10.0)>부터는 <index(quantifier:::possessive)> quantifier 제공:
* 정규식 엔진이 백트래킹을 하지 않도록 지시
* 일반 수량자 뒤에 <code>+</code>를 붙임
* greedy하게 동작하면서, 일단 매치에 성공한 부분은 다른 매치를 테스트하기 위해 되돌려주지 않는다.

* a<index(quantifier:::{n,m}+)> : 최소 n회, 최대 m회 반복, 가능한 한 많이 반복, 매치된 부분은 내어놓지 않음.
* a<index(quantifier:::?+)> : <code>a{0,1}+</code>와 같음
* a<index(quantifier:::{n,}+)> : 최소 n회 반복, 가능한 한 많이 반복, 매치된 부분은 내어놓지 않음.
* a<index(quantifier:::*+)> : <code>a{0,}+</code>와 같음
* a<index(quantifier:::++)> : <code>a{1,}+</code>와 같음
* a<index(quantifier:::{n}+)> : 정확히 n회 반복. 표기의 일관성을 위해 존재

독점적 수량자는 뒤에 나올 ''independent subexpression'' 중 특수한 경우를 나타낸다.

독점적 수량자를 쓰는 적합한 예로, 따옴표로 둘러쌓인 인용문을 매치하는 경우를 생각할 수 있다. 이 때 백슬래쉬는 자기 다음 문자가 다른 문자들처럼 문자 그대로 해석되도록 이스케이프한다. 따라서, 여는 따옴표 뒤에, 이스케이프되지 않은 따옴표나 백슬래쉬를 제외한 나머지 문자와, 이스케이프 캐릭터가 각각 후보인 alternative가 (0번 이상) 반복되는 형태로 생각될 수 있다.
{{{#!vim perl
/"(?:[^"\\]++|\\.)*+"/;
}}}



===== # 독점적 수량자 내용 보충 =====
<blockquote>
주인장 추가:

possessive quantifier에 대해 perlretut 문서의 내용이 잘 와닿지 않는다. 다음 두 문서를 참고하면 좋다.
* [http://www.regular-expressions.info/possessive.html Regex Tutorial - Possessive Quantifiers] - 설명이 잘 나와 있음
* Cpan:perlre

일단, 독점 수량자는 greedy한 수량자와 서로 다른 매치 결과를 낼 수 있으니 주의하라:
{{{#!vim perl
'aaaa' =~ /a++a/
}}}
* 위 패턴은 매치되지 않는다. <code>a++</code>가 <code>'aaaa'</code> 전부에 매치되고, 그 다음 부분인 <code>a</code>에 매치될 게 남지 않는다. <code>a+</code>를 썼다면 이때 백트래킹하면서 'a'하나를 내어놓아서 다음 패턴에 매치되게 하였겠지만, 독점적 수량자는 백트래킹을 하지 않는다.

독점적 수량자가 유용한 경우의 예는 다음과 같다.
{{{#!vim perl
'aaaa' =~ /a++b/
}}}
* 위 패턴 역시 매치하지 않는다. 그러나 greedy 수량자를 썼을 경우는 <code>a+</code> 정규식은 처음에 'aaaa'에 매치되고, <code>b</code>를 매치할 수 없으므로 한 글자를 백트래킹하여 'aaa'에 매치되고, 마찬가지로 'aa','a'에 매치되면서 계속 <code>b</code>를 매치시키려고 하며, 매번 무의미하게 실패하게 된다. 그러나 독점적 수량자를 사용한 경우 <code>a++</code>는 첫 시도에 'aaaa'에 매치된 후에, 그 위치에서 더 이상 백트래킹을 하지 않게 하므로, <code>b</code>가 스트링의 끝에 대응되어서 매치가 안 되는 것을 확인하는 순간 매치 실패를 판정한다. 매우 효율적이다. (단, 여기서 전체 검사가 완전히 종료되는 건 아니다. 스트링의 그 다음 위치, 즉 두번째 a부터 시작해서 'aaa'를 대상으로 다시 시도하게 된다)

따라서 독점적 수량자를 사용할 경우에는, 독점적 수량자를 적용하는 부분의 패턴이, 그 뒷부분에 있는 패턴과 매치되지 않는 게 확실한지 확인해야 한다. 위 예에서는 <code>a++</code>의 <code>a</code>가 뒤에 있는 패턴 <code>b</code>와 일치될 수 없다. 즉, '<code>a++</code>을 매치시키는 동안, 실수로 스트링 내에 있는 'b'를 잡아먹어 버렸을 리가 없다'는 것이다. 반면 <code>.++b</code> 같은 패턴은 <code>.</code>가 <code>b</code>에도 매치되므로 의도하지 않은 결과를 낼 수 있다.
</blockquote>



==== # 정규표현식 구성하기 Building a regexp ====

"수"에 매치되는 정규표현식을 작성하는 예

먼저, 매치시키고 싶은 것과 제외하고 싶은 것을 결정한다.
* 정수와 소수를 매치. 수가 아닌 것을 제외

문제를 단순화 시킨다.
* 정수와 소수로 분리한다.
* 정수: digit의 반복. 앞에 + 또는 -가 올 수 있다.
{{{#!vim perl
        /[+-]?\d+/;  # 정수에 매치
}}}
* 소수:
** 가능한 예: 123., 0.345, .34, -1e6, 25.4E-72, 여기에 +또는 -가 앞에 올 수 있음
** 지수가 없는 경우
** <code>\d*\.\d*</code>를 쓰면 안된다. ("."가 매치되어 버릴 수 있다)
** 정수부와 소수부의 유무에 따라 세가지 경우로 나눈다.
{{{#!vim perl
       /[+-]?\d+\./;     # 1., 321., etc.
       /[+-]?\.\d+/;     # .1, .234, etc.
       /[+-]?\d+\.\d+/;  # 1.0, 30.56, etc.
}}}

세 가지 후보를 결합하여 <index(metacharacter:::alternation)> 형태로 만들 수 있다.
{{{#!vim perl
       /[+-]?(\d+\.\d+|\d+\.|\.\d+)/;  # 지수부가 없는 부동소수
                                       # "\d+\.\d+"가 제일 앞에 와야만 한다.
}}}

지수가 있는 경우를 고려한다. 지수부는 정수와 소숫점이 있는 소수 양쪽에 다 붙을 수도 있다. 따라서 앞에 매치되는 숫자에 소숫점이 있는지 없는지에 무관하며, 유효숫자부와 별개로 처리할 수 있다.
{{{#!vim perl
        /^(optional sign)(integer | f.p. mantissa)(optional exponent)$/;
}}}

지수부의 형태는 <code>e</code> 또는 <code>E</code> 뒤에 정수가 오는 것이다.
{{{#!vim perl
       /[eE][+-]?\d+/;  # 지수부
}}}

따라서 전체 정규표현식은
{{{#!vim perl
       /^[+-]?(\d+\.\d+|\d+\.|\.\d+|\d+)([eE][+-]?\d+)?$/;  # 짠~
}}}

위와 같이 복잡한 정규식은, <index(modifier::://x)> <index(modifier)>를 사용하여 공백과 주석을 추가하여 읽기 쉽게 만들 수 있다.
{{{#!vim perl
       /^
          [+-]?         # 먼저, 부호에 매치
          (             # 그 다음 정수 또는 소수의 유효숫자부에 매치
              \d+\.\d+  # a.b 형태의 유효숫자
             |\d+\.     # a. 형태의 유효숫자
             |\.\d+     # .b 형태의 유효숫자
             |\d+       # a 형태의 정수
          )
          ([eE][+-]?\d+)?  # 끝으로, 추가적으로 올 수 있는 지수부에 매치
       $/x;
}}}

이 때 정규식 내의 스페이스를 넣고 싶으면 <code>\ </code> 또는 <code>[ ]</code>로 표기한다. 마찬가지로 <code>#</code>은 각각 <code>\#</code> 또는 <code>[#]</code>으로 표기한다.
* 위 정규식에 부호와 유효숫자부 사이에 공백이 있는 것을 허용할 경우:
{{{#!vim perl
       /^
          [+-]?\ *      # 먼저, 부호와 *공백*에 매치
          (             # 그 다음 정수 또는 소수의 유효숫자부에 매치
              \d+\.\d+  # a.b 형태의 유효숫자
             |\d+\.     # a. 형태의 유효숫자
             |\.\d+     # .b 형태의 유효숫자
             |\d+       # a 형태의 정수
          )
          ([eE][+-]?\d+)?  # 끝으로, 추가적으로 올 수 있는 지수부에 매치
       $/x;
}}}

alternation 그룹의 1,2,4번째 후보는 다 <code>\d+</code>로 시작하므로, 이것을 뽑아내어 더 단순하게 만들 수 있다.
{{{#!vim perl
       /^
          [+-]?\ *      # 먼저, 부호와 공백에 매치
          (             # 그 다음 정수 또는 소수의 유효숫자부에 매치
              \d+       # a로 시작하면서...
              (
                  \.\d* # a.b 또는 a. 형태의 유효숫자
              )?        # ?는 a 형태의 정수가 오는 경우를 고려한 것
             |\.\d+     # .b 형태의 유효숫자
          )
          ([eE][+-]?\d+)?  # 끝으로, 추가적으로 올 수 있는 지수부에 매치
       $/x;
}}}

또는 압축된 형태로 다시 쓸 수 있다:
{{{#!vim perl
        /^[+-]?\ *(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
}}}

이렇게 해서 정규식을 완성하였다. 다시 정리하면 정규식을 만들기 위하여 다음의 과정을 거쳤다.
* 작업을 자세하게 명세하고
* 문제를 작은 부분들로 나눈 후
* 작은 부분들을 정규식으로 변환하고
* 정규식들을 결합한 후
* 결합된 정규식을 최적화

이 과정들은 컴퓨터 프로그램을 작성할 때도 거치게 되는 과정이다. 완전히 통하는 면이 있는 것이, 정규표현식은 본질적으로 패턴을 명세하는 용도의 컴퓨터 언어로 짠 프로그램이기 때문이다.




==== # Using regular expression in Perl ====


정규표현식을 사용하는 데 관련된 Perl의 문법들

현재까지 다룬 내용
* <ix(matching operator)>
** <ix(matching operator:::/regexp/)> - 기본 형태
** <ix(matching operator:::m!regexp!)> - 임의의 구분자 사용
** <ix(=~)> - 바인딩 연산자
** <ix(=~:::!~)> - 부정 형태
* <ix(modifier)>
** <ix(modifier::://s)> - single line
** <ix(modifier::://m)> - multi-line
** <ix(modifier::://i)> - 대소문자 구분하지 않음
** <ix(modifier::://x)> - 정규식 확장

이 섹션의 남은 부분에서는 매칭 연산자에 대해 추가로 알아둘 만한 것들을 다룬다.


===== # 치환 방지 Prohibiting substitution =====

변수 치환이 전혀 일어나지 않게 하고 싶으면, 특별한 구분자인 <index(matching operator:::m'regexp')>을 사용하라:
{{{#!vim perl
        @pattern = ('Seuss');
        while (<>) {
            print if m'@pattern';  # 문자 그대로 '@pattern'에 매치된다, 'Seuss'가 아니라.
        }
}}}

<index(스트링)>에서와 마찬가지로 <code>m''</code>는 아포스트로피처럼 동작하고, 그 외 다른 <code>m</code>구분자들은 따옴표처럼 동작한다.

정규표현식을 평가했더니 빈 스트링인 경우, ''마지막으로 매치에 성공했던'' 정규식이 대신 사용된다<footnote(매치에 성공한 스트링이 아니라 패턴 자체가 재사용됨)>
{{{#!vim perl
        "dog" =~ /d/;     # 'd'에 매치됨
        "dogbert" =~ //;  # 이전에 사용되었던 'd' 정규식에 매치됨
}}}



===== # 글로벌 매칭 Global matching =====


<ix(modifier::://g)> <index(modifier::://c)> modifier - 매칭을 반복하는 동작
* <code>//g</code> : 글로벌 매칭. 한 스트링 안에서 매칭을 가능한 한 여러번 반복 수행.
* <index(context:::scalar context)>에서, 하나의 스트링에 연속적으로 사용될 때마다 매치되는 부분들을 따라가며 포지션을 이동
* 이 포지션 값은 <ix(pos())> 함수로 얻어내거나 설정할 수 있다.

공백으로 구분된 여러 단어로 이루어진 스트링이 있다고 하자. 단어의 갯수를 알면 그룹을 써서 각 단어들을 추출할 수 있다:
{{{#!vim perl
        $x = "cat dog house"; # 3 words
        $x =~ /^\s*(\w+)\s+(\w+)\s+(\w+)\s*$/; # matches,
                                               # $1 = 'cat'
                                               # $2 = 'dog'
                                               # $3 = 'house'
}}}

단어의 갯수를 모른다면? 단순한 정규식 <code>(\w+)</code>를 구성한 후 <code>/(\w+)/g</code>를 사용하여 매치되는 모든 곳에 대해 루프를 돌아라:
{{{#!vim perl
        while ($x =~ /(\w+)/g) {
            print "Word is $1, ends at position ", pos $x, "\n";
        }
}}}

출력은 다음과 같다
{{{#!vim
        Word is cat, ends at position 3
        Word is dog, ends at position 7
        Word is house, ends at position 13
}}}

매치에 실패하거나 타겟스트링이 바뀌면 포지션은 리셋된다<footnote(즉, pos $x 를 했을 때 undef이 반환된다)>. 매치에 실패해도 리셋되지 않게 하려면 <code>/regexp/gc</code>와 같이 <ix(modifier::://c)> modifier를 같이 사용한다. 현재 포지션 값은 정규식이 아니라 각 스트링에 결합되어 있다. 서로 다른 스트링은 서로 다른 포지션 값을 갖고 있고, 각각을 독립적으로 설정하거나 읽을 수 있다.

<index(context:::list context)>에서 <ix(modifier::://g)>는 매치된 그룹들의 리스트를 반환한다. 패턴 내에 그룹이 없을 경우 전체 정규식에 일치하는 문자열의 리스트를 반환한다.
{{{#!vim perl
        @words = ($x =~ /(\w+)/g);  # matches,
                                    # $word[0] = 'cat'
                                    # $word[1] = 'dog'
                                    # $word[2] = 'house'
}}}

<ix(anchor:::\G)> - 직전에 사용된 <ix(modifier::://g)>에 의해 일치한 부분의 끝에 일치한다. 현재는 정규식의 제일 첫 부분에 사용되었을 때만 제대로 지원이 된다.

<code>\G</code>를 써서 문맥에 의존하는 매칭을 할 수 있다:
{{{#!vim perl
        $metric = 1;              # 미터법을 쓰도록 설정
        ...
        $x = <FILE>;              # 측정값을 읽음
        $x =~ /^([+-]?\d+)\s*/g;  # 수치 부분을 읽음
        $weight = $1;
        if ($metric) {            # 에러 체크
            print "Units error!" unless $x =~ /\Gkg\./g;
        }
        else {
            print "Units error!" unless $x =~ /\Glbs\./g;
        }
        $x =~ /\G\s+(widget|sprocket)/g;  # 계속 진행
}}}

<code>//g</code>와 <code>\G</code>를 조합하여, 스트링의 일부를 먼저 처리하고 그 다음 무엇을 할 것인지 Perl 논리구조를 사용하여 결정할 수 있다.

<code>\G</code>는 또한 고정된 길이의 레코드를 정규식으로 처리할 때 유용하다. DNA 영역에서 <code>TGA</code> 코돈(codon, 3-문자 순열)을 모두 찾는 경우의 예: DNA 단편을 3글자짜리 레코드들의 순열로 생각할 수 있다.
{{{#!vim perl
        # expanded, this is "ATC GTT GAA TGC AAA TGA CAT GAC"
        $dna = "ATCGTTGAATGCAAATGACATGAC";
        $dna =~ /TGA/;
}}}
위 매치는 아무 위치에서나 <code>TGA</code>에 매치되므로 안 된다.

개선된 풀이는
{{{#!vim perl
        while ($dna =~ /(\w\w\w)*?TGA/g) {  # note the minimal *?
            print "Got a TGA stop codon at position ", pos $dna, "\n";
        }
}}}

다음과 같이 출력된다:
{{{#!vim
        Got a TGA stop codon at position 18
        Got a TGA stop codon at position 23
}}}

18번째 캐릭터 포지션은 맞다. 그런데 23번은 틀렸다. 위의 정규식은 마지막으로 제대로 매치된 시점 이후부터 제대로 동작하지 않는다. 그 이후 정규식이 <code>TGA</code> 코돈에 매치에 실패하고, 스트링의 포지션을 한 글자 이동하여 재시도하게 된다. 이 문제를 해결하는 방법은 <code>\G</code>를 사용하여 코돈 경계 부분에 앵커를 설정하는 것이다:

{{{#!vim perl
        while ($dna =~ /\G(\w\w\w)*?TGA/g) {
            print "Got a TGA stop codon at position ", pos $dna, "\n";
        }
}}}
출력:
{{{#!vim
        Got a TGA stop codon at position 18
}}}

위의 예제는, 원하는 것에 매치하는 것 뿐 아니라 원하지 않는 것을 매치되지 않게 하는 것도 중요함을 보여준다.



(<index(modifier::://o)>, <index(modifier::://d)>, <index(modifier::://l)> 등 정규식에서 사용 가능한 modifier가 몇 개 더 있으나, 이 문서의 범위를 벗어난다)



===== # 검색과 치환 Search and replace =====


정규표현식은 검색과 치환 연산을 할 때도 큰 역할을 한다.

<ix(s///)> - <code>s/regexp/replacement/modifier</code>
* regexp와 modifier는 앞에서 다뤘던 내용 모두가 적용됨
* replacement는 Perl의 따옴표로 둘러싼 스트링처럼 동작하며, regexp에 의해 매치되는 부분을 대체함
* 스트링과 <code>s///</code>를 <ix(=~)>로 연결
* <index($_)>에 대해 수행할 경우 <code>$_ =~</code>는 생략가능
* 전체 식은 치환이 일어난 횟수를 반환. 치환이 일어나지 않았을 때는 false 반환

{{{#!vim perl
        $x = "Time to feed the cat!";
        $x =~ s/cat/hacker/;   # $x 는 "Time to feed the hacker!"
        if ($x =~ s/^(Time.*hacker)!$/$1 now!/) {
            $more_insistent = 1;
        }
        $y = "'quoted words'";
        $y =~ s/^'(.*)'$/$1/;  # 작은따옴표를 벗겨냄
                               # $y 는 "quoted words"
}}}
* 위 마지막 예에서, <index(matching variable)> <code>$1</code> 등은 곧바로 replacement 자리에 사용할 수 있다.


global modifier인 <ix(modifier:::s///g)>를 사용하여 스트링 내에 regexp에 매치되는 모든 부분을 치환
{{{#!vim perl
        $x = "I batted 4 for 4";
        $x =~ s/4/four/;   # 한번만 치환:
                           # $x 는 "I batted four for 4"
        $x = "I batted 4 for 4";
        $x =~ s/4/four/g;  # 전부 치환:
                           # $x 는 "I batted four for four"
}}}

이 튜토리알 문서에서 'regexp'라는 표현보다 'regex'가 더 좋다면, 다음 프로그램을 써서 치환할 수 있다<footnote(Linux,Unix 환경에서)>:
{{{#!vim
% cat > simple_replace
#!/usr/bin/perl
$regexp = shift;
$replacement = shift;
while (<>) {
    s/$regexp/$replacement/g;
    print;
}
^D

% simple_replace regexp regex perlretut.pod
}}}
* 위의 <code>simple_replace</code>에서는 <code>s///g</code>를 써서 각 라인에 나타나는 모든 regexp를 치환환다.
* (정규표현식이 루프 안에 들어가고 있지만, Perl은 똑똑해서 그 정규식을 단 한번만 컴파일한다)<footnote(Perl 5.14에서 추가된 문구이고, 이전 버전에서는 <code>//o</code> modifier를 사용하여 한번만 컴파일하도록 지시했었다. 튜토리알에 포함하기에는 좀 생뚱맞은 문구 같음. 기존 버전에 익숙한 사람들을 위해서 문서 후반에 따로 정리하는게 나았을 듯)>
* <code>simple_grep</code>과 마찬가지로 <code>print</code>와 <code>s/$regexp/$replacement/g</code>는 암시적으로 <code>$_</code>에 대해 수행되었다.


비파괴 치환 수정자(non-destructive substitute modifier) <index(modifier:::s///r)>을 사용하여, <code>s///</code>가 원본 변수를 수정해버리는 것을 막을 수 있다. <code>s///r</code>은 치환된 횟수를 반환하는 것이 아니라 최종적으로 치환된 스트링을 반환한다.
{{{#!vim perl
        $x = "I like dogs.";
        $y = $x =~ s/dogs/cats/r;
        print "$x $y\n";
}}}
* 출력은 "I like dogs. I like cats"
* <code>$x</code>의 값이 변하지 않았고, 치환된 최종 결과는 <code>$y</code>에 담긴다.

아무것도 치환되지 않았다면 원본 스트링이 반환된다:
{{{#!vim perl
        $x = "I like dogs.";
        $y = $x =~ s/elephants/cougars/r;
        print "$x $y\n"; # prints "I like dogs. I like dogs."
}}}

<code>s///r</code>을 써서 연쇄 치환을 할 수 있다:
{{{#!vim perl
        $x = "Cats are great.";
        print $x =~ s/Cats/Dogs/r =~ s/Dogs/Frogs/r =~ s/Frogs/Hedgehogs/r, "\n";
        # prints "Hedgehogs are great."
}}}

치환 연산에서만 사용가능한 evaluation modifier <ix(modifier:::s///e)>
* replacement 텍스트를 큰따옴표로 둘러싼 스트링이 아니라 Perl 코드로 취급한다<footnote(5.12까지는 <code>eval {...}</code>로 둘러싼 후 실행하여 결과를 가지고 치환환다고 설명되었다가, 5.14에서 바뀌었음)>
* 코드가 반환한 값을 매치된 부분스트링을 치환하는데 사용
* 텍스트를 치환하는 과정에서 다소의 연산을 해야 할 때 유용

한 라인에서 문자들의 등장 빈도를 세는 예:
{{{#!vim perl
        $x = "Bill the cat";
        $x =~ s/(.)/$chars{$1}++;$1/eg;  # 마지막 $1는 각 문자를 그 문자 자신으로 치환
        print "frequency of '$_' is $chars{$_}\n"
            foreach (sort {$chars{$b} <=> $chars{$a}} keys %chars);
}}}
출력:
{{{#!vim
        frequency of ' ' is 2
        frequency of 't' is 2
        frequency of 'l' is 2
        frequency of 'B' is 1
        frequency of 'c' is 1
        frequency of 'e' is 1
        frequency of 'h' is 1
        frequency of 'i' is 1
        frequency of 'a' is 1
}}}


<code>s///</code>도 <code>m//</code>처럼 다양한 구분자를 쓸 수 있다.
* <code>s!!!</code>, <code>s{}{}</code>, <code>s{}//</code> 등
* <index(s///:::s''')> - 작은따옴표를 쓰는 경우는, 정규식과 대체스트링 둘 다 작은따옴표로 둘러싼 스트링으로 간주되어 변수 치환 등이 일어나지 않는다.
* <ix(s///)>는 <index(context:::list context)>와 <index(context:::scalar context)>에서 동일한 결과 - 일치가 일어난 횟수 - 를 반환한다.





===== # split 연산자 The split operator =====

<index(split)> 함수에서도 정규표현식이 사용된다.
* <code>split /regexp/, string, limit</code>
* string을 서브스트링들의 리스트로 분할하여서 그 리스트를 반환
* regexp는 서브스트링들을 구분하는 구분자로 구성될 내용에 매치되게 작성해야 함
* limit이 주어질 경우, 최대 limit개까지만 분할
 
{{{#!vim perl
        $x = "Calvin and Hobbes";
        @words = split /\s+/, $x;  # $word[0] = 'Calvin'
                                   # $word[1] = 'and'
                                   # $word[2] = 'Hobbes'
}}}
* regexp가 비었을 경우 (//), regexp는 항상 일치되고, 스트링은 개별 캐릭터들로 쪼개짐
* regexp에 <index(metacharacter:::grouping)>이 있을 경우, 그룹에 일치하는 서브스트링도 리스트에 포함된다.
{{{#!vim perl
        $x = "/usr/bin/perl";
        @dirs = split m!/!, $x;  # $dirs[0] = ''
                                 # $dirs[1] = 'usr'
                                 # $dirs[2] = 'bin'
                                 # $dirs[3] = 'perl'
        @parts = split m!(/)!, $x;  # $parts[0] = ''
                                    # $parts[1] = '/'
                                    # $parts[2] = 'usr'
                                    # $parts[3] = '/'
                                    # $parts[4] = 'bin'
                                    # $parts[5] = '/'
                                    # $parts[6] = 'perl'
}}}
* $x의 첫번째 문자인 "/"가 정규식에 매치되므로, split한 결과 제일 앞에 빈 스트링이 원소로 추가된다.



===== # 패턴 평가 최적화 Optimizing pattern evaluation =====

<memo(이 섹션은 5.14문서에서는 삭제되었음. 기록용으로 남겨둠)>
<code>//o</code> - 변수 치환을 한 번만 한다
* Perl 5.6.0 이후로는 변수의 내용이 바뀌지 않는 경우에는 이 옵션이 없어도 재컴파일을 하지 않는다고 함.<footnote(Mastering Perl, Chapter 02)>
{{{#!vim perl
$pattern = 'Seuss';
while (<>) {
    print if /$pattern/;       # 매 루프마다 변수 치환
}

$regexp = shift;
while (<>) {
    print if /$regexp/o;       # 한 번만 치환.
                               # $regexp 가 루프 안에서 변하지 않는다는 보장이 있을때 사용할 것
}
}}}
</memo>



=== # Part 2: 강력한 도구들 Power tools ===

자주 쓰이지는 않으나 더 강력한 기능들.



==== # 캐릭터, 스트링, 캐릭터 클래스 More on characters, strings, and character class ====

<ix(character class:::\l)> <ix(character class:::\u)> - 바로 다음 캐릭터를 소문자 또는 대문자로 변환. 패턴 내에서도 사용 가능

{{{#!vim perl
        $x = "perl";
        $string =~ /\u$x/;  # $string의 'Perl'에 매치
        $x = "M(rs?|s)\\."; # 백슬래쉬를 두 번 쓴 것에 유의
        $string =~ /\l$x/;  # 'mr.', 'mrs.', 'ms.'에 매치
}}}

<ix(character class:::\L)> <ix(character class:::\U)> - 뒤에 이어지는 (<ix(character class:::\E)>를 만나거나, 또다른 <code>\U</code>나 <code>\L</code>을 만나거나, 그 외에는 스트링의 끝까지) 전체 문자열을 소문자 또는 대문자로 변환

{{{#!vim perl
        $x = "This word is in lower case:\L SHOUT\E";
        $x =~ /shout/;       # 매치됨
        $x = "I STILL KEYPUNCH CARDS FOR MY 360"
        $x =~ /\Ukeypunch/;  # matches punch card string
}}}
* \L\u$word 또는 \u\L$word - $word에 담긴 스트링의 첫글자만 대문자로, 나머지는 소문자로 변환

<ix(character class:::\c)> - 콘트롤 캐릭터를 이스케이프. (예: Ctrl+Z - <code>\cZ</code>)

<ix(character class:::\Q)>...<ix(character class:::\E)>
* 사이에 있는 거의 대부분의 non-alphabetic 캐릭터들을 이스케이프.
* $와 @는 예외 - 변수는 치환됨.
{{{#!vim perl
        $x = "\QThat !^*&%~& cat!";
        $x =~ /\Q!^*&%~&\E/;  # check for rough language
}}}

"\Q", "\L", "\l", "\U", "\u", "\E"는 사실 큰따옴표 인용 문법의 일부이지, 정규표현식 문법의 일부가 아니다.
이것들이 프로그램에 직접 삽입된 정규식에 나타날 경우는 제대로 동작하겠지만, 스트링 안에 들어 있다가 패턴 내에서 삽입될 경우는 동작하지 않는다.

<blockquote>
(주인장 보충:)

바로 위 문단의 말은, (주인장이 제대로 이해했다면), 다음과 같은 코드로 확인할 수 있다:
{{{#!vim perl
my $str1 = "\uhello";   # $str1 = 'Hello'
my $str2 = '\uhello';   # $str2 = '\uhello'
say "match" if 'Hello' =~ /$str1/;    # 매치됨
say "match" if 'Hello' =~ /$str2/;    # 런타임 에러
}}}
{{{#!vim
match
Unrecognized escape \u passed through in regex; marked by <-- HERE in m/\u <-- HERE hello/ at ...
}}}
$str2 변수 안에 들어있는 "\u"는 정규식에서는 인식하지 못하는 이스케이프 시퀀스로 취급되어 에러가 난다.

perlretut 문서에 위 문단이 추가된 시점은 [http://perl5.git.perl.org/perl.git/commitdiff/7c579eed878fc49f1db8118b45c262d16571a5c1 여기서 처음], [http://perl5.git.perl.org/perl.git/commitdiff/8e71069ff4d55ae1ebf5da957f031d91cb878cb6 여기서 개정]
</blockquote>

Perl <ix(Perl:::5.6.0)>부터는 정규표현식에서 <ix(Unicode)>를 지원
* Perl의 텍스트 스트링은 유니코드 스트링이고, 255보다 큰 값(코드포인트 또는 캐릭터 번호라 부르는)을 가진 캐릭터를 포함할 수 있다.<footnote(5.8 버전에서는 펄이 UTF-8인코딩을 사용한다는 문구가 있었는데, 내부적으로 처리하는 방식이 그렇다는 얘기라서, 사용자가 여기서 알 필요가 없다고 판단했는지 삭제되었음)>

사용자가 알아야 할 것: 1) 정규식에서 유니코드 문자를 표현하는 법 2) 매칭 연산은 검색할 스트링을 바이트가 아니라 캐릭터의 시퀀스로 취급한다는 점

1) 정규식에서 유니코드 문자를 표현하는 법
* chr(127) 이후의 문자는 <ix(Unicode:::\x{hex})>형태로 표시한다. 중괄호 없이 <code>\x hex</code> 형태로 쓰는 것은 255를 넘지 않기 때문이다.
* Perl <index(Perl:::5.14.0)>부터는, 8진수를 선호한다면 <index(Unicode:::\o{oct})>를 사용할 수 있다.
{{{#!vim perl
        /\x{263a}/;  # match a Unicode smiley face :)
}}}
* '''참고''': Perl <index(Perl:::5.6.0)>에서는 유니코드 관련 기능을 사용하기 위해서는 <code>use utf8</code>을 적어줘야 했으나, 현재는 대부분의 유니코드 처리와 관련해서는 명시적인 utf8 프라그마를 써 줄 필요가 없다. (유일하게 문제가 되는 부분은, 사용자의 펄 스크립트가 유니코드로 작성되어 있고 UTF-8 인코딩으로 저장되어 있을 때는 명시적으로 use utf8 을 해주어야 한다는 점이다.)

16진수로 표현된 유니코드 문자를 보면서 이 문자가 뭔지 파악하는 것이 쉽지 않다. 따라서 유니코드 문자를 "named character" <ix(Escape Sequences)> <ix(character class:::\N{name})>를 사용해 표현할 수 있다. <code>name</code>은 표준에 명시된 유니코드 문자의 이름이다.
* 점성술에서 수성을 나타내는 기호(☿)를 표현하는 예:
{{{#!vim perl
   use charnames ":full";   # use named chars with Unicode full names
   $x = "abc\N{MERCURY}def";
   $x =~ /\N{MERCURY}/;     # matches
}}}
* 짧은 이름을 사용하거나 특정 알파벳 자모에 국한된 이름을 쓸 수도 있다:
{{{#!vim perl
        use charnames ':full';
        print "\N{GREEK SMALL LETTER SIGMA} is called sigma.\n";

        use charnames ":short";
        print "\N{greek:Sigma} is an upper-case sigma.\n";

        use charnames qw(greek);
        print "\N{sigma} is Greek sigma\n";
}}}
* 문자 이름들의 전체 목록은 유니코드 표준에 있는 <code>NamesList.txt</code>에 들어 있다.<footnote(5.8버전에서는 Names.txt라고 잘못 기록되어 있는데 수정되었음. [[주인장]]이 쓰는 리눅스 시스템에서는 <code>/usr/lib/perl5/5.8.8/unicore/NamesList.txt</code>에, 스트로베리 펄 5.10.0에서는 <code>C:\strawberry\perl\lib\unicore\NamesList.txt</code>에 있었음)> (http://www.unicode.org/Public/UNIDATA/ 에서 얻을 수 있음)



2) 매칭 연산이 스트링을 캐릭터의 시퀀스로 간주하는 부분에 대하여:
* <ix(Perl:::5.6.0)>과 이후 버전에서는, 정규식은 대부분 유니코드 캐릭터를 사용한다. (하위호환성을 유지하기 위해서, 대부분 그러지만 모든 매칭 시맨틱이 다 유니코드를 가정하는 건 아니다. Perl <index(Perl:::5.14.0)>부터는 완전히 유니코드를 쓰라고 지시할 수 있는데, 명시적으로 <index(modifier::://u)> modifier를 쓰거나, <code>use 5.012</code>(또는 그보다 높은 버전) 또는 <code>use feature 'unicode_strings'</code> <index(pragma)>를 써서, 프라그마를 사용한 스코프 내에서 묵시적으로 //u modifier를 쓰라고 할 수 있다)
* 내부적으로는, 유니코드 스트링은 그 스트링의 생성 내역에 따라 UTF-8 또는 네이티브 8비트 인코딩을 사용하여 바이트 시퀀스로 인코딩되지만, 개념상 이것은 캐릭터의 시퀀스이지, 바이트의 시퀀스가 아니다. 이에 대한 튜터리알은 Perldoc:perlunitut""를 보라<footnote(5.8버전 문서에는 이 단락에 다음과 같은 내용이 있었는데 삭제되었다: ''스트링이 유니코드 문자의 시퀀스로 간주되는 상황에서, 한 바이트의 매치를 해야 되는 경우라면 <code>\C</code>를 사용한다. <code>\C</code>는 <code>.</code>와 유사하나, 0-255 사이의 어떤 바이트에도 매치된다는 게 다르다.'')>.


<index(Unicode)> 문자들처럼 유니코드 <index(character class)>도 이름으로 표현할 수 있다.
* <index(character class:::\p{name})> - 특정 이름에 해당되는 캐릭터 클래스
* <index(character class:::\P{name})> - <code>\p{name}</code>을 제외한 나머지
* 대소문자 검사 예 (아래 코드에서 "Is"는 생략가능):
{{{#!vim perl
        use charnames ":full"; # use named chars with Unicode full names
        $x = "BOB";
        $x =~ /^\p{IsUpper}/;   # matches, uppercase char class
        $x =~ /^\P{IsUpper}/;   # doesn't match, char class sans uppercase
        $x =~ /^\p{IsLower}/;   # doesn't match, lowercase char class
        $x =~ /^\P{IsLower}/;   # matches, char class sans lowercase
}}}

Perl에서 사용하는 클래스 이름들과, 전통적인 유닉스 클래스들과의 관계:
{{{#!vim
           Perl 클래스이름   유니코드 클래스 이름 또는 정규 표현식

           IsAlpha          /^[LM]/
           IsAlnum          /^[LMN]/
           IsASCII          $code <= 127
           IsCntrl          /^C/
           IsBlank          $code =~ /^(0020|0009)$/ || /^Z[^lp]/
           IsDigit          Nd
           IsGraph          /^([LMNPS]|Co)/
           IsLower          Ll
           IsPrint          /^([LMNPS]|Co|Zs)/
           IsPunct          /^P/
           IsSpace          /^Z/ || ($code =~ /^(0009|000A|000B|000C|000D)$/
           IsSpacePerl      /^Z/ || ($code =~ /^(0009|000A|000C|000D|0085|2028|2029)$/
           IsUpper          /^L[ut]/
           IsWord           /^[LMN]/ || $code eq "005F"
           IsXDigit         $code =~ /^00(3[0-9]|[46][1-6])$/
}}}


공식적인 유니코드 클래스 이름을 <index(character class:::\p)>나 <index(character class:::\P)>와 같이 사용할 수도 있다.
* 예:
** <code>\p{L}</code> - 유니코드 'letters'
** <code>\p{Lu}</code> - 대문자
** <code>\P{Nd}</code> - 숫자가 아닌 것들
* 이름이 한 글자인 경우는 중괄호 생략 가능 - <code>\pM</code> 유니코드 'marks'
* 전체 이름 목록은 Perldoc:perlunicode 참조

유니코드는 다양한 문자집합들로 나눌 수 있으며, <code>\p{...}</code>(특정 집합에 포함되는지) 또는 <code>\P{...}</code>(포함되지 않는지)으로 테스트할 수 있다.
* 예: <code>\p{Latin}</code>, <code>\p{Greek}</code>, <code>\p{Katakana}</code>

<code>\p{...}</code>과 같은 단일 형태 외에, <index(character class:::\p{name=value})>또는 <index(character class:::\p{name:value})> 형태의 복합 형태를 사용할 경우도 있다.
* <code>=</code>와 <code>:</code> 둘 다 사용가능
* 단일 형태보다 더 일반적인 형태로써, 단일 형태는 복합 형태 중 보편적으로 쓰이는 것들을 Perl에서 간편하게 쓸 수 있도록 정의해 둔 것이다.
* 위 단락의 예를 복합형태로 쓰면: <code>\p{Script=Latin}</code>, <code>\p{Script:Greek}</code>, <code>\P{script=katakana}</code> 등이 된다 (중괄호 안에서는 대소문자 무관).


<index(character class:::\X)> - 'Unicode extended grapheme cluster'를 포함하는 캐릭터 클래스 시퀀스
* "논리적 캐릭터" - 하나의 캐릭터로 보이지만, 내부적으로는 하나 이상의 문자로 구성. 기본 문자와 그 뒤에 오는 임의 갯수의 결합 문자.
* 예: 액센트 표시, <code>A + COMBINING RING</code> - 덴마크에서 A위에 동그라미가 있는 문자 Å

유니코드에 대한 최신 정보는 유니코드 표준 문서 또는 유니코드 콘소시엄 웹사이트 http://www.unicode.org/ 참조

Perl에서는 <index(character class:::POSIX-style)> 스타일의 캐릭터 클래스도 정의되어 있음
* <index(character class:::[:name:])>의 형태 - <code>name</code>은 POSIX 클래스
* POSIX 클래스:
** <code>alpha</code>, <code>alnum</code>, <code>ascii</code>, <code>cntrl</code>, <code>digit</code>(펄의 <index(character class:::\d)>), <code>graph</code>, <code>lower</code>, <code>print</code>, <code>punct</code>, <code>space</code>(펄의 <index(character class:::\s)>), <code>upper</code>, <code>xdigit</code>
** <code>word</code> - Perl의 <index(character class:::\w)>에 일치하는 확장
** <code>blank</code> - GNU 확장
* <index(modifier::://a)> modifier를 사용하면 이 클래스들이 ASCII 범위에 대해서만 매치가 되도록 제한한다. 그렇지 않으면 이 클래스들은 각각 대응되는 Perl 유니코드 클래스와 동일하게 매치된다.
** 예: <code>[:upper:]</code>는 <code>\p{IsUpper}</code>와 동일
** 일부 예외가 있는데, Perldoc:perlrecharclass""에서 전체 논의 내용을 볼 수 있다.
* POSIX 클래스의 부정형 - 이름 앞에 <code>^</code>.
** 예: <code>[:^digit:]</code> - <index(character class:::\D)> 또는 유니코드에서 <code>\P{IsDigit}</code>
* 유니코드와 POSIX 캐릭터 클래스는 펄의 캐릭터 클래스처럼 사용될 수 있다. 단 예외적으로, POSIX 캐릭터 클래스는 캐릭터 클래스 <code>[...]</code>안에서만 사용 가능하다:
{{{#!vim perl
        /\s+[abc[:digit:]xyz]\s*/;  # match a,b,c,x,y,z, or a digit
        /^=item\s[[:digit:]]/;      # match '=item',
                                    # followed by a space and a digit
        /\s+[abc\p{IsDigit}xyz]\s+/;  # match a,b,c,x,y,z, or a digit
        /^=item\s\p{IsDigit}/;        # match '=item',
                                      # followed by a space and a digit
}}}





==== # 정규표현식 컴파일 및 저장 Compiling and saving regular expressions ====


컴파일된 정규식은 한 번 저장한 후 계속 사용할 수 있는 자료구조이다.

regexp quote <index(qr//)>
* <code>qr/string/</code> - <code>string</code>을 정규표현식으로 간주하여 컴파일한 후 변수에 할당할 수 있는 형태로 변환
{{{#!vim perl
           $reg = qr/foo+bar?/;  # reg는 컴파일된 정규식을 저장
}}}
* $reg 를 정규표현식으로 사용할 수 있다
{{{#!vim perl
           $x = "fooooba";
           $x =~ $reg;     # 매치됨, /foo+bar?/와 같다
           $x =~ /$reg/;   # 형태만 다르지 동일함
}}}
* $reg를 더 큰 정규표현식 안에서 보간할 수 있다
{{{#!vim perl
           $x =~ /(abc)?$reg/;  # 여전히 매치됨
}}}


다양한 구분자 사용가능
* <code>qr!!</code>, <code>qr{}</code>, <code>qr~~</code> 등
* 작은따옴표를 구분자로 쓰는 경우는 <code>qr''</code> 어떠한 치환도 안 됨


매번 컴파일할 필요 없는 동적인 매칭 연산을 생성할 때 유용
* 앞서 나왔던 <code>simple_grep</code>을 확장한 프로그램. 여러 패턴을 순차적으로 검색하며, 한 패턴이 발견되면 다음 패턴으로 넘어간다.
{{{#!vim perl
        #!/usr/bin/perl
        # grep_step - match <number> regexps, one after the other
        # usage: grep_step <number> regexp1 regexp2 ... file1 file2 ...

        $number = shift;
        $regexp[$_] = shift foreach (0..$number-1);
        @compiled = map qr/$_/, @regexp;
        while ($line = <>) {
            if ($line =~ /$compiled[0]/) {
                print $line;
                shift @compiled;
                last unless @compiled;
            }
        }
}}}
{{{#!vim
        % grep_step 3 shift print last grep_step
        $number = shift;
                print $line;
                last unless @compiled;
}}}
* 미리 컴파일된 정규표현식을 <code>@compiled</code> 변수에 저장함으로써 재컴파일할 필요가 없이 루프를 돌며 정규식들을 사용할 수 있다.<footnote(아래에 [[주인장]]이 추가로 작성한 [[#aboutqr|qr// 에 대하여]] 섹션 참조)>



==== # 런타임에 정규표현식 생성하기 Composing regular expressions at runtime ====

여러 개의 정규식이 있고, 그 중 아무 것에나 매치되면 된다면, 이 정규식들을 여러 후보들(alternatives)의 집합으로 합칠 수 있다. 만일 각각의 정규식이 입력 데이타로 들어온다면, join 연산을 사용하면 될 것이다.

<code>simple_grep</code>의 개선판: 여러 패턴을 매칭하는 프로그램
{{{#!vim perl
        #!/usr/bin/perl
        # multi_grep - match any of <number> regexps
        # usage: multi_grep <number> regexp1 regexp2 ... file1 file2 ...

        $number = shift;
        $regexp[$_] = shift foreach (0..$number-1);
        $pattern = join '|', @regexp;

        while ($line = <>) {
            print $line if $line =~ /$pattern/;
        }
}}}
{{{#!vim
        % multi_grep 2 shift for multi_grep
        $number = shift;
        $regexp[$_] = shift foreach (0..$number-1);
}}}

가끔은, 분석할 ''입력''을 패턴으로 구성하고, 허용되는 값들을 매칭 연산의 좌변에 두는 게 더 나을 때가 있다. 이렇게 다소 역설적으로 들리는 상황의 예로, 입력으로 명령어를 받고 이 명령어는 사용 가능한 명령어들 중 하나여야 한다고 하자. 또한 명령어들은 혼동의 여지가 없는 한 축약해서 쓸 수 있다고 하자:
{{{#!vim perl
        #!/usr/bin/perl
        # keymatch
        $kwds = 'copy compare list print';
        while( $command = <> ){
            $command =~ s/^\s+|\s+$//g;  # 앞뒤에 공백을 제거
            if( ( @matches = $kwds =~ /\b$command\w*/g ) == 1 ){
                print "command: '@matches'\n";
            } elsif( @matches == 0 ){
                print "no such command: '$command'\n";
            } else {
                print "not unique: '$command' (could be one of: @matches)\n";
            }
        }
}}}
{{{#!vim
        % keymatch
        li
        command: 'list'
        co
        not unique: 'co' (could be one of: copy compare)
        printer
        no such command: 'printer'
}}}
입력을 각 키워드들에 일일이 매치하지 않고, 키워드들을 합친 집합을 입력에 매치하였다. <code>$kwds =~ /\b($command\w*)/g</code> 연산은 한번에 여러가지 일을 수행한다.
* 입력받은 명령어가 한 키워드와 첫글자부터 일치하도록 하고 (<code>\b</code>)
* 덧붙은 <code>\w*</code>로 인하여 앞부분만 축약해서 입력할 수 있게 하고
* 매칭된 키워드의 갯수를 알려주고 (<code>scalar @matches</code>)
* 실제로 매치된 키워드들이 뭔지도 알려준다.




==== # 정규식 내에 주석과 modifier 삽입 Embedding comments and modifiers in a regular expression ====

Perl의 <index(extended pattern)> : <code>(?char...)</code> 형태

* <index(extended pattern:::embedded comment)> : <ix(extended pattern:::(?#text))> - 패턴 내에 주석을 삽입
** 주석 내에 괄호 사용 불가
** 복잡한 주석은 <ix(modifier::://x)>를 사용할 것
{{{#!vim perl
        /(?# Match an integer:)[+-]?\d+/;
}}}

* <ix(extended pattern:::(?i))> - <ix(modifier::://i)>에 대응
* <ix(extended pattern:::(?m))> - <ix(modifier::://m)>에 대응
* <ix(extended pattern:::(?s))> - <ix(modifier::://s)>에 대응
* <ix(extended pattern:::(?x))> - <ix(modifier::://x)>에 대응
{{{#!vim perl
        /(?i)yes/;  # 대소문자 구분 없이 'yes'에 매치
        /yes/i;     # 위와 동일
        /(?x)(          # 정수를 나타내는 정규식
                 [+-]?  # 선택적으로 올 수 있는 부호에 매치
                 \d+    # 숫자의 시퀀스에 매치
             )
        /x;
}}}
* (위 예문의 마지막 라인에 다시 /x modifier가 있는데, 필요없다. 오류라고 생각됨)


embedded modifier의 장점:

1) 각각의 정규식 패턴마다 고유의 변경자를 둘 수 있고, 변경자를 동적으로 바꿀 수 있다. 이것은 서로 다른 변경자가 적용되어야 하는 정규식들의 배열을 매칭할 때 아주 유용하다.
{{{#!vim perl
        $pattern[0] = '(?i)doctor';
        $pattern[1] = 'Johnson';
        ...
        while (<>) {
            foreach $patt (@pattern) {
                print if /$patt/;
            }
        }
}}}

2) 패턴 내의 특정 그룹에만 변경자의 효과를 지정할 수 있다. (<index(modifier::://p)>는 예외. 이것은 전체 정규식에 적용된다)
{{{#!vim perl
        /Answer: ((?i)yes)/;  # matches 'Answer: yes', 'Answer: YES', etc.
}}}

현재 적용되고 있는 modifier의 효과를 없애기: <code>(?-i)</code> 등

여러 modifier를 동시에 사용하기: <code>(?s-i)</code> 등

삽입된 modifier는 <index(non-capturing)> 그룹이다. 예를 들어 <code>(?i-m:regexp)</code>는 <code>regexp</code>에 대소문자 구분 없고 multi-line 모드를 끈 상태에서 매치되는, 캡처되지 않는 그룹이다.



<blockquote>
주인장 보충 - [http://www.effectiveperlprogramming.com/blog/735 Let perl create your regex stringification | The Effective Perler]의 내용

* <ix(extended pattern:::(?^...:))> - <ix(Perl:::5.14.0)>부터 도입
* 명시된 변경자만 적용되고 나머지는 적용이 안 된 것을 의미

정규표현식을 스트링으로 표현(stringify)할 때, 이전에는 적용 안 된 옵션들을 명시하는 형태였다:
{{{
$ perl5.12.2 -le 'print qr/Buster|Mimi/;'
(?-xism:Buster|Mimi)
}}}
이 경우 문제점은, Perl 버전이 올라가면서 새로운 변경자가 추가되면, 스트링 표현에 그 변경자가 추가되어야 하므로 동일한 정규표현식이 버전에 따라 서로 다르게 표현될 있다는 점이다

5.14.0부터는 적용되는 옵션들만을 표시하기 때문에 항상 동일하게 표현된다.
{{{
$ perl5.13.6 -le 'print qr/Buster|Mimi/i'
(?^i:Buster|Mimi)
}}}
프로그래머 입장에서는, 애초에 스트링 표현을 명시적으로 하지 말고 Perl이 하도록 하면 딱히 신경쓰지 않아도 된다
</blockquote>






==== # 앞뒤 살펴보기 Looking ahead and looking behind ====

Perl 정규표현식에서 대부분의 정규식 요소들은 자기가 매치될 때 매치되는 스트링을 '먹어치운다'. 예를 들어 <code>[abc}]</code>는 매치될 때 스트링의 캐릭터 하나를 먹으며, Perl은 매치 후 스트링의 그 다음 캐릭터 위치로 이동한다. 그러나 매치될 때 캐릭터들을 먹지(즉 캐릭터 포지션을 이동시키지) 않는 요소들이 일부 있다. 위에서 봤던 <index(anchor)>들이 그 예다. 앵커 <index(anchor:::^)>는 라인의 시작 부분에 매치되나, 어떤 캐릭터도 삼키지 않는다. <index(anchor:::\b)>도 유사하게 <code>\w</code>에 매치되는 캐릭터와 매치되지 않는 캐릭터가 접한 위치에 매치되지만, 캐릭터를 삼키진 않는다. 앵커는 <ix(zero-width)> <ix(assertion)>의 예이다
* zero-width: 캐릭터를 먹어치우지 않고
* assertion: 스트링의 어떤 특성을 테스트한다
숲 속을 산책하는 것에 정규식 매칭을 비유하면 대부분의 정규식 요소들은 경로를 따라 이동하는 것과 같고, 앵커는 잠시 멈춰서 주변을 확인하는 것과 같다. 만일 주변 환경이 테스트에 통과하면 계속 진행할 수 있고, 통과하지 못한다면 백트랙해야 한다.

환경을 체크하는 것은 경로의 앞, 뒤, 또는 양쪽을 다 살펴보는 일을 수반한다. <code>^</code>는 뒤쪽을 살펴보고 뒤쪽에 아무 캐릭터도 없는지 확인한다. <code>$</code>는 앞쪽을 살펴보고 앞에 캐릭터가 남아 있지 않는 것을 확인한다. <code>\b</code>는 앞뒤를 다 살펴보고, 앞뒤에 있는 캐릭터들이 word인지 여부가 서로 다른지 확인한다.

lookahead와 lookbehind는 앵커 개념을 일반화한 것이며, zero-width assertion으로써 우리가 테스트하려는 캐릭터가 무엇인지 명시할 수 있다.
* <index(lookahead)> assertion : <ix(lookahead:::(?=regexp))>
** 검사하려는 식 이후에 regexp가 있으면 참
* <ix(lookahead:::lookbehind)> assertion : <ix(lookahead:::(?<=fixed-regexp))>
** 검사하려는 식 이전에 regexp가 있으면 참
** lookbehind의 경우는 고정길이만 된다. (?<=(ab|bc))는 가능. (?<=(ab)*)는 불가능
* 이 둘은 <ix(non-capturing)>이다. 즉 <ix(matching variable:::$1)> 같은 매칭 변수에 할당되지 않는다.
{{{#!vim perl
        $x = "I catch the housecat 'Tom-cat' with catnip";
        $x =~ /cat(?=\s)/;   # matches 'cat' in 'housecat'
        @catwords = ($x =~ /(?<=\s)cat\w+/g);  # matches,
                                               # $catwords[0] = 'catch'
                                               # $catwords[1] = 'catnip'
        $x =~ /\bcat\b/;  # matches 'cat' in 'Tom-cat'
        $x =~ /(?<=\s)cat(?=\s)/; # doesn't match; no isolated 'cat' in
                                  # middle of $x
}}}
* <ix(lookahead:::(?!regexp))>
* <ix(lookahead:::(?<!fixed-regexp))>
** 이 둘은 regexp와 일치하지 않을 때 참
{{{#!vim perl
           $x = "foobar";
           $x =~ /foo(?!bar)/;  # doesn't match, 'bar' follows 'foo'
           $x =~ /foo(?!baz)/;  # matches, 'baz' doesn't follow 'foo'
           $x =~ /(?<!\s)foo/;  # matches, there is no \s before 'foo'
}}}
* "<ix(character class:::\C)>" 는 lookbehind에는 지원되지 않는다. "\C"의 정의가 그렇잖아도 위험한 여지가 있는데 스트링의 이전 방향으로 되돌아가며 검사하는 것은 더더욱 위험하기 때문이다.<footnote(5.8버전의 문서에서는 <code>\C</code>에 대한 언급이 유니코드 얘기할 때 나온다. <code>\C</code>는 유니코드 스트링을 대상으로 매칭할 때 한 "바이트"에 매치되는 캐릭터 클래스이다. 5.14버전에서는 그 언급이 사라졌는데 여기에는 삭제되지 않았다)>

다음 예에서는 한 스트링에 빈칸으로 구분된 단어들, 숫자들, 그리고 한칸짜리 대시들이 포함되어 있고, 이것을 각 성분을 쪼개려 한다. 대시와 대시 사이, 또 대시와 단어 사이에는 공백이 없기 때문에 <code>/\s+/</code>만 사용하는 걸로는 제대로 분리되지 않는다. 분리할 위치를 lookahead와 lookbehind를 사용하여 지정해 주고 있다:
{{{#!vim perl
        $str = "one two - --6-8";
        @toks = split / \s+              # 연속된 공백
                      | (?<=\S) (?=-)    # 공백이 아닌 문자와 '-'사이
                      | (?<=-)  (?=\S)   # '-'와 공백이 아닌 문자 사이
                      /x, $str;          # @toks = qw(one two - - - 6 - 8)
}}}



==== # 백트래킹을 금지하는 독립적인 부분표현식 Using independent subexpressions to prevent backtracking ====

<index(independent subexpression:::(?>regexp))>
* 전체 정규표현식의 일부이면서, 전체 정규식이 매치될 수 있을지 없을지를 고려하지 않고, 자신이 매치될 수 있는 최대한 또는 최소한의 스트링을 소비해버리는 정규표현식

일반적인 정규표현식과 비교
* 일반적인 정규표현식:
{{{#!vim perl
           $x = "ab";
           $x =~ /a*ab/;  # 매치됨
}}}
* <code>a*</code>는 일단 스트링의 <code>a</code>를 가로채어 간다. 그러나 이렇게 하면 전체 정규표현식이 매치가 되지 않으므로 앞으로 되돌아간 후 <code>a</code>를 내어놓고 자신은 빈 스트링에 매치된다. 즉 <code>a*</code>가 매치되는 부분은 정규식의 나머지 부분이 매치되는 부분에 의존적이다.
* independent subexpression의 경우:
{{{#!vim perl
           $x =~ /(?>a*)ab/;  # 매치되지 않음!
}}}
* <code>(?>a*)</code>는 정규식의 나머지 부분을 고려하지 않고 자신이 매치될 수 있는 최대한의 스트링을 가로채어 간다. 따라서 정규식의 나머지 부분 <code>ab</code>는 매치가 되지 않는다. <code>(?>a*)</code>는 독립적이므로, 백트래킹이 생기지 않고 이 부분표현식은 자신이 매치된 <code>a</code>를 내어놓지 않는다.
* 서로 독립적인 정규표현식들을 사용할 때도 이런 상황이 나올 수 있다:
{{{#!vim perl
           $x = "ab";
           $x =~ /a*/g;   # 매치됨, 'a'를 먹어버림
           $x =~ /\Gab/g; # 매치되지 않음, 매치할 'a'가 남아있지 않다
}}}
** <index(modifier::://g)>와 <index(anchor:::\G)>가 결합되어 스트링을 한쪽 정규표현식에서 다른 정규식으로 넘겨준다.

독립적 부분표현식이 백트래킹을 방지하는 특성은, 검색 소요 시간을 줄이는 데 유용하다
* 최대 두 단계 깊이까지 중첩된 괄호 안의 스트링을 매치하는 예:
{{{#!vim perl
           $x = "abc(de(fg)h";  # 쌍이 맞지 않는 괄호들
           $x =~ /\( ( [^()]+ | \([^()]*\) )+ \)/x;
}}}
* 위 정규식은 여는 괄호, alternation의 한번 이상의 반복, 닫는 괄호 순으로 매치된다. alternation은 두가지이며, 첫번째 <code>[^()]+</code>는 괄호가 없는 서브스트링에, 두번째 <code>\([^()]*\)</code>는 괄호로 둘러싸인 서브스트링에 매치된다. 
* 위 정규표현식에는 숫자가 지정되지 않은 <index(quantifier)>가 <code>(a+|b)+</code> 형태로 중첩되어 있고, 파트1에서 얘기했듯이 이것은 전체 스트링에서 매치되는 부분이 없을 경우 검색시간이 지수적으로 증가함
* 불필요한 백트래킹을 못하게 함으로써 검색 소요 시간을 줄일 수 있다, 여기서는 안쪽의 수량자를 독립적인 부분표현식으로 만든다:
{{{#!vim perl
           $x =~ /\( ( (?>[^()]+) | \([^()]*\) )+ \)/x;
}}}
* <code>(?>[^()]+)</code> 부분은 가능한 많은 양의 스트링을 삼켜버리고 내어놓지 않으므로, 매치 실패 결과가 더 빨리 난다.







==== # [#conditional]조건부 정규표현식 Conditional expressions ====


<index(conditional expression)>
* 조건에 따라 어느 패턴을 사용할지 결정하게 되는 표현식
* <index(conditional expression:::(?(condition)yes-regexp))>
** 조건이 참이면 <code>yes-regexp</code>를 매치함
** 조건이 거짓이면 이 식을 무시하고 다음 정규식으로 진행
* <index(conditional expression:::(?(condition)yes-regexp|no-regexp))>
** 조건이 참이면 <code>yes-regexp</code>를 매치함
** 조건이 거짓이면 <code>no-regexp</code>를 매치함

<code>condition</code>을 나타내는 여러 가지 형태:
* <code>(정수)</code>
** <code>\정수</code>에 해당하는 <index(backreference)>가 정규식 앞부분에서 매치되었다면 참
** 캡처 그룹에 이름을 붙인 <index(backreference:::named backreference)>의 경우에도 마찬가지로 <code>(<name>)</code> 또는 <code>('name')</code>으로 사용 가능
** 앞서 매치되었던 내용에 따라 다음 매치할 것을 결정하는 게 가능
** <code>$x$x</code> 또는 <code>$x$y$y$x</code> 형태의 단어를 찾는 예:

* <code>(?...)</code> - <index(zero-width)> <ix(assertion)>
** <index(lookahead)>, <index(lookahead:::lookbehind)> 조건에 맞으면 참
** <index(code evaluation)>(다음 절에서 설명)

* <code>(R)</code>, <code>(R1)</code>,<code>(R2)</code>..., <code>(R&name)</code>
** <index(recursive pattern)>과 관련됨. 아래 [[#recursive|"재귀적 패턴" 절]] 참조
** 조건이 재귀적으로 호출된 상태에서 실행되었는지 (<code>(R)</code>), 재귀적으로 호출될 때 특정 번호로 참조되는 그룹으로부터 실행되었는지 (<code>(R1)</code>,<code>(R2)</code>...), 특정 이름으로 참조되는 그룹으로부터 실행되었는지 <code>(R&name)</code>에 대해 체크

정수 또는 이름으로 된 형태의 조건은, 앞에서 무엇이 매치되었냐에 따라 뒤에서 무엇을 매치할 것인가를 보다 유연하게 선택할 수 있게 한다. 아래의 예는, <code>"$x$x"</code> 또는 <code>"$x$y$y$x"</code> 형태의 단어들을 검색한다:
{{{#!vim
        % simple_grep '^(\w+)(\w+)?(?(2)\g2\g1|\g1)$' /usr/dict/words
        beriberi
        coco
        couscous
        deed
        ...
        toot
        toto
        tutu
}}}

lookbehind 조건은, 백레퍼런스와 같이 사용되어, 앞에서 매치된 내용이 뒤의 매치에 영향을 주게 한다:
{{{#!vim perl
        /[ATGC]+(?(?<=AA)G|C)$/;
}}}
* DNA 시퀀스 중 <code>AAG</code>로 끝나거나, 그 외의 베이스 쌍 조합과 <code>C</code>로 끝나는 것을 찾는 예:
* 조건부 정규식 부분이 <code>(?((?<=AA))G|C)</code>가 아님에 유의. lookbehind, lookahead, code assertion 의 경우는 조건 바깥쪽에 다시 괄호를 써줄 필요는 없다.





===== # 조건부 표현식 내용 보충 =====

주인장 보충:

[http://www.regular-expressions.info/conditional.html Regex Tutorial - If-Then-Else Conditionals]의 두번째 절에 흥미로운 예제가 있다.

패턴 <code>(a)?b(?(1)c|d)</code>은, 첫번째 그룹 <code>(a)</code>가 매치되면 <code>b</code> 뒤에 <code>c</code>가, 그렇지 않으면 <code>d</code>가 매치된다. 이 때 눈여겨 볼 점은
* <code>(a)?</code>는 스트링의 "a"에 매치되지 않을 경우는 아예 정규식에 관여되지 않고, <code>\1</code>과 같은 참조는 실패하게 된다. 그런데 만일 이 부분을 <code>(a?)</code>라고 쓴다면, 이 그룹은 항상 "a" 또는 ""에 매치되며, 항상 정규식에 유효하게 참여한다. 따라서 <code>?(1)</code>은 항상 참이 되어 버릴 것이다.
* 이 패턴은 "bd"또는 "abc"에는 매치된다. "bc"에는 매치되지 않는다. 그런데, "abd"에는 '''매치된다'''. 처음에 "a"부터 시작해서 매치를 할 때에는 패턴의 <code>c</code>가 매치되지 않으므로 실패하지만, 정규식 엔진은 다시 전체 스트링의 그 다음 위치에서부터 매칭을 시도하고, 결과적으로 "a'''bd'''"의 "bd"부분이 패턴에 매치하게 된다. 이걸 원하지 않는다면 패턴에 앵커를 두어 <code>^(a)?b(?(1)c|d)$</code>와 같이 했야 한다.



==== # 패턴 정의하고 이름붙이기 Defining named patterns ====

어떤 정규표현식은 같은 서브패턴이 여러번 사용된다. Perl <index(Perl:::5.10.0)>부터는 서브패턴을 정의하고 이름을 붙인 후 패턴 내 어느 곳에서든 이름을 사용하여 불러올 수 있게 지원한다.

* <index(definition group:::(?(DEFINE)(?<name>pattern)...))> 형태로 정의
* <index(definition group:::(?&name))> 형태로 사용

아래 예는 앞에서 봤던 부동소수를 나타내는 패턴을 이 기능을 사용하여 표현한 것이다. 두 번 이상 사용되는 세 가지 서브 패턴이 있는데 부호, 정수에 사용되는 숫자열, 소수부이다. 패턴 아래쪽의 DEFINE 그룹에서 그 세가지 서브패턴을 정의한다. 소수부 패턴에서는 정수 패턴을 재사용하는 것을 눈여겨보라.

{{{#!vim perl
       /^ (?&osg)\ * ( (?&int)(?&dec)? | (?&dec) )
          (?: [eE](?&osg)(?&int) )?
        $
        (?(DEFINE)
          (?<osg>[-+]?)         # 생략 가능한 부호
          (?<int>\d++)          # 정수
          (?<dec>\.(?&int))     # 소수부
        )/x
}}}



==== # [#recursive]재귀적 패턴 Recursive patterns  ====

<index(Perl:::5.10.0)>부터 <index(recursive pattern)> 지원.

<index(recursive pattern:::(?group-ref))>을 사용하여 패턴 내의 다른 캡처 그룹을 참조하면, 참조된 그룹 내의 ''패턴''이 참조하는 자리에서 독립적 서브패턴으로 사용된다. 그룹 레퍼런스는 자기가 참조하는 그 그룹 내에 존재할도 수 있기 때문에, 지금까지 재귀적 해석기(parser)가 필요했던 작업을 패턴 매칭을 적용하여 할 수 있게 되었다.

회문(palindrome)을 포함한 스트링에 매치되는 패턴을 예로 들자. (회문은 공백이나 문장 부호를 무시하였을 때, 앞에서 읽으나 뒤에서 읽으나 똑같은 단어나 문장이다) 먼저 빈 스트링이나, 한 글자짜리 스트링은 회문이다. 그 외의 경우는 가운데 어떤 회문이 있고, 그 회문의 앞과 뒤에 같은 글자가 있어야 한다.

{{{#!vim perl
        /(?: (\w) (?...Here be a palindrome...) \g{-1} | \w? )/x
}}}

무시해야 될 것들을 제거하기 위해 앞뒤에 <code>\W*</code>만 붙여주면, 전체 패턴이 완성된다:
{{{#!vim perl
        my $pp = qr/^(\W* (?: (\w) (?1) \g{-1} | \w? ) \W*)$/ix;
        for $s ( "saippuakauppias", "A man, a plan, a canal: Panama!" ){
            print "'$s' is a palindrome\n" if $s =~ /$pp/;
        }
}}}
<code>(?...)</code> 안에는 백레퍼런스의 절대 번호나 상대 번호 둘 다 쓸 수 있다. 전체 패턴은 <index(recursive pattern:::(?R))> 또는 <index(recursive pattern:::(?0))> 으로 표시할 수 있다. 그룹에 이름을 붙였을 경우 <index(recursive pattern:::(?&name))>으로 그 그룹을 재귀호출할 수 있다.



===== # 재귀적 패턴 보충 =====

<blockquote>
주인장 보충:

재귀적 정규표현식을 사용하는 예를 찾기가 힘든데, 주로 balanced text, 즉 좌우에 대칭되는 표식에 의해 둘러싸여 있으면서, 또다른 balanced text가 중첩될 수 있는 상황을 풀 수 있는 식을 볼 수 있었다.
* 이 튜토리알에 언급된 회문 예제도 결국 같은 형태
* <code>( 3 + ( 2 * 6 ) )</code> 같이 괄호로 둘러싸인 수식
* <code><tag1>...<tag2>..</tag2>...</tag1></code> 처럼 태그로 둘러싸인 텍스트

* [http://learn.perl.org/faq/perlfaq6.html#Can-I-use-Perl-regular-expressions-to-match-balanced-text- Perl faq6. Can I use Perl regular expressions to match balanced text?]
* [http://coding.smashingmagazine.com/2009/05/06/introduction-to-advanced-regular-expressions/ Crucial Concepts Behind Advanced Regular Expressions]

그러나 일반적으로, 심지어 perlfaq 글에서마저, 애초에 이런 형태의 텍스트, 특히 html,xml 등 태그가 포함된 텍스트를 다루는 것은 정규식이 아니라 그 용도로 나온 모듈을 사용하는 게 훨씬 낫다고 하고 있다.

어쨌거나 perlfaq에 있는 예제를 보면, 부등호로 둘러쌓인 <code><텍스트></code> 부분을 추출한다. 이 때도 역시 중첩되어 있을 수 있다.
{{{#!vim perl
my $string =<<"HERE";
I have some <brackets in <nested brackets> > and
<another group <nested once <nested twice> > >
and that's it.
HERE

my @groups = $string =~ m/
        (                   # 캡처 버퍼 1의 시작
        <                   # 여는 부등호에 매치
            (?:
                [^<>]++     # 부등호를 제외한 문자들이 반복, 백트래킹하지 않음
                  |
                (?1)        # < 또는 > 발견, 캡처 버퍼 1을 재귀적으로 부름
            )*
        >                   # 닫는 부등호에 매치
        )                   # 캡처 버퍼 1의 끝
        /xg;

$" = "\n\t";
print "Found:\n\t@groups\n";
}}}
실행결과:
{{{#!vim
Found:
        <brackets in <nested brackets> >
        <another group <nested once <nested twice> > >
}}}
* 위의 회문 매칭과 결국 개념은 똑같다.
* 중첩되지 않은 패턴은, <code><</code>로 시작하고, <code><</code>나 <code>></code>가 아닌 글자가 반복되다가, <code>></code>로 끝난다. 패턴으로 나타내면 <code><[^<>]++></code>
* 중첩된 패턴의 경우는, <code><</code>로 시작하고, 부등호가 아닌 글자 또는 '''중첩된 패턴(즉 자기 자신과 같은 패턴)'''이 반복되다가, <code>></code>로 끝난다. 따라서 정규식 내부가 <code>(?: [^<>]++ | (?1) )*</code>이 된다.

이제, 위의 [[#conditional|"조건부 정규표현식" 절]]에서 언급된, "조건"을 묘사하는 세번째 패턴을 테스트해보자. (이건 주인장이 만들어본 예제라서, 정확하지 않을 수 있음)
* 부등호로 둘러싸인 텍스트가 중첩되었을 경우, 가장 바깥쪽 단계의 텍스트를 제외하고, 내부에 중첩된 텍스트는 소문자가 들어가면 안 된다는 조건을 추가
* 아까는 <code>[^<>]++</code>로 나타냈던 부분을, 조건을 추가해서 <code>(?(R) [^a-z<>]++ | [^<>]++ )</code>로 바꾼다.
* 테스트를 위해 <code>$string</code>값에서 두번째 줄 "nested twice"를 "NESTED TWICE"로 고친다.
실행 결과:
{{{#!vim perl
Found:
        <nested brackets>
        <nested once <NESTED TWICE> >
}}}

<code>R1</code>이나 <code>R&name</code> 형태는, 재귀적으로 호출할 때 <code>(?번호)</code>또는 <code>(?&이름)</code>으로 호출했다면 그 번호 또는 이름이, <code>R</code> 뒤에 있는 번호 또는 이름과 일치할 때 참이 된다. 예를 들어 <code>((패턴))</code> 이 형태는 바깥쪽 괄호나 안쪽 괄호 어느 쪽을 재귀호출해도 결국 똑같이 매칭이 되긴 하지만, 호출을 <code>(?2)</code>로 했는데 조건검사를 <code>(?(R1)..)</code>으로 하면 이건 거짓으로 판정된다. 또한, 이름으로 호출하고 번호로 검사하거나 그 반대로 하는 것은 허용되는 걸로 보인다.
</blockquote>



==== # 정규표현식 안에서 Perl 코드 실행하기 A bit of magic: executing Perl code in a regular expression ====



<index(code evaluation:::(?{code}))> - <index(code evaluation)> expression. Perl 구문으로 구성된 <code>code</code>를 정규표현식의 일부로 사용
* 아직 실험적인 상태라 차후에 공지 없이 변경될 수 있음
* <index(zero-width)> assertion
* <index(conditional expression)>의 조건으로 사용되는 경우
** 코드가 실행되고 마지막 구문의 결과를 가지고 참/거짓 결정
* 그 외의 경우
** assertion은 항상 참이 되고, 실행 결과는 특수변수 <code>$^R</code>에 저장됨. 이 변수를 이후에 정규표현식 안에서 사용 가능

예:
{{{#!vim perl
        $x = "abcdef";
        $x =~ /abc(?{print "Hi Mom!";})def/; # 매치됨,
                                             # 'Hi Mom!'출력
        $x =~ /aaa(?{print "Hi Mom!";})def/; # 매치되지 않음,
                                             # 'Hi Mom!' 출력않음
}}}

다음 두 예는 주의:
{{{#!vim perl
        $x =~ /abc(?{print "Hi Mom!";})ddd/; # doesn't match,
                                             # no 'Hi Mom!'
                                             # but why not?
        $x =~ /abc(?{print "Hi Mom!";})[dD]dd/; # doesn't match,
                                                # but _does_ print
}}}
* 두 정규식이 결과적으로 거의 동일한 패턴이고 같은 스트링에 매치되지만 전자는 코드가 실행되지 않고 후자는 된다.
* Perl 정규표현식 엔진의 최적화에 따른 차이
** 전자는 코드 부분을 제외하면 평범한 문자열만 있고, 정규식 엔진은 실제로 패턴 검색을 하기 이전에 패턴이 타겟 스트링에 존재하지 않는 것을 파악한다.
** 후자의 경우는 캐릭터 클래스를 사용한 것을 보고 엔진은 패턴이 매치되는지 안 되는지를 파악하기 위해서 실제 검색을 수행하게 된다. 매치가 안 되는 것을 알기 전에 코드가 수행되게 된다.
* 정규식 엔진이 어떻게 최적화를 하는지에 대해 더 자세한 내용은 아래 "프라그마와 디버깅" 절을 보라.

다른 예:
{{{#!vim perl
        $x =~ /(?{print "Hi Mom!";})/;       # matches,
                                             # prints 'Hi Mom!'
        $x =~ /(?{$c = 1;})(?{print "$c";})/;  # matches,
                                               # prints '1'
        $x =~ /(?{$c = 1;})(?{print "$^R";})/; # matches,
                                               # prints '1'
}}}

정규표현식이 코드 표현식이 있는 부분을 백트래킹하게 되고, 그 코드 표현식 안에 사용된 변수가 <code>local</code> 키워드를 사용하여 지역화되어 있다면, 코드 표현식에 의하여 변수값이 바뀌었던 것도 취소된다.
* 한 문자가 그룹 안에서 몇 번이나 매치되는지 확인하는 예:
{{{#!vim perl
        $x = "aaaa";
        $count = 0;  # initialize 'a' count
        $c = "bob";  # test if $c gets clobbered
        $x =~ /(?{local $c = 0;})         # initialize count
               ( a                        # match 'a'
                 (?{local $c = $c + 1;})  # increment count
               )*                         # do this any number of times,
               aa                         # but match 'aa' at the end
               (?{$count = $c;})          # copy local $c var into $count
              /x;
        print "'a' count is $count, \$c variable is '$c'\n";
}}}
* 출력:
{{{#!vim
        'a' count is 2, $c variable is 'bob'
}}}
* <code>(?{local $c = $c + 1;})</code> 대신 <code>(?{$c = $c + 1;})</code>라고 쓸 경우는 백트래킹할 때 변경이 취소되지 않는다:
{{{#!vim
        'a' count is 4, $c variable is 'bob'
}}}

취소될 수 있는 건 지역화된 변수의 값 변화 뿐이며, 코드 표현식에 의한 다른 부효과는 영구히 남게 된다:
{{{#!vim perl
           $x = "aaaa";
           $x =~ /(a(?{print "Yow\n";}))*aa/;
}}}
* 출력:
{{{#!vim
          Yow
          Yow
          Yow
          Yow
}}}

<code>$^R</code>은 자동으로 지역화되며, 백트래킹이 이뤄질 때도 올바르게 동작한다.

코드 표현식을 조건으로 사용하여 영어와 독어의 정관사를 매치하는 예:
{{{#!vim perl
        $lang = 'DE';  # use German
        ...
        $text = "das";
        print "matched\n"
            if $text =~ /(?(?{
                              $lang eq 'EN'; # is the language English?
                             })
                           the |             # if so, then match 'the'
                           (der|die|das)     # else, match 'der|die|das'
                         )
                        /xi;
}}}
* 코드 표현식 바깥쪽에 다시 조건을 나타내는 괄호를 써서 <code>(?((?{...}))yes-regexp|no-regexp)</code>로 표기할 필요는 없다.

코드 표현식과 변수 치환을 동시에 사용할 경우 문제가 있다:
{{{#!vim perl
           $bar = 5;
           $pat = '(?{ 1 })';
           /foo(?{ $bar })bar/; # compiles ok, $bar not interpolated
           /foo(?{ 1 })$bar/;   # compile error!
           /foo${pat}bar/;      # compile error!

           $pat = qr/(?{ $foo = 1 })/;  # precompile code regexp
           /foo${pat}bar/;      # compiles ok
}}}
* 정규표현식에 (1) 코드 표현식과 치환되어야 할 변수가 같이 있거나 (2) 코드 표현식으로 치환되는 변수가 있는 경우 컴파일 에러가 난다.
* 코드 표현식이 미리 컴파일되어 변수에 저장될 경우는 정규식 내에서 치환되는 데 문제가 없다

이런 제한의 이유는, 변수 치환과 코드 표현식을 동시에 사용하는 것이 보안 문제를 야기할 수 있기 때문이다.
* 검색 엔진을 개발할 때 많은 경우 사용자 입력을 받아서 그 입력을 정규표현식에 바로 집어넣는다:
{{{#!vim perl
           $regexp = <>;       # read user-supplied regexp
           $chomp $regexp;     # get rid of possible newline
           $text =~ /$regexp/; # search $text for the $regexp
}}}
* <code>$regexp</code>에 코드 표현식이 들어갈 경우 사용자는 임의의 Perl 코드를 실행 가능하다. (<code>system('rm -rf *')</code>와 같은)
* 따라서 하나의 정규표현식 안에 변수 치환과 코드 표현식을 동시에 사용하는 것은 허용되지 않으며, 이 제한을 없애려면 <code>use re 'eval'</code>을 실행하여야 한다:
{{{#!vim perl
           use re 'eval';       # throw caution out the door
           $bar = 5;
           $pat = '(?{ 1 })';
           /foo(?{ 1 })$bar/;   # compiles ok
           /foo${pat}bar/;      # compiles ok
}}}




<index(code evaluation:::pattern code expression)> <index(code evaluation:::(??{code}))>
* 코드를 실행한 결과를 다시 정규표현식으로 취급하여 매칭 연산에 사용한다
{{{#!vim perl
           $length = 5;
           $char = 'a';
           $x = 'aaaaabb';
           $x =~ /(??{$char x $length})/x; # matches, there are 5 of 'a'
}}}

마지막 예문:
* 보통의 코드 표현식과 패턴 코드 표현식을 동시에 사용
* 이진 스트링 <code>1101010010001...</code>에서 <code>1</code>의 간격이 피보나치 수열 0,1,1,2,3,5...의 형태로 되어 있는지를 검사하는 코드:
{{{#!vim perl
        $x = "1101010010001000001";
        $z0 = ''; $z1 = '0';   # initial conditions
        print "It is a Fibonacci sequence\n"
            if $x =~ /^1         # match an initial '1'
                        (?:
                           ((??{ $z0 })) # match some '0'
                           1             # and then a '1'
                           (?{ $z0 = $z1; $z1 .= $^N; })
                        )+   # repeat as needed
                      $      # that is all there is
                     /x;
        printf "Largest sequence matched was %d\n", length($z1)-length($z0);
}}}
* <code>$^N</code>은 마지막 캡처 그룹에 일치된 내용으로 설정된다는 걸 기억하라.
* 출력:
{{{#!vim
           It is a Fibonacci sequence
           Largest sequence matched was 5
}}}

변수 <code>$z0</code>과 <code>$z1</code>은 코드 표현식 바깥쪽에 있는 보통의 변수들과 달리, 정규식이 컴파일될 때 치환되지 않는다. 대신 Perl 이 매치되는 것을 찾아 검색하는 동안 코드 표현식을 만나게 되면 그 때 평가된다.

<index(modifier::://x)>를 쓰지 않고 위 정규식을 쓰면 다음과 같다.
{{{#!vim perl
        /^1(?:((??{ $z0 }))1(?{ $z0 = $z1; $z1 .= $^N; }))+$/
}}}
* 즉 코드 부분에는 스페이스를 넣는 게 여전히 가능하다.
* 그렇지만 코드 표현식 또는 조건부 정규표현식을 사용할 때는 <code>//x</code>를 써서 확장 표현식을 사용해야 표현식을 작성하고 디버깅하는데 용이하다.




==== # 백트래킹 제어 명령어 Backtracking control verbs ====


Perl <index(Perl:::5.10.0)>에서는 백트래킹 과정을 세부적으로 제어할 수 있는
여러 제어 명령어가 추가되었다. 이 기능들은 전부 실험적인 기능이고 향후에
변경되거나 없어질 수 있다. 자세한 설명은
[http://perldoc.perl.org/perlre.html#Special-Backtracking-Control-Verbs
 perlre문서의 Special Backtracking Control Verbs]를 읽어보라.

여기서는 <index(backtracking control:::(*FAIL))> 명령어를 사용한 예를 보인다.
* <code>(*F)</code>로 줄여 쓸 수 있음
* 정규식이 패턴과 스트링 사이에 일치가 되지 않는 지점에서 실패하듯이, 정규식을 실패하게 한다.
* 평범한 상황에서 실패했을 때와 마찬가지로, 정규식 엔진은 스트링의 다음 포지션으로 이동하거나 다른 alternative를 시도하는 등 계속 진행한다. 매치에 실패했을 때는 캡처 그룹을 보존하거나 어떤 결과값을 생성하지 않으므로, 이걸 쓸 때 코드 표현식을 같이 써야 할 수도 있다.

{{{#!vim perl
       %count = ();
       "supercalifragilisticexpialidoceous" =~
           /([aeiou])(?{ $count{$1}++; })(*FAIL)/i;
       printf "%3d '%s'\n", $count{$_}, $_ for (sort keys %count);
}}}

저 패턴은 일부 문자들에 매치되는 클래스로 시작된다. 여기에 매치되면, <code>$count{'a'}++</code>와 같은 구문이 실행되어 매치된 글자의 카운터를 증가시킨다. 그 다음 <code>(*FAIL)</code>이 말 그대로 매칭을 실패하게 만들고, 정규식 엔진은 지금껏 배운 대로 스트링이 끝나기 전까지 계속 포지션을 이동시키며 다음 모음으로 이동한다. 따라서, 매치되든 되지 않든 상관없이 정규식 엔진은 전체 스트링을 다 검사할 때까지 계속 진행한다.

위 방법이 다음과 같은 다른 해결책에 비해 눈에 띄게 빠르다는 것은 주목할 만 하다<footnote(주인장 컴퓨터에서 Strawberry Perl 5.12에서 Cpan:Benchmark 모듈로 테스트해보면, print 구문을 제외했을 때 속도 차이가 두 배가 넘었다)>:
{{{#!vim perl
       $count{lc($_)}++ for split('', "supercalifragilisticexpialidoceous");
       printf "%3d '%s'\n", $count2{$_}, $_ for ( qw{ a e i o u } );
}}}



==== # 프라그마와 디버깅 Pragmas and debugging ====


정규표현식을 제어하고 디버그하는 데 사용되는 <index(pragma)>들.

<code>use re 'eval'</code>
* 한 정규식 내에 변수 치환과 코드 표현식을 동시에 사용가능

<code>use re 'taint'</code>
{{{#!vim perl
        use re 'taint';
        $tainted = <>;
        @parts = ($tainted =~ /(\w+)\s+(\w+)/; # 이제 @parts도 오염되었음
}}}
* 오염된(tainted) 변수에 매칭 연산을 통해 얻어낸 스트링들도 오염된 것으로 간주하게 함
* 오염된 변수에서 안전한 비트들을 추출하기 위해 정규식을 사용하곤 하기 때문에<footnote([[Perl/디버깅]] 참조)>, 기본적으로는 매칭 연산을 통해 얻어낸 값은 오염된 것으로 간주하지 않음
* 안전한 부분을 추출하는 게 아니라 다른 처리를 하는 거라면 <code>taint</code>를 사용하라.

* <code>taint</code>와 <code>eval</code> 프라그마는 렉시컬 스코프를 따른다. 즉 프라그마를 둘러싼 블록 안에서만 효과가 있다.

<code>re '/flags'</code>
{{{#!vim perl
        use re '/m';   # 또는 다른 어떤 플래그라도
        $multiline_string =~ /^foo/; # /m 이 묵시적으로 적용된다
}}}
* Perl <index(Perl:::5.14.0)>에 도입
* 정규 표현식 플래그를 렉시컬 스코프 내에 항상 적용되게 한다.
* 더 자세한 것은 Perldoc:re""의 <code>'flags' mode</code> 절 참고


<code>re 'debug'</code>
* 정규표현식 컴파일 및 실행과 관련된 자세한 정보를 출력
* <code>re 'debugcolor'</code> - termcap 컬러를 출력할 수 있는 터미널에서는 컬러로 출력함

debug 예:
* <code>% perl -e 'use re "debug"; "abc" =~ /a*b+c/;'</code>

컴파일 단계:
{{{#!vim number
           Compiling REx 'a*b+c'
           size 9 first at 1
              1: STAR(4)
              2:   EXACT <a>(0)
              4: PLUS(7)
              5:   EXACT <b>(0)
              7: EXACT <c>(9)
              9: END(0)
}}}
* <code>STAR(4)</code> - 오브젝트(여기서는 'a')에 별표가 붙은 형태이며, 매치할 경우 4번 라인의 <code>PLUS(7)</code>로 가라는 의미

매칭 연산 전에 수행하는 휴리스틱, 최적화:
{{{#!vim number
           floating 'bc' at 0..2147483647 (checking floating) minlen 2
           Guessing start of match, REx 'a*b+c' against 'abc'...
           Found floating substr 'bc' at offset 1...
           Guessed: match at offset 0
}}}

실제 매칭 연산이 이뤄지는 과정:
{{{#!vim number
           Matching REx 'a*b+c' against 'abc'
             Setting an EVAL scope, savestack=3
              0 <> <abc>             |  1:  STAR
                                      EXACT <a> can match 1 times out of 32767...
             Setting an EVAL scope, savestack=3
              1 <a> <bc>             |  4:    PLUS
                                      EXACT <b> can match 1 times out of 32767...
             Setting an EVAL scope, savestack=3
              2 <ab> <c>             |  7:      EXACT <c>
              3 <abc> <>             |  9:      END
           Match successful!
           Freeing REx: 'a*b+c'
}}}
* 각 단계는 <code>n <x> <y></code> 형태
** <code><x></code> - 일치한 스트링
** <code><y></code> - 아직 매치 검사가 수행되지 않은 부분
* <code>| 1: STAR</code> - 현재 컴파일 리스트(위에서 본)의 1번 라인에 있음
* 자세한 내용은 [http://perldoc.perl.org/perldebguts.html#Debugging-regular-expressions perldebguts 문서의 "Debugging regular expressions"] 참조

정규표현식을 디버그하는 다른 방법: <code>print</code> 구문을 삽입:
* alternation이 있는 곳에서 백트래킹하는 과정을 상세하게 볼 수 있음
{{{#!vim perl
           "that this" =~ m@(?{print "Start at position ", pos, "\n";})
                            t(?{print "t1\n";})
                            h(?{print "h1\n";})
                            i(?{print "i1\n";})
                            s(?{print "s1\n";})
                                |
                            t(?{print "t2\n";})
                            h(?{print "h2\n";})
                            a(?{print "a2\n";})
                            t(?{print "t2\n";})
                            (?{print "Done at position ", pos, "\n";})
                           @x;
}}}
* 출력
{{{
           Start at position 0
           t1
           h1
           t2
           h2
           a2
           t2
           Done at position 4
}}}



=== # 버그들 BUGS ===


<index(code evaluation)>, <index(conditional expression)>, <index(independent subexpression)> 은 '''실험적'''인 상태이다. 상용 코드에 사용하지 말라.



=== # 참고 SEE ALSO ===


* Perldoc:perlre - regular expressions reference 
* <code>m//</code>과 <code>s///</code> 연산자에 관해서 - Perldoc:perlop 의 "Regexp Quote-Like Operators" 섹션[http://perldoc.perl.org/perlop.html#Regexp-Quote-Like-Operators]
* split 연산자에 관해서 - Perldoc:split
* Jeffrey Friedl, ''Mastering Regular Expressions'', O'Reilly, ISBN:1556592-257-3




== # Mastering Perl ==

[http://www252.pair.com/comdog/mastering_perl/Chapters/02.advanced_regular_expressions.html Mastering Perl: Advanced Regular Expressions]에서 몇 가지.

=== # /g , /c modifier 예 - 간단한 파서 ===

<index(modifier::://g)>, <ix(modifier::://c)>, <ix(anchor:::\G)> 를 사용한 예

{{{#!vim perl
# 간단한 파서
my $line = "Just another regex hacker, Perl hacker, and that's it!\n";

while( 1 )
    {
    my( $found, $type )= do {
        if( $line =~ /\G([a-z]+(?:'[ts])?)/igc )
            { ( $1, "a word"           ) }
        elsif( $line =~ /\G (\n) /xgc             )
            { ( $1, "newline char"     ) }
        elsif( $line =~ /\G (\s+) /xgc            )
            { ( $1, "whitespace"       ) }
        elsif( $line =~ /\G ( [[:punct:]] ) /xgc  )
            { ( $1, "punctuation char" ) }
        else
            { last; ()                   }
        };

    print "Found a $type [$found]\n";
    }
}}}
* 만약에 word를 검사하는 곳에서 /c가 없으면, 처음 "Just"를 매칭하여 출력하고, 다음 공백을 만났을 때 첫 if에서 매치가 안 되므로 pos값을 리셋해버린다. 그 다음 elsif 문들은 전부 매치에 실패한다 (\G 앵커가 스트링의 첫 부분을 가리키므로 "\G(\s+)"가 매치되지 않음). 따라서 바로 종료.
* word를 검사하는 곳에서 /g가 없으면, 매치가 되어도 포지션이 이동하지 않으므로, 무한 루프를 돌면서 계속 "Just"를 매치하여 출력하게 된다.



=== # lookaround ===
"Wilma"와 "Fred"라는 문자열이 순서에 관계없이 둘 다 포함되어 있는 스트링을 찾는 경우:
{{{#!vim perl
$_ = "Here come Wilma and Fred!";
print "Matches" if /Fred.*Wilma|Wilma.*Fred/;   # alternation을 사용한 하나의 정규표현식
print "Matches" if /Fred/ && /Wilma/;           # 두개의 정규표현식을 사용한 것이 위의 표현보다 더 간단하다.

print "Matches" if /(?=.*Wilma).*Fred/;         # positive lookahead assertion 을 사용한 하나의 정규표현식
}}}
* <index(lookahead)> (?=.*Wilma)는 ".*Wilma" 패턴이 매치하는 곳, 즉 스트링의 처음에 앵커를 세팅한다. 이 앵커에서부터 다시 ".*Fred"를 찾아나가게 된다. Wilma와 Fred의 순서에 관계없이 매치되게 된다.
{{{#!vim perl
# 잘못된 경우
print "Matches" if /(?Wilma).*Fred/;            # 이것은 Wilma가 Fred보다 앞에 있는 경우에만 매치된다.
}}}


<ix(zero-width)>특성을 이용하여 Perldoc:split 함수에서 사용하는 예:
{{{#!vim perl
my @words = split /(?=[A-Z])/, 'CamelCaseString';       # "C", "C", "S"가 없어지지 않는다.
print join '_', map { lc } @words; # camel_case_string
}}}
* "(?=[A-Z])" 대신에
** ([A-Z])를 사용하면 ("", "C", "amel", "C", "ase", "S", 'tring")
** [A-Z]를 사용하면 ("", "amel", "ase", "tring")





== # 그 외 이런저런 주제들 ==

=== # [#aboutqr]qr// 에 대하여 ===



위의 perldoc 문서에서는 <index(qr//)>에 대해서, 스트링을 정규표현식으로 해석하여 저장한다고 막연하게 나와 있는데, 그냥 정규표현식이 담겨 있는 스칼라 변수를 사용할 때와 어떤 차이가 있는지 알기 쉽진 않다.
{{{#!vim perl
my $pattern = "foo";
my $qr      = qr/foo/;

# 아래 네 가지는 항상 같은 결과
$str =~ /$pattern/;  # 흔히 보는 예
$str =~ $pattern;    # 희한하게 생겼지만 이것도 잘 동작한다

$str =~ $qr;
$str =~ /$qr/;       # 이 둘도 동치
}}}

단순 문자열 패턴 뿐 아니라 캐릭터 클래스나 괄호나 기타 등등도 그대로 동일하게 적용된다.
{{{#!vim perl
my $str = "my name is hong";

my $pattern = 'name is (\w+)$';
my $qr      = qr/name is (\w+)$/;

if ( $str =~ $pattern ) { print "[$1]\n"; }   # hong
if ( $str =~ $qr      ) { print "[$1]\n"; }   # 이것도 hong
}}}
 
<index(modifier)> 사용도 마찬가지. 표현만 달라지지 똑같은 효과를 낼 수 있다:
{{{#!vim perl
my $str = "my NAME is hong";             # NAME 이 대문자가 되었음

my $pattern = '(?i)name is (\w+)$';      # 확장 패턴 사용
my $qr      = qr/name is (\w+)$/i;       # modifier 사용

if ( $str =~ $pattern ) { print "[$1]\n"; }
if ( $str =~ $qr      ) { print "[$1]\n"; }   # 둘 다 hong 검출
}}}


요컨데 딱히 qr//을 써야만 매칭을 할 수 있고 스트링 스칼라로는 할 수 없는 경우가 따로 있는 것 같지는 않다. ([[주인장]]의 추정일 뿐이긴 하지만)

qr//의 장점은 perldoc 에서 언급했듯이 "미리 컴파일하여 저장"하고 "사용할 때는 컴파일하지 않는다"라는 점이다. 이것이 어떤 의미인지는 직접 코드를 확인해보자:
{{{#!vim perl
#!/usr/bin/perl
use re 'debug';        # Perl 내부에서 정규표현식을 처리하는 과정을 STDERR로 출력함
local $| =1;    

my $str = "iname";

#################
# qr//을 사용하는 예
#################
my @reg_qr = ( qr/a/, qr/b/, qr/c/ );             # 이 시점에서 세 개의 정규표현식이 컴파일된다.

# 이하의 내용에서 print 문은 단지 각 구문의 실행을 추적하기 위해 넣었음
for my $c ( 10 .. 11 ) {
    print "\n\n-- $c --------------------\n\n";
    for ( 0 .. 2 ) {
        print "------------------------------\n";
        my $reg = $reg_qr[$_];
        if ( $str =~ $reg ) {                      # 여기서는 컴파일하지 않고 바로 사용한다
            print "MATCH!!!!!!!!!!\n";
        }
        else {
            print "NOT MATCH~~~~~~\n";
        }
    }
}

print "\n\n\n", "="x30, "\n\n\n";

#################
# 스트링 스칼라 변수를 사용하는 예
#################
my @reg_str = ( "a", "b", "c" );

for my $c ( 10 .. 11 ) {
    print "\n\n-- $c --------------------\n\n";
    for ( 0 .. 2 ) {
        print "------------------------------\n";
        my $reg = $reg_str[$_];
        if ( $str =~ $reg ) {                # =~ 연산을 할 때마다 컴파일한다
            print "MATCH!!!!!!!!!!\n";
        }
        else {
            print "NOT MATCH~~~~~~\n";
        }
    }
}
}}}
보다시피, 두 번의 for 루프는 각각 패턴 "a", "b", "c" 를 각각 비교하는 과정을 다시 두 번 반복한다.

실행결과는 다음과 같다:

<memo(길어서 접음. 클릭)>
{{{
<---- 처음에는 qr//을 사용하여 테스트
Compiling REx `a'                              <--- qr/a/ 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <a>(3)
   3: END(0)
anchored "a" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Compiling REx `b'                              <--- qr/b/ 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <b>(3)
   3: END(0)
anchored "b" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Compiling REx `c'                              <--- qr/c/ 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <c>(3)
   3: END(0)
anchored "c" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]


-- 10 --------------------

------------------------------
Guessing start of match, REx "a" against "iname"...    <---- "a" 매칭
Found anchored substr "a" at offset 2...
Starting position does not contradict /^/m...
Guessed: match at offset 2
MATCH!!!!!!!!!!
------------------------------
Guessing start of match, REx "b" against "iname"...    <---- "b" 매칭
Did not find anchored substr "b"...
Match rejected by optimizer
NOT MATCH~~~~~~
------------------------------
Guessing start of match, REx "c" against "iname"...    <---- "c" 매칭
Did not find anchored substr "c"...
Match rejected by optimizer
NOT MATCH~~~~~~


-- 11 --------------------

------------------------------
Guessing start of match, REx "a" against "iname"...    <---- "a" 매칭
Found anchored substr "a" at offset 2...
Starting position does not contradict /^/m...
Guessed: match at offset 2
MATCH!!!!!!!!!!
------------------------------
Guessing start of match, REx "b" against "iname"...    <---- "b" 매칭
Did not find anchored substr "b"...
Match rejected by optimizer
NOT MATCH~~~~~~
------------------------------
Guessing start of match, REx "c" against "iname"...    <---- "c" 매칭
Did not find anchored substr "c"...
Match rejected by optimizer
NOT MATCH~~~~~~



==============================
<---- 여기서부터는 스트링을 사용하여 테스트



-- 10 --------------------

------------------------------                     <---- for 루프 안에 들어온 후에야
Compiling REx `a'                                  <---- "a" 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <a>(3)
   3: END(0)
anchored "a" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Guessing start of match, REx "a" against "iname"...
Found anchored substr "a" at offset 2...
Starting position does not contradict /^/m...
Guessed: match at offset 2
MATCH!!!!!!!!!!
------------------------------
Freeing REx: `"a"'
Compiling REx `b'                                  <---- "b" 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <b>(3)
   3: END(0)
anchored "b" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Guessing start of match, REx "b" against "iname"...
Did not find anchored substr "b"...
Match rejected by optimizer
NOT MATCH~~~~~~
------------------------------
Freeing REx: `"b"'
Compiling REx `c'                                  <---- "c" 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <c>(3)
   3: END(0)
anchored "c" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Guessing start of match, REx "c" against "iname"...
Did not find anchored substr "c"...
Match rejected by optimizer
NOT MATCH~~~~~~


-- 11 --------------------

------------------------------
Freeing REx: `"c"'
Compiling REx `a'                                  <---- 다시(!) "a" 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <a>(3)
   3: END(0)
anchored "a" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Guessing start of match, REx "a" against "iname"...
Found anchored substr "a" at offset 2...
Starting position does not contradict /^/m...
Guessed: match at offset 2
MATCH!!!!!!!!!!
------------------------------
Freeing REx: `"a"'
Compiling REx `b'                                  <---- "b" 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <b>(3)
   3: END(0)
anchored "b" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Guessing start of match, REx "b" against "iname"...
Did not find anchored substr "b"...
Match rejected by optimizer
NOT MATCH~~~~~~
------------------------------
Freeing REx: `"b"'
Compiling REx `c'                                  <---- "c" 컴파일
size 3 Got 28 bytes for offset annotations.
first at 1
   1: EXACT <c>(3)
   3: END(0)
anchored "c" at 0 (checking anchored isall) minlen 1
Offsets: [3]
    1[1] 0[0] 2[0]
Guessing start of match, REx "c" against "iname"...
Did not find anchored substr "c"...
Match rejected by optimizer
NOT MATCH~~~~~~
Freeing REx: `"a"'
Freeing REx: `"b"'
Freeing REx: `"c"'
Freeing REx: `"c"'
}}}
</memo>

결과에서 보면 qr을 사용한 테스트에서는 세 개의 패턴을 한번씩만 컴파일한 후에, 두번째 루프를 돌 때는 컴파일 없이 바로 사용하고 있다. 그러나 스칼라 변수를 사용한 테스트에서는 변수의 값이 매번 바뀔 때마다 다시 컴파일을 하기 때문에 총 여섯 번 컴파일한다.

Perldoc:Benchmark 를 사용하여 성능을 비교해보면 (위 코드에서 print 문을 전부 제거한 후 비교하였음) 속도가 두 배 이상 차이난다.
{{{
          Rate scalar     qr
scalar 42309/s     --   -57%
qr     97303/s   130%     --
}}}

추가로, 만일 스칼라 변수를 사용한 곳에서 <index(modifier::://o)> modifier를 사용하여 강제로 재컴파일을 금지시키면 어떻게 될까?
{{{#!vim perl
        my $reg = $reg_str[$_];
        if ( $str =~ /$reg/o ) {             # /o 사용
        }
}}}
이 경우는 디버그 메시지를 가지고 확인해보면, 여섯 번의 비교 중에 제일 첫번째 비교를 할 때 컴파일을 한 후 나머지 다섯번의 비교에서는 컴파일을 하지 않는 것을 볼 수 있다. 속도도 따라서 qr 보다 1.5배 정도 빠르게 나온다. '''그러나 여섯번 모두 "a" 패턴을 가지고 비교를 하므로, 잘못된 실행 결과가 나온다 (여섯번 모두 매치하는 걸로 판정됨)'''


==== # aero 님의 코멘트 ====

''(Perl 고수 [http://aero.sarang.net/ aero님]의 코멘트. 감사합니다!)''

다음이 실마리가 될듯합니다.

'''일반스트링과 컴파일된 정규식의 비교'''

{{{
aero@doc:~$ perl -MDevel::Peek -e '$s="foo";Dump($s)'
SV = PV(0x8cd9700) at 0x8cf9e38
  REFCNT = 1
  FLAGS = (POK,pPOK)
  PV = 0x8cf5f28 "foo"\0
  CUR = 3
  LEN = 4
}}}

{{{
aero@doc:~$ perl -MDevel::Peek -e '$s=qr/foo/;Dump($s)'
SV = IV(0x8776e3c) at 0x8776e40
  REFCNT = 1
  FLAGS = (ROK)
  RV = 0x8759520
  SV = REGEXP(0x87844a0) at 0x8759520
    REFCNT = 1
    FLAGS = (OBJECT,POK,FAKE,pPOK)
    IV = 0
    PV = 0x877a548 "(?-xism:foo)"
    CUR = 12
    LEN = 0
    STASH = 0x8758fe0   "Regexp"
}}}

qr은 컴파일된 정규식 Regexp객체임을 알 수 있다.


'''정규식 매칭의 표현의 코드 해석'''

{{{
aero@doc:~$ perl -MO=Deparse -e '$p="foo bar";$s="foo";$p=~$s'
$p = 'foo bar';
$s = 'foo';
$p =~ /$s/;
-e syntax OK
}}}

{{{
aero@doc:~$ perl -MO=Deparse -e '$p="foo bar";$s=qr/foo/;$p=~$s'
$p = 'foo bar';
$s = qr/foo/;
$p =~ /$s/;
-e syntax OK
}}}

정규식 매칭 표현구문에서 구분자가 생략되어도 Perl은 알아서 넣어서 해석한다.

마지막 예제는 컴파일된 정규식 같은경우는 $reg에 넣으면 그 자체가 컴파일된 정규식 객체를 가르키게되어서 그대로 사용가능하지만 그냥 스칼라 스트링을 $reg에 넣으면 설령 그것이 정규표현식 구문에서 컴파일 되었다고 해도 $reg는 어떤 객체를 가르키고 있는 레퍼런스가 아니라 복사된 스칼라값일 뿐이므로 컴파일된 정규식이 원래값이 있는 곳을 찾아 컴파일된 정규식으로 교체할 수 없기 때문에 결과는 당연해 보입니다. o modifier는 이제 deprecated된 feature로 쓰지 않아도 Perl이 필요하다면 자동적으로 최적화 시키고, 어떤 변화된 값이 오는 곳에 o modifier를 쓰는 건 예상치 못한 side effect를 가져온다고 이미 조심을 해야된다고 알려진터라 실제에는 그렇게 사용할 일도 없을 것 같고요. 

qr의 유용한 점은 마지막 예에서 처럼 여러 set들의 정규식이 반복적으로 사용되어져야 할때( 예: http://www.effectiveperlprogramming.com/blog/183 )유용하겠죠 :)
<mysign(aero,2010-4-22 10:39 pm)>




=== # [#matchvariable] 매치 변수와 성능 문제 ===

이 섹션의 출처:
* Effective Perl Programming, Item 33. Watch out for the match variables.
* [http://www.effectiveperlprogramming.com/blog/140 Detect regular expression match variables in your code « The Effective Perler]
* http://perldoc.perl.org/perlre.html#Capture-buffers 아래쪽 "WARNING:" 부분


매치 변수 <index(matching variable:::$`)>, <index(matching variable:::$&)>, <index(matching variable:::$')> 세 가지는 프로그램에 심각한 <index(matching variable:::성능 문제)>를 가져온다:
* 위 세 변수 중 하나라도 프로그램에 한 번이라도 사용되면, 모든 패턴 매치에 대하여 이 변수들에 해당하는 값을 준비해두기 위해서 별도의 작업을 하게 된다.
* 이것은 <index(matching variable:::$1)> 등의 변수에도 마찬가지로 적용되며, 따라서 단순히 <index(metacharacter:::grouping)> 기능만 필요한 경우는 <index(non-capturing:::(?:regexp))>를 사용하는 것이 좋다.
** 그렇지만 위의 세 가지 변수가 한번도 쓰이지 않았을 경우에는, 괄호를 사용하지 않은 패턴에 대해서는 추가 비용이 발생하지 않는다.

{{{#!vim perl
'My cat is Buster Bean' =~ m/Buster/;
print "I matched $&\n";   # 여기서 매치 변수를 사용해버렸기 때문에

while (<>) {
   next unless /Bean/;    # 매치할 때마다 매번 오버헤드가 발생
}
}}}

따라서:
* 위 세 가지 매치 변수는 최대한 사용하지 않도록 한다.
* 만일 단 한 번이라도 사용했다면, 어차피 비용이 이미 발생했으므로, 이후에는 맘대로 사용해도 상관없다.
* <index(Perl:::5.5.0)> 이후부터는 $&는 다른 두 변수보다는 비용이 작다.

Perldoc:English 모듈을 사용할 경우 주의:
* <code>use English;</code> 로 모듈을 로드하는 순간 세 가지 매치 변수에 해당하는 영문 이름 변수가 로드가 되며, 따라서 매치 변수를 이후 사용하지 않아도 이미 성능 하락이 발생한다.
* <code>use English qw(-no_match_vars)</code> 를 하여 매치 변수를 쓰지 않을 것을 명시하라

<index(Perl:::5.10.0)>에서는:
* <index(matching variable:::${^PREMATCH})>, <index(matching variable:::${^MATCH})>, <index(matching variable:::${^POSTMATCH})> 변수를 사용할 수 있다:
* 이 세 가지 변수는 위의 세 가지 매치 변수와 동일한 역할을 한다.
* 다만, 매치 연산을 할 때 <index(modifier::://p)> modifier를 명시하고, 성공적으로 매치가 이뤄졌을 때만, 이 변수들의 값이 정의된다고 보장할 수 있다.
* 즉, 전체적인 성능 하락을 가져오지 않지만, 그 댓가로 사용자가 명시적으로 perl에게 사용하겠다고 알려줘야 하는 것이다.

{{{#!vim perl
use 5.010;

'My cat is Buster Bean' =~ m/\s\w+\sBean/p;   # /p 옵션 사용
say "I matched ${^MATCH}";

while (<>) {
   next unless /Bean/;     # 오버헤드 없음
}
}}}

<index(Perl:::5.10.0)> 이전 버전에서는, 정규식 자체를 수정하여 명시적으로 <index(metacharacter:::( ))>를 사용하여 캡처링하라:
|| _____사용하지 말 것_____ || _____5.10 이전 버전에서는_____ || _____5.10 이하 버전에서는_____ ||
|< /pattern/ 이후 $` |< /(.*?)pattern/ 이후 $1 |< /pattern/p 이후 ${^PREMATCH} ||
|< /pattern/ 이후 $& |< /(pattern)/ 이후 $1 |< /pattern/p 이후 ${^MATCH} ||
|< /pattern/ 이후 $' |< /pattern(.*)/ 이후 $+ |< /pattern/p 이후 ${^POSTMATCH} ||

기존에 사용 중이던 프로그램에 매치 변수가 쓰였는지를 확인하고 싶다면 다음 모듈들을 살펴보라
* Cpan:Devel::SawAmpersand
* Cpan:Devel::FindAmpersand
** thread를 지원하도록 컴파일된 perl 바이너리는 지원을 못 한다고 나온다... ;ㅅ;
* 자신이 작성한 코드 뿐 아니라 로드해서 사용하는 모듈 중에 매치 변수가 있다면 역시 전체적으로 오버헤드가 생긴다. 로드한 모듈까지 검사하는 부분은 출처에 있는 [http://www.effectiveperlprogramming.com/blog/140 Detect...] 글을 참고.



=== # non-greedy quantifier를 쓸 때 주의 ===

{{{#!vim perl
my $str = qq|aaa "bbb" ccc "ddd" eee|;

# greedy 수량자 /+/
if ( $str =~ /"(.+)"/ ) {
    print "[$1]\n";
}
# 출력은 당연히 [bbb" ccc "ddd]

# non-greedy 수량자 /+?/
if ( $str =~ /"(.+?)"/ ) {
    print "[$1]\n";
}
# 출력은 [bbb]


# greedy 수량자 /+/
if ( $str =~ /"(.+)" eee/ ) {
    print "[$1]\n";
}
# 역시 당연히 [bbb" ccc "ddd]

# non-greedy 수량자 /+?/
if ( $str =~ /"(.+?)" eee/ ) {
    print "[$1]\n";
}
# [ddd]가 아니라, [bbb" ccc "ddd]이다


# 이 경우는 . 대신 [^"]를 써야 한다.
# greedy 수량자 /+/
if ( $str =~ /"([^"]+)" eee/ ) {
    print "[$1]\n";
}
# non-greedy 수량자 /+?/
if ( $str =~ /"([^"]+?)" eee/ ) {
    print "[$1]\n";
}
# 위 둘 다 결과는 [ddd]
}}}

non-greedy 수량자를 쓰는 경우라도, 일단 첫번째 원칙은 스트링의 '''가장 왼쪽에서부터''' 매치를 하는 것이므로, <code>"bbb" c</code>가 <code>/"(.+?)" eee/</code>와 매치되지 않는 게 확인된 시점에서, 그 다음은 <code>.+?</code>의 범위를 늘려나가며 재시도를 하게 된다.



=== # /g, /c, \G, 포지션 리셋에 관한 보충 ===

포지션이 리셋된다거나, <ix(modifier::://c)> modifier를 써서 리셋되지 않게 한다는 것이 무슨 의미이고 어떤 때 사용할 수 있는지 쉽게 와닿지 않았다가, 최근에 이 부분을 실제 코드에서 경험하게 되어서, 여기에 간단한 예를 만들어 적어 둔다.

샘플 코드 전체는 [https://github.com/gypark/perl-regex-position-example GitHub]에서 받을 수 있음

'''코드1:'''

{{{#!vim perl
my $str = "a1a2a3a4a5";
# a<숫자> 형태의 문자열을 전부 찾아내어 어떤 처리를 하고 싶다
while ( $str =~ /(a\d)/ ) {
    print "[$1]\n";    # 어떤 처리 : 출력
}
}}}

{{{#!vim
[a1]
[a1]
... 무한 루프
}}}

위 코드는 매번 $str의 시작 부분부터 검사를 하기 때문에 "a1"만 찾으며 무한 루프를 돈다.

'''코드2:'''

{{{#!vim perl
my $str = "a1a2a3a4a5";
while ( $str =~ /(a\d)/g ) {
    # /g modifier
    print "[$1] at position ", pos($str), "\n";
}
}}}

{{{#!vim
[a1] at position 2
[a2] at position 4
[a3] at position 6
[a4] at position 8
[a5] at position 10
}}}

이런 경우에 가장 흔하게 사용하는 패턴이다.

'''코드3:'''

{{{#!vim perl
my $str = "a1a2a3a4a5";
while ( $str =~ /(a\d)/gc ) {
    print "[$1] at position ", pos($str), "\n";
}

# /c 때문에 $str의 포지션은 여전히 10이고, 따라서 아래 루프의 매치는 실패
while ( $str =~ /(a\d)/g ) {
    print "Again, [$1] at position ", pos($str), "\n";
}
}}}

/c 변경자가 없었다면 두번째 루프에서 다시 "a1"부터 출력되었을 것이다. 그러나 /c 변경자를 첫번째 루프에서 사용했기 때문에, "a5"를 찾은 후 그 다음 매치가 실패했을 때 $str의 포지션 정보가 리셋되지 않은 채로 남아 있고, 두번째 루프에서 그 지점(오프셋 10)에서 매치를 시작하기 때문에 곧바로 실패하여 루프를 빠져나온다.

{{{#!vim
[a1] at position 2
[a2] at position 4
[a3] at position 6
[a4] at position 8
[a5] at position 10
}}}

'''코드4:'''

발견한 문자열이 "a2"인 경우에 한해서, 그 바로 뒤에 "a3"이 따라붙으면 이 "a3"은 다음 번 검사에서 매치시키지 않고 스킵하고 싶다고 하자.

언제나 "a3"은 처리하지 않겠다면 애초에 정규식을 <code>a[012456789]</code>로 만들거나, 루프 안에서 if로 <code>$1 eq 'a3'</code>인 경우를 따로 처리할 수 있지만, 지금과 같이 <바로 앞에 "a2"가 있었던 경우에만>라는 조건이 붙으면 복잡해진다. 직전에 발견되었던 게 "a2"인지 여부를 저장하는 변수를 추가로 써야 하거나...

이런 경우 /g 변경자를 써서 포지션을 넘겨 버릴 수 있다.

{{{#!vim perl
# 이 코드는 불완전
my $str = "a1a2a3a4a5";
while ( $str =~ /(a\d)/g ) {
    print "[$1] at position ", pos($str), "\n";
    if ( $1 eq "a2" ) {
        # a3 을 매치시켜서 포지션 이동
        $str =~ /a3/g;
    }
}
}}}

{{{#!vim
[a1] at position 2
[a2] at position 4
[a4] at position 8
[a5] at position 10
}}}

언뜻 보면 성공한 것 같지만, 이 코드는 문제가 있다.

먼저, 만일 "a2" 뒤에 "a3"이 없다면? if 블록 안의 정규식 검사가 매치에 실패하기 때문에 포지션이 리셋되고, 다음 검사는 다시 문자열의 처음부터 검사하게 된다.

{{{#!vim perl
my $str = "a1a2a!!a4a5";   # a2 뒤에 a3이 없다
}}}

{{{#!vim
[a1] at position 2
[a2] at position 4
[a1] at position 2
[a2] at position 4
... 무한 루프
}}}

따라서, "a3"을 찾는 검사에서 실패하더라도 포지션을 리셋하지 않도록 해야 한다.

{{{#!vim perl
    if ( $1 eq "a2" ) {
        # /c - a3 매치에 실패하더라도 포지션을 리셋하지 않음
        $str =~ /a3/gc;
    }
}}}

이제 무한 루프는 해결했지만, 여전히 문제가 남아 있다. 이 코드는 "a2"를 발견한 시점에서 그 다음 나타나는 첫번째 "a3"까지 검사를 진행하기 때문에, "a2"와 "a3" 사이에 다른 패턴이 들어가 있으면 그걸 전부 건너뛰어 버릴 것이다.

{{{#!vim perl
my $str = "a1a2a9a3a4a5";   # a2와 a3 사이에 a9가 끼어 있다.
}}}

{{{#!vim perl
[a1] at position 2
[a2] at position 4
[a4] at position 10  <-- a9 까지 스킵해버린다.
[a5] at position 12
}}}

따라서 현재 포지션 바로 직후에 있는 "a3"만 찾기 위해 앵커가 필요하고, <code>^</code>는 답이 아니다. 이럴 때 <ix(anchor:::\G)>를 사용할 수 있다.

'''코드5:'''

{{{#!vim perl
my $str = "a1a2a9a3a4a5";
while ( $str =~ /(a\d)/g ) {
    print "[$1] at position ", pos($str), "\n";
    if ( $1 eq "a2" ) {
        # a3 을 매치시켜서 포지션 이동
        # /c - a3 매치에 실패하더라도 포지션을 리셋하지 않음
        # \G - a2 매치에 성공한 그 지점을 나타내는 앵커
        $str =~ /\Ga3/gc;
    }
}
}}}

{{{#!vim
[a1] at position 2
[a2] at position 4
[a9] at position 6
[a3] at position 8
[a4] at position 10
[a5] at position 12
}}}

어떻게든 정규식 패턴만으로 동일한 동작을 하게 하려면... 아래에 있는 코드는 주인장이 떠올린 몇 가지 패턴들이고, 테스트 케이스에 대해서는 다 잘 동작하지만... 어떤 버그가 숨겨져 있을지도.

'''코드9:'''

{{{#!vim perl
foreach my $str (
    "a1a2a3a4a5",
    "a1a2!!a4a5",       # a2 뒤에 a3이 없는 경우
    "a1a2a9a3a4a5",     # a2 와 a3 사이에 다른 매치가 있는 경우
    "a1a3a4a5",         # a2가 없는 경우
) {
    print "---------- $str ----------\n";
    # code_05 에서 사용한 /c, \G
    print " 1. using /c, \\G\n";
    while ( $str =~ /(a\d)/g ) {
        print "[$1] at position ", pos($str), "\n";
        if ( $1 eq "a2" ) {
            $str =~ /\Ga3/gc;
        }
    }

    # 백레퍼런스에 이름을 붙여 사용
    # a2a3 이 매치되면 그 중 a2에,
    # 그 외의 경우는 a<숫자>에 PAT 백레퍼런스가 생긴다
    print " 2. named backreference\n";
    while ( $str =~ /(?<PAT>a2)a3|(?<PAT>a\d)/g ) {
        print "[$+{PAT}] at position ", pos($str), "\n";
    }

    # 또는
    # 캡처그룹 번호 리셋 (?| ... )
    print " 3. alternative capture group numbering\n";
    # 그룹번호:         $1     $1
    while ( $str =~ /(?|(a2)a3|(a\d))/g ) {
        print "[$1] at position ", pos($str), "\n";
    }

    # 또는
    # 바로 앞에 a2가 있지 않은(부정적 룩비하인드) a3, 또는 a<3이 아닌 숫자>
    print " 3. lookbehind\n";
    while ( $str =~ /((?<!a2)a3|(?:a[012456789]))/g ) {
        print "[$1] at position ", pos($str), "\n";
    }
}
}}}







== # 기타 ==

* [http://www.regular-expressions.info/tutorial.html Regular Expression Tutorial - Learn How to Use Regular Expressions] - 정규표현식 튜토리알인데, 몇 장만 살펴봤는데 진짜 잘 되어 있네요. 특히나 정규식 패턴과 매치 대상인 스트링을 서로 다른 색상으로 표시해놓고, 매칭 도중에 어느 패턴이 스트링 어느 부분에 매치되고 있는지를 보여주며 설명하는 게 아주 훌륭함.
* [http://www.kpug.net/zboard/view.php?id=almighty&no=110827 정규식에서 마지막 확장자를 제외하고 모든 . 를 공백으로 바꾸기 -- 한국 팜 사용자 모임 - KPUG]
** 스트링에 포함된 마침표들을 공백으로 바꾸되, 가장 마지막 마침표는 바꾸지 말아야 한다
** 이 경우에도 <index(lookahead)>를 사용
** <code> s/\.(?=.*\.)/ /g </code> - 마침표를 "\."로 표기했기 때문에 좀 복잡해보이지만, <code>s/A(?=.*A)/ /g</code> 형태로 보면, "A가 있고, 그 뒤를 이어서 임의의 문자가 있고 그 이후에 A가 있는 경우"가 매치되는 것이므로, 결과적으로 "마지막 A가 아닌 나머지 A"들이 줄줄이 매치되면서 치환된다.
* [http://www.effectiveperlprogramming.com/blog/174 Know the difference between regex and match operator flags « The Effective Perler] - regex에 적용되는 플래그와 연산자에 적용되는 플래그
* [http://www.effectiveperlprogramming.com/blog/659 Use the /r substitution flag to work on a copy | The Effective Perler]
** <index(Perl:::5.14.0)>에서 도입되는 <index(modifier:::s///r)> 플래그.
** 원본 스트링을 건드리지 않고 사본을 만들어 치환하며, 이 때 <code>=~</code>는 치환 횟수가 아니라 치환된 결과를 리턴한다.
* [http://www.effectiveperlprogramming.com/blog/791 Perl 5.14 introduces non-destructive transliteration | The Effective Perler] - 5.14에서는 tr 연산자에도 /r 적용
* [http://www.effectiveperlprogramming.com/blog/1479 Define grammars in regular expressions | The Effective Perler]

* 5.8버전과 5.14버전 사이의 문서 변경 내역을 보기 위해서는, 각 버전의 Perl 배포본 또는 tar.gz 파일에서 <code>perlretut_5_*_*.pod</code> 파일을 찾은 후, text 형태로 출력한 후 diff 를 보거나 vim 등에서 두 파일을 diff 모드로 띄워두는 게 무난한 듯
** 예: <code>perldoc -otext perlretut_5_8_8.pod</code>

* [http://ostermiller.org/findcomment.html Finding Comments in Source Code Using Regular Expressions]
** 은근히 까다로운, '소스코드의 주석문 매칭'

정규표현식을 테스트할 수 있는 도구
* http://www.weitz.de/regex-coach/ via [http://swbae.egloos.com/1780067 헐랭이와 IT보안 : RegEx Coach - 정규표현식 도우미 툴] - 정규표현식 도우미 :-)
* http://clien.career.co.kr/cs2/bbs/board.php?bo_table=useful&wr_id=227301 - 여러 온라인 툴 링크들이 있음

* [http://advent.perl.kr/2013/2013-12-11.html 열한번째 날: 유니코드를 활용한 정규 표현식 | R.I.P. @am0c - Seoul.pm 펄 크리스마스 달력 #2013]




== # comments ==

<div class="comments">

얼마전 SET Escape '\' 이란걸 배워서 스크립트에 적용했는데요 \\
테이블앞에 붙은 버전을 변수로 받기위해 &1\_JIBUN_CODE 이런식으로 변수뒤에 백슬래쉬가 붙었는데 \\
스크립트 중간중간에 정규식쓰면서 백슬래쉬를 여기저기에 사용한게 많더라고요.. \\
그래서 정규식에 쓰인 것까지 Escape 해버려서 결과값이 다르게 나오는것 같아요 \\
전체스크립트 상단에 SET Escape '\'  설정되어있고 중간에 이런 replace문들이 있는거죠 \\
 \\
SELECT \\
 DISTINCT ''AS CODE, '' AS ITEMNAME, \\
 TRIM(ADM_EMD) AS NAME1, \\
 REGEXP_REPLACE(ADM_EMD, '([^0-9,.]*)([^동]*)(동|읍|면)', '\1') AS NAME2 \\
 FROM &1\_JIBUN_CODE \\
 WHERE \\
 USE_FLAG IN ('1', '2') AND SUBSTR(ADM_CODE,6,10) <> '00000' AND \\
 LENGTH(REGEXP_REPLACE(ADM_EMD, '([^0-9,.]*)([^동]*)(동|읍|면)', '\1'))> 1 \\
 \\
그냥 set escape off 할수도없고..저 replace 문들도 사용해야하고..좋은 방법은 없나요.. ㅜ \\
 \\
시도1) set escape 쓸때 백슬래쉬말고 다른기호를 쓴다 => #로 바꿔보니 에러나더라구요 \\
시도2) regexp_replace 쓸때 백슬래쉬말고 다른표현을 쓴다 => 이건 어떻게 해야 동일하게 나올지 잘안되구,자칫 잘못꼬이면 큰일나구, \\
 \\
-- 정규식 검색하다가 들러서 질문남깁니다.. 근데 여기에 질문해도 되는건가요.. <mysign(Daff,2015-6-15 11:35 am)>

: 질문해도 상관은 없습니다만 답은 제가 모르겠네요ㅋ \\
 \\
오라클 쪽인가본데, \\
1) 직관적으로 생각해서 백슬래시가 이스케이프 접두사로 쓰이는 상황이라면, 백슬래시 자체를 나타내기 위해서는 \\를 쓰겠지요. 그러니 저 regexp_replace 쪽에서 '\1'이라고 쓴 걸 '\\1' 로 바꿔서 해볼 법 하고요. (그럼 \\가 먼저 \로 바뀌고, 그 상태에서 함수 인자로 들어가 동작하여 성공...하는 게 이론적인 희망) \\
 \\
2) [http://stackoverflow.com/a/410490 이 댓글]을 보면 저 시도1에서 말씀하신 것처럼 이스케이프 접두어를 #으로 바꾸는 게 가능해보이는데요. 에러가 난 이유는 다른 데 있었던 게 아닐까요. <mysign([[Raymundo]],2015-6-15 9:15 pm)>

regexp_replace 쪽에서 '\1'이라고 쓴 걸 '\\1' 로 바꿔서 => 이렇게 해보니 해결되었어요, 정말 급했는데.. 감사합니다!!! <mysign(Daff,2015-6-16 12:47 pm)>

1.1.1 에서 보면 \\
"keeper" =~ /^keep$/;      # 매치됨 \\
 \\
^와$를 사용하면 스트링 전체를 할 수 있다고 해서 위와 같이 매칭이 된다고 되어 있는데 매칭이 되지 않음이 맞지 않을까 합니다. <mysign(duraboy,2016-6-13 2:44 pm)>

: 헉 맞습니다. 이 문서가 만들어진 후 몇 년간 아무도 눈치채지 못하고 지나간 것을... 감사합니다. <mysign([[Raymundo]],2016-6-14 1:54 pm)>

Hi,  \\
 \\
pe.kr is only listed in a 8/10,000+ Directories \\
 \\
We have a black friday deal going on at the moment to get your website listed in all 10k+ for $19.95 \\
 \\
Visit us on DirectoryBump.com <mysign(Wilda,2023-11-22 5:14 am)>
<longcomments(Perl/정규표현식,100)>
----

</div>
----
[[컴퓨터분류]]
Perl/정규표현식 페이지로 돌아가기 | 다른 수정본 보기