=encoding utf8
=head1 NAME
X X X
=begin original
perlre - Perl regular expressions
=end original
perlre - Perl の正規表現
=head1 DESCRIPTION
=begin original
This page describes the syntax of regular expressions in Perl.
=end original
このページでは Perl での正規表現の構文について説明します。
=begin original
If you haven't used regular expressions before, a tutorial introduction
is available in L. If you know just a little about them,
a quick-start introduction is available in L.
=end original
もしこれまでに正規表現を使ったことがないなら、
L にチュートリアルがあります。
正規表現を少しだけ知っているなら、L に
クイックスタートがあります。
=begin original
Except for L section, this page assumes you are familiar
with regular expression basics, like what is a "pattern", what does it
look like, and how it is basically used. For a reference on how they
are used, plus various examples of the same, see discussions of C,
C, C and C<"??"> in L.
=end original
L 節を例外として、このページは、「パターン」とは何か、
それはどのような見た目のものか、基本的にどのようにして使われるか、といった
正規表現の基本に親しんでいることを仮定しています。
それらをどのように使うのかやそれに関する様々な例に
関しては、L にある
C, C, C, C<"??"> の説明を参照して下さい。
=begin original
New in v5.22, L|re/'strict' mode> applies stricter
rules than otherwise when compiling regular expression patterns. It can
find things that, while legal, may not be what you intended.
=end original
v5.22 から、L|re/'strict' mode> は、
正規表現パターンをコンパイルするときにその他よりもより厳しい規則を
適用します。
これは、正当ではあるけれども、意図していないかもしれないものを
見つけることができます。
=head2 The Basics
X X X
(基本)
=begin original
Regular expressions are strings with the very particular syntax and
meaning described in this document and auxiliary documents referred to
by this one. The strings are called "patterns". Patterns are used to
determine if some other string, called the "target", has (or doesn't
have) the characteristics specified by the pattern. We call this
"matching" the target string against the pattern. Usually the match is
done by having the target be the first operand, and the pattern be the
second operand, of one of the two binary operators C<=~> and C,
listed in L; and the pattern will have been
converted from an ordinary string by one of the operators in
L, like so:
=end original
正規表現とは、この文書と、この文書で参照される補助文書で記述されている、
特定の構文と意味を持つ文字列です。
この文字列は「パターン」と呼ばれます。
パターンは、「ターゲット」と呼ばれる他の文字列が、パターンで指定された
特性を持つ(または持たない)かどうかを判別するために使われます。
これをパターンに対するターゲット文字列の「マッチング」と呼びます。
通常、マッチングは、L にリストされている
二つの二項演算子 C<=~> および C の一つの、ターゲットを
最初のオペランドにし、パターンを 2 番目のオペランドにすることによって
行われます;
そしてパターンは次のように、L の
演算子の一つによって通常の文字列から変換されています。
$foo =~ m/abc/
=begin original
This evaluates to true if and only if the string in the variable C<$foo>
contains somewhere in it, the sequence of characters "a", "b", then "c".
(The C<=~ m>, or match operator, is described in
L.)
=end original
これは、変数 C<$foo> 内の文字列のどこかに文字並び "a", "b", "c" が
含まれている場合にのみ真と評価されます。
(マッチング演算子 C<=~ m> は、L で
説明されています。)
=begin original
Patterns that aren't already stored in some variable must be delimitted,
at both ends, by delimitter characters. These are often, as in the
example above, forward slashes, and the typical way a pattern is written
in documentation is with those slashes. In most cases, the delimitter
is the same character, fore and aft, but there are a few cases where a
character looks like it has a mirror-image mate, where the opening
version is the beginning delimiter, and the closing one is the ending
delimiter, like
=end original
何らかの変数にまだ格納されていないパターンは、両端が区切り文字で
区切られている必要があります。
これらは上の例のようにスラッシュであることが多く、文書中で
パターンを記述する一般的な方法はこれらのスラッシュです。
ほとんどの場合、区切り文字は前と後で同じ文字ですが、文字が鏡像のように
見える場合がいくつかあります;
次のように、開くのが開始区切り文字で、閉じるのが終了区切り文字です:
$foo =~ m
=begin original
Most times, the pattern is evaluated in double-quotish context, but it
is possible to choose delimiters to force single-quotish, like
=end original
ほとんどの場合、パターンはダブルクォート風コンテキストで評価されますが、
次のように区切り文字を選択してシングルクォート風を強制することもできます:
$foo =~ m'abc'
=begin original
If the pattern contains its delimiter within it, that delimiter must be
escaped. Prefixing it with a backslash (I, C<"/foo\/bar/">)
serves this purpose.
=end original
パターン内に区切り文字が含まれている場合は、その区切り文字を
エスケープする必要があります。
逆スラッシュを前置すると (例えば、C<"/foo\/bar/">)、この目的を
達成できます。
=begin original
Any single character in a pattern matches that same character in the
target string, unless the character is a I with a special
meaning described in this document. A sequence of non-metacharacters
matches the same sequence in the target string, as we saw above with
C.
=end original
パターン中のすべての単一の文字は、その文字が個々でまたはこの文書で
説明されている特別な意味を持った I<メタ文字> である場合以外は、
ターゲット文字列内の同じ文字にマッチングします。
非メタ文字の並びは、前述の C で見たように、
ターゲット文字列の同じ並びにマッチングします。
=begin original
Only a few characters (all of them being ASCII punctuation characters)
are metacharacters. The most commonly used one is a dot C<".">, which
normally matches almost any character (including a dot itself).
=end original
ほんのいくつかの文字 (全て ASCII の句読点文字) がメタ文字です。
もっとも一般的に使われるものはドット C<"."> で、これは通常
(ドット自身を含む) ほとんどの文字にマッチングします。
=begin original
You can cause characters that normally function as metacharacters to be
interpreted literally by prefixing them with a C<"\">, just like the
pattern's delimiter must be escaped if it also occurs within the
pattern. Thus, C<"\."> matches just a literal dot, C<"."> instead of
its normal meaning. This means that the backslash is also a
metacharacter, so C<"\\"> matches a single C<"\">. And a sequence that
contains an escaped metacharacter matches the same sequence (but without
the escape) in the target string. So, the pattern C would
match any target string that contains the sequence C<"blur\fl">.
=end original
文字は C<"\"> で前置されることで通常はメタ文字としての機能を持っている文字を
リテラルとして処理させられるようになります;
パターンの区切り文字がパターンの中に現れる場合は
エスケープされなければならないのと同様です。
従って、C<"\."> は、通常の意味ではなく、
単にリテラルなドット C<"."> にマッチングするようになります。
つまり、逆スラッシュもメタ文字なので、
"\\" は単一の C<"\"> にマッチングするということです。
エスケープされたメタ文字を含む並びは、ターゲット文字列の中の
同じ並び(但しエスケープなし)にマッチングします。
それで、パターン C は
並び C<"blur\fl"> を含むターゲット文字列にマッチングします。
=begin original
The metacharacter C<"|"> is used to match one thing or another. Thus
=end original
メタ文字 C<"|"> は二つのもののどちらかをマッチングするのに使われます。
従って:
$foo =~ m/this|that/
=begin original
is TRUE if and only if C<$foo> contains either the sequence C<"this"> or
the sequence C<"that">. Like all metacharacters, prefixing the C<"|">
with a backslash makes it match the plain punctuation character; in its
case, the VERTICAL LINE.
=end original
これは C<$foo> に並び C<"this"> または並び C<"that"> のどちらかが
含まれている場合にのみ真になります。
全てのメタ文字と同様、C<"|"> に逆スラッシュを前置すると普通の句読点文字、
この場合は VERTICAL LINE にマッチングします。
$foo =~ m/this\|that/
=begin original
is TRUE if and only if C<$foo> contains the sequence C<"this|that">.
=end original
これは、C<$foo> に C<"this|that"> という並びを含んでいる場合にのみ
真になります。
=begin original
You aren't limited to just a single C<"|">.
=end original
単一の C<"|"> だけに制限されません。
$foo =~ m/fee|fie|foe|fum/
=begin original
is TRUE if and only if C<$foo> contains any of those 4 sequences from
the children's story "Jack and the Beanstalk".
=end original
これは、C<$foo> に童話「ジャックとまめの木」から取った
四つの並びのいずれがを含んでいる場合にのみ真になります。
=begin original
As you can see, the C<"|"> binds less tightly than a sequence of
ordinary characters. We can override this by using the grouping
metacharacters, the parentheses C<"("> and C<")">.
=end original
ここで見られるように、C<"|"> は通常の文字の並びより弱く結びつけます。
これはグループ化メタ文字であるかっこ C<"("> と C<")"> を使って
上書きできます。
$foo =~ m/th(is|at) thing/
=begin original
is TRUE if and only if C<$foo> contains either the sequence S> or the sequence S>. The portions of the string
that match the portions of the pattern enclosed in parentheses are
normally made available separately for use later in the pattern,
substitution, or program. This is called "capturing", and it can get
complicated. See L.
=end original
これは C<$foo> に並び S> または並び
S> のいずれかが含まれている場合にのみ TRUE が返されます。
かっこで囲まれたパターンの部分と一致する文字列の部分は、通常、後でパターン、
置換、プログラムで使用するために個別に使用できます。
これは「捕捉」(capturing)と呼ばれ、複雑になる場合があります。
L を参照してください。
=begin original
The first alternative includes everything from the last pattern
delimiter (C<"(">, C<"(?:"> (described later), I. or the beginning
of the pattern) up to the first C<"|">, and the last alternative
contains everything from the last C<"|"> to the next closing pattern
delimiter. That's why it's common practice to include alternatives in
parentheses: to minimize confusion about where they start and end.
=end original
最初の代替には最後のパターン区切り (C<"(">, C<"(?:"> (後述) など、または
パターンの始まり)から最初の C<"|"> までのすべてが含まれ、
最後の代替には最後の C<"|"> から次の閉じパターン区切りまでが含まれます。
通常代替をかっこの中に入れるのは、その開始位置と終了位置が少しはわかりやすく
なるようにです。
=begin original
Alternatives are tried from left to right, so the first
alternative found for which the entire expression matches, is the one that
is chosen. This means that alternatives are not necessarily greedy. For
example: when matching C against C<"barefoot">, only the C<"foo">
part will match, as that is the first alternative tried, and it successfully
matches the target string. (This might not seem important, but it is
important when you are capturing matched text using parentheses.)
=end original
代替は左から右へと試されます、なので最初の代替がその完全な式で
マッチングしたのならそれが選択されます。
これは代替は貪欲である必要はないということを意味します。
例えば: C<"barefoot"> に対して C をマッチングさせると、
最初の代替から試されるので、C<"foo"> の部分がマッチングし、
これは対象の文字列に対して成功でマッチングします。
(これは重要ではないでしょうが、かっこを使ってマッチングしたテキストを
捕捉しているときには重要でしょう。)
=begin original
Besides taking away the special meaning of a metacharacter, a prefixed
backslash changes some letter and digit characters away from matching
just themselves to instead have special meaning. These are called
"escape sequences", and all such are described in L. A
backslash sequence (of a letter or digit) that doesn't currently have
special meaning to Perl will raise a warning if warnings are enabled,
as those are reserved for potential future use.
=end original
接頭辞付き逆スラッシュは、メタ文字の特殊な意味を取り除くだけでなく、
一部の文字や数字をそれ自体と一致させないように変更し、
代わりに特殊な意味を持つようにします。
これらは「エスケープシーケンス」と呼ばれ、L で
説明されています。
現在 Perl にとって特殊な意味を持たない (文字や数字の)
逆スラッシュシーケンスは、警告が有効になっている場合に警告を発します;
これらは将来使用するために予約されているためです。
=begin original
One such sequence is C<\b>, which matches a boundary of some sort.
C<\b{wb}> and a few others give specialized types of boundaries.
(They are all described in detail starting at
L.) Note that these don't match
characters, but the zero-width spaces between characters. They are an
example of a L. Consider again,
=end original
そのようなシーケンスのひとつは C<\b> です;
これはある種の境界にマッチします。
C<\b{wb}> やその他のいくつかは特定の境界を与えます。
(これらはすべて L で詳細に
記述されています。)
これらは文字ではなく、文字と文字の間のゼロ幅の
スペースにマッチングすることに注意してください。
これらは L<ゼロ幅言明|/Assertions> の例です。
もう一度考えてみます:
$foo =~ m/fee|fie|foe|fum/
=begin original
It evaluates to TRUE if, besides those 4 words, any of the sequences
"feed", "field", "Defoe", "fume", and many others are in C<$foo>. By
judicious use of C<\b> (or better (because it is designed to handle
natural language) C<\b{wb}>), we can make sure that only the Giant's
words are matched:
=end original
これは、これら四つの単語以外に、"feed", "field", "Defoe", "fume",
その他多くのシーケンスのいずれかが C<$foo> にある場合、TRUE と評価されます。
C<\b>(または(自然言語を処理するように設計されているため) より良い
C<\b{wb}>)を慎重に使用することで、
確実に巨人の単語だけが一致するようにできます。
$foo =~ m/\b(fee|fie|foe|fum)\b/
$foo =~ m/\b{wb}(fee|fie|foe|fum)\b{wb}/
=begin original
The final example shows that the characters C<"{"> and C<"}"> are
metacharacters.
=end original
最後の例は、文字 C<"{"> と C<"}"> がメタ文字であることを示しています。
=begin original
Another use for escape sequences is to specify characters that cannot
(or which you prefer not to) be written literally. These are described
in detail in L, but the next three
paragraphs briefly describe some of them.
=end original
エスケープシーケンスのもう一つの使用法は、文字通りに書くことができない
(あるいは書きたくない)文字を指定することです。
これらについては
L で詳しく説明していますが、
次の三つの段落でその一部を簡単に説明します。
=begin original
Various control characters can be written in C language style: C<"\n">
matches a newline, C<"\t"> a tab, C<"\r"> a carriage return, C<"\f"> a
form feed, I.
=end original
様々な制御文字は C 言語形式で書くことができます:
"\n" は改行にマッチングし、C<"\t"> はタブに、C<"\r"> は復帰に、
C<"\f"> はフォームフィードにといった具合にマッチングします。
=begin original
More generally, C<\I>, where I is a string of three octal
digits, matches the character whose native code point is I. You
can easily run into trouble if you don't have exactly three digits. So
always use three, or since Perl 5.14, you can use C<\o{...}> to specify
any number of octal digits.
=end original
より一般的に、C<\I> (I は 3 桁の 8 進数字) は
ネイティブな符号位置が I の文字にマッチングします。
正確に 3 桁以外の数字を使うと、簡単に困難に陥ります。
従って、常に 3 桁で使うか、Perl 5.14 以降なら、
任意の桁の 8 進数を使うために C<\o{...}> を使えます。
=begin original
Similarly, C<\xI>, where I are hexadecimal digits, matches the
character whose native ordinal is I. Again, not using exactly two
digits is a recipe for disaster, but you can use C<\x{...}> to specify
any number of hex digits.
=end original
同じように、\xI (I は16進数字) はネイティブな数値で I に
なる文字にマッチングします。
再び、正確に 2 桁以外の数字を使うのは災いの元ですが、
任意の桁の 16 進数を指定するために C<\x{...}> を使えます。
=begin original
Besides being a metacharacter, the C<"."> is an example of a "character
class", something that can match any single character of a given set of
them. In its case, the set is just about all possible characters. Perl
predefines several character classes besides the C<".">; there is a
separate reference page about just these, L.
=end original
メタ文字であることに加えて、C<"."> は、特定の集合の任意の 1 文字に
マッチングする「文字クラス」の例です。
この場合、集合ははほぼすべての可能な文字です。
Perlは C<"."> 以外にもいくつかの文字クラスを事前定義しています;
これらについては、L という別のリファレンスページが
あります。
=begin original
You can define your own custom character classes, by putting into your
pattern in the appropriate place(s), a list of all the characters you
want in the set. You do this by enclosing the list within C<[]> bracket
characters. These are called "bracketed character classes" when we are
being precise, but often the word "bracketed" is dropped. (Dropping it
usually doesn't cause confusion.) This means that the C<"["> character
is another metacharacter. It doesn't match anything just by itself; it
is used only to tell Perl that what follows it is a bracketed character
class. If you want to match a literal left square bracket, you must
escape it, like C<"\[">. The matching C<"]"> is also a metacharacter;
again it doesn't match anything by itself, but just marks the end of
your custom class to Perl. It is an example of a "sometimes
metacharacter". It isn't a metacharacter if there is no corresponding
C<"[">, and matches its literal self:
=end original
独自のカスタム文字クラスを定義するには、パターン内の適切な場所に、集合内に
必要なすべての文字のリストを配置します。
これを行うには、リストを C<[]> 大かっこ文字で囲みます。
これらは、正確にであれば「大かっこ文字クラス」と呼ばれますが、
「大かっこ」という単語が削除されることがよくあります。
(通常は、これを削除しても混乱は生じません。)
これは、C<"["> 文字はもう一つのメタ文字であることを意味します。
これ自身だけでは何にもマッチングしません;
Perl に対して、後に続くものが大かっこ文字クラスであることを
伝えるためにのみ使用されます。
リテラルの左大かっこにマッチさせたい場合は、C<"\["> のように
エスケープする必要があります。
一致する C<"]"> もメタ文字です;
ここでも何にもマッチしませんが、カスタムクラスの終わりを Perl に
マークするだけです。
これは「時々メタ文字」の例です。
対応する C<"["> が存在しない場合はメタ文字ではなく、
リテラルにマッチングします。
print "]" =~ /]/; # prints 1
=begin original
The list of characters within the character class gives the set of
characters matched by the class. C<"[abc]"> matches a single "a" or "b"
or "c". But if the first character after the C<"["> is C<"^">, the
class instead matches any character not in the list. Within a list, the
C<"-"> character specifies a range of characters, so that C
represents all characters between "a" and "z", inclusive. If you want
either C<"-"> or C<"]"> itself to be a member of a class, put it at the
start of the list (possibly after a C<"^">), or escape it with a
backslash. C<"-"> is also taken literally when it is at the end of the
list, just before the closing C<"]">. (The following all specify the
same class of three characters: C<[-az]>, C<[az-]>, and C<[a\-z]>. All
are different from C<[a-z]>, which specifies a class containing
twenty-six characters, even on EBCDIC-based character sets.)
=end original
文字クラスの中の文字のリストは、そのクラスがマッチングする
文字の集合を表しています。
C<"[abc]"> は単一の "a" または "b" または "c" にマッチングします。.
しかし、C<"["> の後の最初の文字が C<"^"> だったときには、その文字クラスは
リストの中にない任意の文字にマッチングします。
リストの中では、文字 C<"-"> は文字の範囲を意味します;
なので C は "a" と "z" を含めてそれらの間にあるすべての文字を表します。
文字クラスの要素として C<"-"> または C<"]"> 自身を使いたい時には、
リストの先頭に (あるいは C<"^"> の後に) 置くか、逆スラッシュを使って
エスケープします。
C<"-"> はリストの終端、リストを閉じる C<"]"> の直前にあったときも
リテラルとして扱われます。
(次の例はすべて同じ3文字からなる文字クラスです: C<[-az]>, C<[az-]>,
C<[a\-z]>。
これらはすべて EBCDIC ベースの文字集合であっても26文字からなる文字集合
C<[a-z]> とは異なります。)
=begin original
There is lots more to bracketed character classes; full details are in
L.
=end original
大かっこ文字クラスにはもっと色々な要素があります; 完全な詳細は
L にあります。
=head3 Metacharacters
X
X<\> X<^> X<.> X<$> X<|> X<(> X<()> X<[> X<[]>
(メタ文字)
=begin original
L introduced some of the metacharacters. This section
gives them all. Most of them have the same meaning as in the I
command.
=end original
L ではメタ文字の一部を導入しました。
この節ではその全てを示します。
そのほとんどは I コマンドと同じ意味を持ちます。
=begin original
Only the C<"\"> is always a metacharacter. The others are metacharacters
just sometimes. The following tables lists all of them, summarizes
their use, and gives the contexts where they are metacharacters.
Outside those contexts or if prefixed by a C<"\">, they match their
corresponding punctuation character. In some cases, their meaning
varies depending on various pattern modifiers that alter the default
behaviors. See L.
=end original
C<"\"> のみが常にメタ文字です。
その他は時々にだけメタ文字です。
次の表は、すべてのメタ文字の一覧、使用方法の概要、
メタ文字になるコンテキストを示しています。
これらのコンテキスト以外では、または C<"\"> で始まる場合は、
対応する句読点文字とマッチングします。
場合によっては、既定の動作を変更するさまざまなパターン修飾子によって
意味が異なります。
L を参照してください。
=begin original
PURPOSE WHERE
\ Escape the next character Always, except when
escaped by another \
^ Match the beginning of the string Not in []
(or line, if /m is used)
^ Complement the [] class At the beginning of []
. Match any single character except newline Not in []
(under /s, includes newline)
$ Match the end of the string Not in [], but can
(or before newline at the end of the mean interpolate a
string; or before any newline if /m is scalar
used)
| Alternation Not in []
() Grouping Not in []
[ Start Bracketed Character class Not in []
] End Bracketed Character class Only in [], and
not first
* Matches the preceding element 0 or more Not in []
times
+ Matches the preceding element 1 or more Not in []
times
? Matches the preceding element 0 or 1 Not in []
times
{ Starts a sequence that gives number(s) Not in []
of times the preceding element can be
matched
{ when following certain escape sequences
starts a modifier to the meaning of the
sequence
} End sequence started by {
- Indicates a range Only in [] interior
# Beginning of comment, extends to line end Only with /x modifier
=end original
目的 場所
\ 次の文字をエスケープ もう一つの \ で
エスケープしない限り常に
^ 文字列(または /m が使われていれば行) の [] の中以外
先頭にマッチング
^ [] クラスの補集合 [] の先頭
. 改行以外の任意の 1 文字にマッチング [] の中以外
(/s の下では改行を含む)
$ 文字列の末尾にマッチング [] の中以外、しかし
(または文字列の最後の改行の前; スカラの変数展開を
または /m が使われていれば改行の前) 意味する
| 代替 [] の中以外
() グループ化 [] の中以外
[ 大かっこ文字クラスの開始 [] の中以外
] 大かっこ文字クラスの終了 [] のみで先頭以外
* 前にある要素に 0 回以上マッチング [] の中以外
+ 前にある要素に 1 回以上マッチング [] の中以外
? 前にある要素に 0 回または 1 回マッチング [] の中以外
{ 前にある要素がマッチングする回数を指定する [] の中以外
並びの開始
{ 以下のいくつかのエスケープシーケンスで
シーケンスの意味の修飾子の開始
} { で開始した並びの終わり
- 範囲を示す [] の内部のみ
# コメントの開始; 行末まで /x 修飾子のみ
=begin original
Notice that most of the metacharacters lose their special meaning when
they occur in a bracketed character class, except C<"^"> has a different
meaning when it is at the beginning of such a class. And C<"-"> and C<"]">
are metacharacters only at restricted positions within bracketed
character classes; while C<"}"> is a metacharacter only when closing a
special construct started by C<"{">.
=end original
ほとんどのメタ文字は、かっこで囲まれた文字クラス内で出現すると
特殊な意味を失うことに注意してください;
ただし、C<"^"> は、そのようなクラスの先頭では異なる意味を持ちます。
また、C<"-"> と C<"]"> は、かっこ弧で囲まれた文字クラス内の限定された
位置でだけメタ文字になります;
一方、C<"}"> は、C<"{"> によって開始された特殊な構造体を
閉じるときにのみメタ文字です。
=begin original
In double-quotish context, as is usually the case, you need to be
careful about C<"$"> and the non-metacharacter C<"@">. Those could
interpolate variables, which may or may not be what you intended.
=end original
ダブルクォート風のコンテキストでは、通常の場合と同様、
C<"$"> とメタ文字でない C<"@"> に注意する必要があります。
これらは変数を補完することができますが、それは
意図したものである場合とない場合があります。
=begin original
These rules were designed for compactness of expression, rather than
legibility and maintainability. The Lx and Exx> pattern
modifiers allow you to insert white space to improve readability. And
use of S>> adds extra checking to
catch some typos that might silently compile into something unintended.
=end original
これらの規則は、読みやすさや保守性ではなく、表現のコンパクトさを
考慮して設計されています。
Lx and Exx> パターン修飾子を使用すると、読みやすさを
向上させるために空白を挿入できます。
また、S>> を使用すると、
意図しないものに暗黙的にコンパイルされる可能性のあるタイプミスを
捕捉するための追加チェックが追加されます。
=begin original
By default, the C<"^"> character is guaranteed to match only the
beginning of the string, the C<"$"> character only the end (or before the
newline at the end), and Perl does certain optimizations with the
assumption that the string contains only one line. Embedded newlines
will not be matched by C<"^"> or C<"$">. You may, however, wish to treat a
string as a multi-line buffer, such that the C<"^"> will match after any
newline within the string (except if the newline is the last character in
the string), and C<"$"> will match before any newline. At the
cost of a little more overhead, you can do this by using the
Cm>> modifier on the pattern match operator. (Older programs
did this by setting C<$*>, but this option was removed in perl 5.10.)
X<^> X<$> X
=end original
デフォルトでは、文字 C<"^"> は文字列の先頭にのみ、そして文字 C<"$"> は
末尾(または末尾の改行の前)にのみマッチングすることを保証し、そして Perl は
文字列が 1 行のみを含んでいるという仮定でいくつかの最適化を行います。
埋め込まれている改行文字は C<"^"> や C<"$"> とはマッチングしません。
しかし文字列には複数行が格納されていて、C<"^"> は任意の改行の後(但し
改行文字が文字列の最後の文字だった場合は除く)、そして C<"$"> は任意の改行の
前でマッチングさせたいこともあるでしょう。
小さなオーバーヘッドはありますが、これはパターンマッチングで
Cm>> 修飾子を使うことで行うことができます。
(古いプログラムでは C<$*> を設定することでこれを行っていましたが
これは perl 5.10 では削除されています。)
X<^> X<$> X
=begin original
To simplify multi-line substitutions, the C<"."> character never matches a
newline unless you use the Ls>|/s> modifier, which in effect tells
Perl to pretend the string is a single line--even if it isn't.
X<.> X
=end original
複数行での利用を簡単にするために、文字 C<"."> は Ls>|/s> 修飾子を
使って Perl に文字列を 1 行として処理すると Perl に伝えない限り、
改行にはマッチングしません。
X<.> X
=head2 Modifiers
(修飾子)
=head3 Overview
(概要)
=begin original
The default behavior for matching can be changed, using various
modifiers. Modifiers that relate to the interpretation of the pattern
are listed just below. Modifiers that alter the way a pattern is used
by Perl are detailed in L and
L. Modifiers can be added
dynamically; see L below.
=end original
マッチングのデフォルトの振る舞いは、様々な修飾子 (modifier) で
変更できます。
パターンの解釈に関連する修飾子は、直後に一覧にしています。
Perl がパターンを使う方法を変更する
修飾子は L
及び L に
説明されています。
修飾子は動的に追加できます; 後述する L を
参照してください。
=over 4
=item B>
X X X X
=begin original
Treat the string being matched against as multiple lines. That is, change C<"^"> and C<"$"> from matching
the start of the string's first line and the end of its last line to
matching the start and end of each line within the string.
=end original
文字列を複数行としてマッチングするように扱います。
つまり、C<"^"> 及び C<"$"> は文字列の最初の行の先頭および最後の行の末尾に対する
マッチングから、文字列中の各行の銭湯と末尾に対するマッチングへと
変更されます。
=item B>
X X X
X
=begin original
Treat the string as single line. That is, change C<"."> to match any character
whatsoever, even a newline, which normally it would not match.
=end original
文字列を 1 行として扱います。
つまり、C<"."> は任意の 1 文字、通常はマッチングしない改行でさえも
マッチングするように変更されます。
=begin original
Used together, as C, they let the C<"."> match any character whatsoever,
while still allowing C<"^"> and C<"$"> to match, respectively, just after
and just before newlines within the string.
=end original
C として共に使うと、C<"^"> 及び C<"$"> はそれぞれ
文字列中の改行の直前及び直後のマッチングでありつつ、C<"."> は任意の文字に
マッチングするようになります。
=item B>
X X X
X
=begin original
Do case-insensitive pattern matching. For example, "A" will match "a"
under C.
=end original
大文字小文字を区別しないパターンマッチングを行います。
例えば、C の下では "A" は "a" にマッチングします。
=begin original
If locale matching rules are in effect, the case map is taken from the
current
locale for code points less than 255, and from Unicode rules for larger
code points. However, matches that would cross the Unicode
rules/non-Unicode rules boundary (ords 255/256) will not succeed, unless
the locale is a UTF-8 one. See L.
=end original
ロケールマッチングルールが有効になっている場合、符号位置 255 以下の場合は
現在のロケールから取られ、より大きい符号位置では Unicode ルールから
取られます。
しかし、Unicode ルールと非 Unicode ルールの境界(番号255/256) を
またぐマッチングは、ロケールが UTF-8 のものでない限り成功しません。
L を参照してください。
=begin original
There are a number of Unicode characters that match a sequence of
multiple characters under C. For example,
C should match the sequence C. Perl is not
currently able to do this when the multiple characters are in the pattern and
are split between groupings, or when one or more are quantified. Thus
=end original
C の基で複数の文字の並びにマッチングする Unicode 文字はたくさんあります。
例えば、C は並び C にマッチングするべきです。
複数の文字がパターン中にあってグループ化で分割されている場合、または
どれかの文字に量指定子が付いている場合、Perl は今のところこれを行えません。
従って
=begin original
"\N{LATIN SMALL LIGATURE FI}" =~ /fi/i; # Matches
"\N{LATIN SMALL LIGATURE FI}" =~ /[fi][fi]/i; # Doesn't match!
"\N{LATIN SMALL LIGATURE FI}" =~ /fi*/i; # Doesn't match!
=end original
"\N{LATIN SMALL LIGATURE FI}" =~ /fi/i; # マッチング
"\N{LATIN SMALL LIGATURE FI}" =~ /[fi][fi]/i; # マッチングしない!
"\N{LATIN SMALL LIGATURE FI}" =~ /fi*/i; # マッチングしない!
=begin original
# The below doesn't match, and it isn't clear what $1 and $2 would
# be even if it did!!
"\N{LATIN SMALL LIGATURE FI}" =~ /(f)(i)/i; # Doesn't match!
=end original
# 次のものはマッチングしないし、もししたとしても $1 と $2 が何になるか
# はっきりしない!!
"\N{LATIN SMALL LIGATURE FI}" =~ /(f)(i)/i; # マッチングしない!
=begin original
Perl doesn't match multiple characters in a bracketed
character class unless the character that maps to them is explicitly
mentioned, and it doesn't match them at all if the character class is
inverted, which otherwise could be highly confusing. See
L, and
L.
=end original
Perl は、明示的にマッピングについて言及されていない限り、
大かっこ文字クラスの複数の文字にはマッチングしません;
そして文字クラスが否定された場合はそれらには全くマッチングしません;
さもなければとても混乱することがあるからです。
L と
L を参照して下さい。
=item B> and B>
X
(B> と B>)
=begin original
Extend your pattern's legibility by permitting whitespace and comments.
Details in Lx and Exx>
=end original
空白やコメントを許可してパターンを読みやすくするように拡張します。
詳細は Lx and Exx> にあります。
=item B>
X
X X
=begin original
Preserve the string matched such that C<${^PREMATCH}>, C<${^MATCH}>, and
C<${^POSTMATCH}> are available for use after matching.
=end original
C<${^PREMATCH}>, C<${^MATCH}>, C<${^POSTMATCH}> といったマッチングされた
文字列をマッチングの後も使えるように維持します。
=begin original
In Perl 5.20 and higher this is ignored. Due to a new copy-on-write
mechanism, C<${^PREMATCH}>, C<${^MATCH}>, and C<${^POSTMATCH}> will be available
after the match regardless of the modifier.
=end original
Perl 5.20 以降ではこれは無視されます。
新しいコピーオンライト機構により、
C<${^PREMATCH}>, C<${^MATCH}>, and C<${^POSTMATCH}> はこの修飾子に関わらず
マッチングの後も利用可能です。
=item B>, B>, B>, and B>
X X X X
(B>, B>, B>, B>)
=begin original
These modifiers, all new in 5.14, affect which character-set rules
(Unicode, I.) are used, as described below in
L.
=end original
5.14 から導入されたこれらの新しい修飾子は、どの文字集合規則
(Unicode など) が使われるかに影響を与えます;
L で後述します。
=item B>
X X X
X
=begin original
Prevent the grouping metacharacters C<()> from capturing. This modifier,
new in 5.22, will stop C<$1>, C<$2>, I... from being filled in.
=end original
グループ化メタ文字 C<()> が捕捉しないようにします。
5.22 からのこの修飾子は、C<$1>, C<$2> などを埋めるのを止めます。
"hello" =~ /(hi|hello)/; # $1 is "hello"
"hello" =~ /(hi|hello)/n; # $1 is undef
=begin original
This is equivalent to putting C at the beginning of every capturing group:
=end original
これは各捕捉グループの始めに C を置くのと等価です:
"hello" =~ /(?:hi|hello)/; # $1 is undef
=begin original
C can be negated on a per-group basis. Alternatively, named captures
may still be used.
=end original
C はグループ単位で否定できます。
その代わりに、名前付き捕捉はまだ使えます。
"hello" =~ /(?-n:(hi|hello))/n; # $1 is "hello"
"hello" =~ /(?hi|hello)/n; # $1 is "hello", $+{greet} is
# "hello"
=item Other Modifiers
(その他の修飾子)
=begin original
There are a number of flags that can be found at the end of regular
expression constructs that are I generic regular expression flags, but
apply to the operation being performed, like matching or substitution (C
or C respectively).
=end original
一般的な正規表現フラグ I<ではない> ですが、マッチングや置換 (それぞれ C
や C) のような操作が実行される時に適用される
多くのフラグが正規表現構文の末尾に見つけられます。
=begin original
Flags described further in
L are:
=end original
L に
さらに記述されているフラグは:
c - keep the current position during repeated matching
g - globally match the pattern repeatedly in the string
=begin original
Substitution-specific modifiers described in
L are:
=end original
置換専用の修飾子で
L に記述されているのは:
e - evaluate the right-hand side as an expression
ee - evaluate the right side as a string then eval the result
o - pretend to optimize your code, but actually introduce bugs
r - perform non-destructive substitution and return the new value
=back
=begin original
Regular expression modifiers are usually written in documentation
as I, "the C modifier", even though the delimiter
in question might not really be a slash. The modifiers C
may also be embedded within the regular expression itself using
the C<(?...)> construct, see L below.
=end original
正規表現修飾子は文書中では通常「C 修飾子」のように記述され、
これは区切りが実際にはスラッシュでなくてもそう記述されます。
また、C 修飾子は C<(?...)> 構築子を使って正規表現内に
埋め込まれることもあります; 後述する L を
参照してください。
=head3 Details on some modifiers
(一部の修飾子の詳細)
=begin original
Some of the modifiers require more explanation than given in the
L above.
=end original
修飾子の一部は前述の L よりもさらなる説明が必要です。
=head4 C and C
(C と C)
=begin original
A single C tells
the regular expression parser to ignore most whitespace that is neither
backslashed nor within a bracketed character class. You can use this to
break up your regular expression into more readable parts.
Also, the C<"#"> character is treated as a metacharacter introducing a
comment that runs up to the pattern's closing delimiter, or to the end
of the current line if the pattern extends onto the next line. Hence,
this is very much like an ordinary Perl code comment. (You can include
the closing delimiter within the comment only if you precede it with a
backslash, so be careful!)
=end original
単一の C は、逆スラッシュでエスケープされたり大かっこ文字クラスの
中だったりしないほとんどの空白を無視するように正規表現パーサに伝えます。
これは正規表現を読みやすく部分に分割するために使えます。
また C<"#"> は、パターンの閉じ区切り文字まで、またはパターンが次の行に
続く場合は現在の行の末尾までのコメントを開始するメタ文字として扱われます。
従って、これは通常の Perl コードのコメントととても似ています。
(コメントの中の閉じ区切り文字は、逆スラッシュを前置した場合にのみ
含めることができます; 注意してください!)
=begin original
Use of C means that if you want real
whitespace or C<"#"> characters in the pattern (outside a bracketed character
class, which is unaffected by C), then you'll either have to
escape them (using backslashes or C<\Q...\E>) or encode them using octal,
hex, or C<\N{}> or C<\p{name=...}> escapes.
It is ineffective to try to continue a comment onto the next line by
escaping the C<\n> with a backslash or C<\Q>.
=end original
C の使用はまた、(C の影響を受けない大かっこ文字クラス内以外で)
パターン中に本当の空白や
C<"#"> 文字を使いたい場合は、(逆スラッシュや C<\Q...\E> を使って)
エスケープするか、8 進数、16 進数、C<\N{}>, C<\p{name=...}> エスケープの
いずれかでエンコードする必要があると言うことです。
C<\n> を逆スラッシュや C<\Q> でエスケープすることで
コメントを次の行まで続けようとしても無効です。
=begin original
You can use L(?#text)> to create a comment that ends earlier than the
end of the current line, but C also can't contain the closing
delimiter unless escaped with a backslash.
=end original
現在の行の末尾より早く修了するコメントを作るために
L(?#text)> が使えますが、やはり C は逆スラッシュで
エスケープされない限り閉じ区切り文字を含むことはできません。
=begin original
A common pitfall is to forget that C<"#"> characters (outside a
bracketed character class) begin a comment under C and are not
matched literally. Just keep that in mind when trying to puzzle out why
a particular C pattern isn't working as expected.
Inside a bracketed character class, C<"#"> retains its non-special,
literal meaning.
=end original
よくある落とし穴は、(大かっこ文字クラスの外側の)
C<"#"> 文字は C の下ではコメントを始めるので、
文字通りにマッチしないことを忘れてしまうことです。
特定の C パターンが期待通りに動作しない理由を解明しようとするときには、
このことを念頭に置いてください。
大かっこ文字クラスの中では、C<"#"> は特別でないリテラルな意味のままです。
=begin original
Starting in Perl v5.26, if the modifier has a second C<"x"> within it,
the effect of a single C is increased. The only difference is that
inside bracketed character classes, non-escaped (by a backslash) SPACE
and TAB characters are not added to the class, and hence can be inserted
to make the classes more readable:
=end original
Perl v5.26 以降では、修飾子に二つ目の C<"x"> が含まれている場合、
一つの C の効果が増加します。
唯一の違いは、大かっこ文字クラスの中では、(逆スラッシュによって)
エスケープされていない SPACE および TAB 文字はクラスに追加されません;
したがって、クラスをより読みやすくするためにこれらを挿入できます:
/ [d-e g-i 3-7]/xx
/[ ! @ " # $ % ^ & * () = ? <> ' ]/xx
=begin original
may be easier to grasp than the squashed equivalents
=end original
これは、圧縮された同等物よりも掴みやすいかもしれません:
/[d-eg-i3-7]/
/[!@"#$%^&*()=?<>']/
=begin original
Note that this unfortunately doesn't mean that your bracketed classes
can contain comments or extend over multiple lines. A C<#> inside a
character class is still just a literal C<#>, and doesn't introduce a
comment. And, unless the closing bracket is on the same line as the
opening one, the newline character (and everything on the next line(s)
until terminated by a C<]> will be part of the class, just as if you'd
written C<\n>.
=end original
残念ながら、これはあなたの大かっこクラスがコメントを含めたり
複数行に拡張できたりするということではないことに注意してください。
文字クラスの中の C<#> はリテラルな C<#> のままで、コメントを導入しません。
また、閉じ大かっこが開き大かっこと同じ行にない限り、
改行文字 (および C<]> で終端されるまでの次の行の全て) は、
C<\n> を書いたのと同じように、クラスの一部になります。
=begin original
Taken together, these features go a long way towards
making Perl's regular expressions more readable. Here's an example:
=end original
まとめると、これらの機能は Perl の正規表現をより読みやすくするために
大きく役立ちます。
以下は例です:
# Delete (most) C comments.
$program =~ s {
/\* # Match the opening delimiter.
.*? # Match a minimal number of characters.
\*/ # Match the closing delimiter.
} []gsx;
=begin original
Note that anything inside
a C<\Q...\E> stays unaffected by C. And note that C doesn't affect
space interpretation within a single multi-character construct. For
example C<(?:...)> can't have a space between the C<"(">,
C<"?">, and C<":">. Within any delimiters for such a construct, allowed
spaces are not affected by C, and depend on the construct. For
example, all constructs using curly braces as delimiters, such as
C<\x{...}> can have blanks within but adjacent to the braces, but not
elsewhere, and no non-blank space characters. An exception are Unicode
properties which follow Unicode rules, for which see
L.
X
=end original
C<\Q...\E> の内側のものは C の影響を受けないことに注意してください。
例えば、C<(?:...)> は
C<"(">, C<"?">, C<":"> の間にスペースを含むことはできません。
このような構文の区切り文字の中では、スペースが許されるかどうかは
C に影響されず、構文自身に影響されます。
例えば、C<\x{...}> のような、区切り文字として中かっこを使う全ての構文は、
中かっこの隣の内部ではスペース文字を置けますが、他の場所には置けず、
スペース以外の空白文字も置けません。
例外は、Unicode の規則に従っている Unicode 特性です;
L を
参照してください。
X
=begin original
The set of characters that are deemed whitespace are those that Unicode
calls "Pattern White Space", namely:
=end original
空白と見なされる文字の集合は、Unicode が "Pattern White Space" と
呼ぶもので、次のものです:
U+0009 CHARACTER TABULATION
U+000A LINE FEED
U+000B LINE TABULATION
U+000C FORM FEED
U+000D CARRIAGE RETURN
U+0020 SPACE
U+0085 NEXT LINE
U+200E LEFT-TO-RIGHT MARK
U+200F RIGHT-TO-LEFT MARK
U+2028 LINE SEPARATOR
U+2029 PARAGRAPH SEPARATOR
=head4 Character set modifiers
(文字集合修飾子)
=begin original
C, C, C, and C, available starting in 5.14, are called
the character set modifiers; they affect the character set rules
used for the regular expression.
=end original
5.14 から利用可能な C, C, C, C は文字集合修飾子と呼ばれます;
これらは正規表現で使われる文字集合規則に影響を与えます。
=begin original
The C, C, and C modifiers are not likely to be of much use
to you, and so you need not worry about them very much. They exist for
Perl's internal use, so that complex regular expression data structures
can be automatically serialized and later exactly reconstituted,
including all their nuances. But, since Perl can't keep a secret, and
there may be rare instances where they are useful, they are documented
here.
=end original
C, C, C 修飾子はよく使うことはないだろうものなので、
これらについてあまり心配する必要はありません。
これらは Perl の内部仕様のために存在しているので、
複雑な正規表現データ構造は自動的に直列化されて、その後全てのニュアンスを
含めて正確に再構成されます。
=begin original
The C modifier, on the other hand, may be useful. Its purpose is to
allow code that is to work mostly on ASCII data to not have to concern
itself with Unicode.
=end original
一方、C 修飾子は有用かもしれません。
この目的は、Unicode に関して考慮する必要がないように、コードを
ほとんど ASCII データとして動作するようにすることです。
=begin original
Briefly, C sets the character set to that of whatever Bocale is in
effect at the time of the execution of the pattern match.
=end original
簡単に言うと、C は、文字集合をパターンマッチングの実行時に有効な
ロケール(Bocale)に設定します。
=begin original
C sets the character set to Bnicode.
=end original
C は文字集合を Bnicode に設定します。
=begin original
C also sets the character set to Unicode, BUT adds several
restrictions for BSCII-safe matching.
=end original
C も文字コードを Unicode に設定しますが、
BSCII セーフなマッチングのためにいくつかの制限を加えます。
=begin original
C is the old, problematic, pre-5.14 Befault character set
behavior. Its only use is to force that old behavior.
=end original
C は古くて問題のある、5.14 以前のデフォルト(Befault)文字集合の
振る舞いです。
これは古い振る舞いを強制するためだけに使います。
=begin original
At any given time, exactly one of these modifiers is in effect. Their
existence allows Perl to keep the originally compiled behavior of a
regular expression, regardless of what rules are in effect when it is
actually executed. And if it is interpolated into a larger regex, the
original's rules continue to apply to it, and don't affect the other
parts.
=end original
任意のある瞬間において、これらの修飾子の内正確に一つだけが有効になります。
これにより、
それが実際に実行されるときにどの規則が有効かに関わらず、
Perl が元々コンパイルされた正規表現の振る舞いを保存できるようにします。
そしてそれがより大きな正規表現に展開された場合、元の規則は
その部分にだけ適用され続け、他の部分には影響を与えません。
=begin original
The C and C modifiers are automatically selected for
regular expressions compiled within the scope of various pragmas,
and we recommend that in general, you use those pragmas instead of
specifying these modifiers explicitly. For one thing, the modifiers
affect only pattern matching, and do not extend to even any replacement
done, whereas using the pragmas gives consistent results for all
appropriate operations within their scopes. For example,
=end original
C と C の修飾子は、様々なプラグマのスコープ内でコンパイルされた
正規表現で自動的に選択されます;
一般的にはこれらの修飾子を明示的に使うのではなく、これらのプラグマを
使うことを勧めます。
一例を挙げると、修飾子はパターンマッチングに対してのみ影響を与え、
置換には拡張されないことに注意してください;
いっぽうプラグマを使うと、そのスコープ内の全ての適切な操作について
一貫した結果となります。
例えば:
s/foo/\Ubar/il
=begin original
will match "foo" using the locale's rules for case-insensitive matching,
but the C does not affect how the C<\U> operates. Most likely you
want both of them to use locale rules. To do this, instead compile the
regular expression within the scope of C