perlop - Perl の演算子と優先順位
Perl での演算子の優先順位と結合性は多かれ少なかれ数学のものと似ています。
演算子の優先順位 とは、他の演算子より先に評価される演算子が あるということです。 例えば、2 + 4 * 5 の場合、乗算が高い優先順位を持っているので、 4 * 5 が先に評価され、結果は 6 * 5 == 30 ではなく、 2 + 20 == 22 となります。
演算子の結合性 は、同じ演算子が連続して現れた場合に何が起こるかを 定義します: 評価器が左側を先に評価するか右側を先に評価するかです。 例えば、8 - 4 - 2 の場合、減算は左結合なので、Perl は式を左から 右に評価します。 8 - 4 が先に評価されるので、8 - 2 == 6 ではなく 4 - 2 == 2 となります。
Perl の演算子には、以下のような結合性と優先順位 (高い優先順位から 低いものへ並べている) があります。 C から持ってきた演算子の優先順位は、C での優先順位が多少おかしくても、 そのままにしてあります。 (これによって、C を使っている方が Perl に移りやすくなっています。) ごく僅かな例外を別として、全ての演算子はスカラ値のみを持ち、 配列値を持ちません。
左結合 項 リスト演算子 (左方向に対して)
左結合 ->
非結合 ++ --
右結合 **
右結合 ! ~ \ 単項の+ 単項の-
左結合 =~ !~
左結合 * / % x
左結合 + - .
左結合 << >>
非結合 名前付き単項演算子
非結合 < > <= >= lt gt le ge
非結合 == != <=> eq ne cmp ~~
左結合 &
左結合 | ^
左結合 &&
左結合 || //
非結合 .. ...
右結合 ?:
右結合 = += -= *= などの代入演算子
左結合 , =>
非結合 リスト演算子 (右方向に対して)
右結合 not
左結合 and
左結合 or xor以下の章では、演算子は優先順位の順に記述されています。
多くの演算子はオブジェクトでオーバーロードできます。 overload を参照して下さい。
「項」は Perl でもっとも優先順位が高いものです。 これには、変数、クォートとクォート的な演算子、括弧で括った任意の式、 引数を括弧で括った任意の関数が含まれます。 実際には、この意味では本当の関数はなく、リスト演算子と関数のように働く 単項演算子が、引数を括弧で括るためそのように見えます。 これらはすべて perlfunc に記述しています。
もし、リスト演算子 (print() など) や単項演算子 (chdir() など)の 名前の後に開き括弧が続く場合には、その演算子と括弧内の引数は、 通常の関数呼び出しのように、もっとも高い優先順位で処理されます。
括弧が無い場合には、print、sort、chmod のようなリスト演算子の 優先順位は、演算子の左側をからすると非常に高く、右側からすると 非常に低く見えます。たとえば、
@ary = (1, 3, sort 4, 2);
print @ary; # prints 1324では、sort の右のコンマは sort よりも前に評価されます (右側から見ると sort の優先順位が低い) が、左側のコンマは sort のあとに評価されます (左側から見ると sort の方が優先順位が高くなっている)。 言い方を変えると、リスト演算子は自分の後にある引数をすべて使って処理を行ない、 その結果を自分の前の式に対する「項」であるかのように見せるということです。 ただし、括弧には気を付けないといけません:
# 以下は print を行なう前に exit を評価します:
print($foo, exit); # 明らかにやりたいことではないでしょう。
print $foo, exit; # これでもない。
# 以下は exit を評価する前に print を行ないます:
(print $foo), exit; # これがしたかった。
print($foo), exit; # これでもいい。
print ($foo), exit; # これも OK。また、
print ($foo & 255) + 1, "\n";の動作を一目見ただけで判断するのは、難しいでしょう。 かっこは print のために評価される引数リストを囲っています ($foo & 255 の結果が表示されます)。 それから print の返り値 (通常は 1) に 1 が加えられます。 結果は以下のようになります:
1 + 1, "\n"; # Obviously not what you meant.意味したいことを適切に行うには、以下のように書く必要があります:
print(($foo & 255) + 1, "\n");詳しくは、"Named Unary Operators" を参照してください。
この他に「項」として解析されるものには、do {} や eval {} の 構成、サブルーティンやメソッドの呼び出し、無名のコンストラクタ [] と {} があります。
後の方の"Quote and Quote-like Operators"や "I/O Operators"も参照してください。
C や C++ と同じように "->" は中置の被参照演算子です。 右側が [...], {...}, (...) のいずれかの形の添字であれば、左側は配列、ハッシュ、 サブルーチンへのハードリファレンスかシンボリックリファレンス (あるいは 技術的には、配列またはハードリファレンスが代入可能であれば ハードリファレンスを保持できる場所) でなければなりません。perlreftut と perlref を参照してください。
そうでなければ、右側はメソッド名かサブルーチンのリファレンスを持った 単純スカラ変数で、左側はオブジェクト (bless されたリファレンス) か クラス名でなければなりません。 perlobj を参照してください。
"++" と "--" は、C の場合と同じように動作します。 つまり、変数の前に置かれれば、値を返す前に変数を 1 インクリメントまたは デクリメントし、後に置かれれば、値を返した後で変数を インクリメントまたはデクリメントします。
$i = 0; $j = 0;
print $i++; # prints 0
print ++$j; # prints 1C と同様、Perl は いつ 変数がインクリメントまたはデクリメントされるかは 定義されません。 値が返される前か後のどこかで行われる、ということだけがわかります。 これは、同じ文である変数を 2 回修正すると、振る舞いが未定義になることを 意味します。 以下のような文は避けてください:
$i = $i ++;
print ++ $i + $i ++;Perl は上記の文の結果について保障しません。
インクリメント演算子には、ちょっと風変わりな機能が組み込まれています。 数値が入った変数や、数値の文脈で使われてきた変数を インクリメントする場合には、通常のインクリメントとして動作します。 しかし、その変数が設定されてからずっと文字列の文脈で しか使われていなくて、空文字列でなく、 /^[a-zA-Z]*[0-9]*\z/ にマッチする 値を持っているときには、個々の文字の範囲を保ちながら桁あげを行なって、 文字列としてインクリメントが行なわれます (マジカルインクリメントと呼ばれます):
print ++($foo = '99'); # prints '100'
print ++($foo = 'a0'); # prints 'a1'
print ++($foo = 'Az'); # prints 'Ba'
print ++($foo = 'zz'); # prints 'aaa'undef は常に数値として扱われ、特にインクリメントされる前には 0 に 変換されます(従って、undef のポストインクリメント値は undef ではなく 0 になります)。
デクリメント演算子には、マジカルなものはありません。
二項演算子の "**" は指数演算子です。 この演算子は、単項のマイナスよりも結合が強い演算子で、 -2**4 は (-2)**4 ではなく、-(2**4) と解釈されます。 (これは C の pow(3) を使って実装されていますので、 内部的には double で動作します。)
単項演算子の "!" は論理否定を行ないます。 つまり 「not」 ということです。 この演算子の優先順位を低くしたものとして、not が用意されています。
単項演算子の "-" は被演算子が数値であれば、算術否定を行ないます。 被演算子が識別子ならば、マイナス記号にその識別子をつなげた 文字列が返されます。 これ以外で被演算子の最初の文字がプラスかマイナスのときには、 その記号を逆のものに置き換えた文字列を返します。 この規則の結果、-bareword が文字列 "-bareword" に等価となります。 しかし、文字列が英字以外("+" と "-" を除く)で始まっていると、 Perl は文字列を数値に変換しようとし、それから算術否定が実行されます。 もし文字列が明確に数値に変換できない場合、Perl は Argument "the string" isn't numeric in negation (-) at ... という 警告を出します。
単項演算子の "~" はビットごとの否定を行ないます。 つまり、1 の補数を返します。 例えば、0666 & ~027 は 0640 です。 ("Integer Arithmetic" と "Bitwise String Operators" も参照して下さい。) 結果の幅はプラットホーム依存であることに注意してください。 ~0 は 32-bit プラットホームでは 32 ビット幅ですが、 64-bit プラットホームでは 64 ビット幅ですので、 特定のビット幅を仮定する場合は、 余分なビットをマスクするために & 演算子を使うことを忘れないでください。
単項演算子の "+" は、たとえ文字列に対して用いられた場合にも、何もしません。 関数名に続けて括弧付きの式を書く場合に、関数の引数リストと 解釈されないようにするために用いることができます。 (下記 Terms and List Operators (Leftward) の例を参照してください。)
単項演算子の "\" はその後に続くものへのリファレンスを生成します。 perlreftut と perlref を参照してください。 この用法も文字列中のバックスラッシュも、後に続くものが展開されるのを 防ぐことになりますが、動作を混同しないでください。
二項演算子の "=~" は、スカラ式をパターンマッチに拘束します。 デフォルトで $_ の文字列を検索したり、変更したりする演算があります。 この演算子は、そのような演算を他の文字列に対して行なわせるようにするものです。 右引数は、検索パターン、置換、文字変換のいずれかです。 左引数は、デフォルトの $_ の代わりに検索、置換、文字変換の対象となるものです。 スカラコンテキストで使うと、返り値は一般的に演算の結果が成功したか否かです。 リストコンテキストでの振る舞いは演算子に依存します。 詳しくは "Regexp Quote-Like Operators" を、これらの演算子を使った 例については perlretut を参照して下さい。
右引数が検索パターン、置換、文字変換ではなく、式であれば、 それは実行時に決まる検索パターンと解釈されます。 これは、内容が 2 回展開されることを意味することに注意してください; つまり:
'\\' =~ q'\\';は正しくありません; 正規表現エンジンは最終的にパターン \ を コンパイルしようとして、これは文法エラーと考えるからです。
二項演算子の "!~" は、返される値が論理否定されることを除いて "=~" と同じです。
二項演算子の "*" は 2 つの数値の積を返します。
二項演算子の "/" は 2 つの数値の商を返します。
二項演算子の "%" は剰余演算子で、一つ目の引数を二つ目の引数で割ったときの 余りを返します。 $a と $b の二つの整数の被演算子を取ったとすると: $b が正の場合、$a % $b は、$a から $a 以下の最大の $b の倍数を引いた値です。 $b が負の場合、$a % $b は、$a から $a を下回らない 最小の $b の倍数を引いた値です。(従って結果はゼロ以下になります。) オペランド $a と $b が浮動小数点数で、$b の絶対値 (つまり abs($b)) が (UV_MAX + 1) より小さい場合、 $a と $b の整数部のみが操作で使われます (注意: ここで UV_MAX は符号なし整数の最大値を意味します)。 右オペランドの絶対値 (abs($b)) が (UV_MAX + 1) 以上の場合、 "%" は、($r = $a - $i*$b) となる浮動小数点剰余 $r を計算します; ここで $i は、$r が右オペランド $b と同じ符号 (C の 関数 fmod() のように左オペランド $a ではありません) で、 絶対値が $b より小さいものになるような、ある整数です。 use integer がスコープ内にある場合、 "%" は C コンパイラで実装された剰余演算子を使います。 この演算子は被演算子が負の場合の挙動が不確実ですが、 より高速です。
二項演算子の "x" は繰り返し演算子です。 スカラコンテキストまたは左辺値が括弧で括られていない場合は、 左被演算子を右被演算子に示す数だけ繰り返したもので構成される 文字列を返します。 リストコンテキストでは、左被演算子が括弧で括られているか、qw/STRING の 形のリストの場合、リストを繰り返します。 右オペランドが 0 か負数の場合、コンテキストによって、空文字列か空リストを 返します。
print '-' x 80; # print row of dashes
print "\t" x ($tab/8), ' ' x ($tab%8); # tab over
@ones = (1) x 80; # a list of 80 1's
@ones = (5) x @ones; # set all elements to 5二項演算子の "+" は 2 つの数値の和を返します。
二項演算子の "-" は 2 つの数値の差を返します。
二項演算子の "." は 2 つの文字列を連結します。
二項演算子の "<<" は左引数の値を、右引数で示すビット数だけ、 左にシフトした値を返します。 引数は整数でなければなりません。 ("Integer Arithmetic" も参照して下さい。)
二項演算子の ">>" は左引数の値を、右引数で示すビット数だけ、 右にシフトした値を返します。 引数は整数でなければなりません。 ("Integer Arithmetic" も参照して下さい。)
Perl での "<<" と ">>" は C での "<<" と ">>" を直接利用して 実装されていることに注意してください。 use integer ("Integer Arithmetic" を参照してください)が有効な場合、 C の符号付き整数が使われ、そうでない場合は C の符号なし整数が使われます。 どちらの場合も、この実装は Perl がビルドされた整数型のサイズ(32 ビットか 64 ビット)よりも大きい結果を生成することはありません。
整数の範囲をオーバーフローした場合の結果は、C でも未定義なので、未定義です。 言い換えると、32 ビット整数を使っているとき、1 << 32 は未定義です。 シフトするビット数として負の数を指定した場合も未定義です。
さまざまな名前付き単項演算子が、引数を 1 つ持ち、括弧が省略可能な、 関数として扱われます。
リスト演算子 (print() など) や単項演算子 (chdir() など) は、 すべて次のトークンとして開き括弧が続くと、その演算子と括弧内の引数は、 通常の関数呼び出しのようにもっとも高い優先順位として扱われます。 たとえば、名前つき単項演算子は || より優先順位が高いので、 以下のようになります:
chdir $foo || die; # (chdir $foo) || die
chdir($foo) || die; # (chdir $foo) || die
chdir ($foo) || die; # (chdir $foo) || die
chdir +($foo) || die; # (chdir $foo) || dieしかし * は名前つき演算子より優先順位が高いので、以下のようになります:
chdir $foo * 20; # chdir ($foo * 20)
chdir($foo) * 20; # (chdir $foo) * 20
chdir ($foo) * 20; # (chdir $foo) * 20
chdir +($foo) * 20; # chdir ($foo * 20)
rand 10 * 20; # rand (10 * 20)
rand(10) * 20; # (rand 10) * 20
rand (10) * 20; # (rand 10) * 20
rand +(10) * 20; # rand (10 * 20)優先順位に関して、-f や -M のようなファイルテスト演算子は、名前付き 単項演算子として扱われますが、この関数のかっこルールは適用されません。 これは、例えば -f($file).".bak" は -f "$file.bak" と等価であることを 意味します。
"Terms and List Operators (Leftward)" も参照して下さい。
二項演算子の "<" は左引数が数値的に右引数よりも小さければ、 真を返します。
二項演算子の ">" は左引数が数値的に右引数よりも大きければ、 真を返します。
二項演算子の "<=" は左引数が数値的に右引数よりも小さいか等しければ、 真を返します。
二項演算子の ">=" は左引数が数値的に右引数よりも大きいか等しければ、 真を返します。
二項演算子の "lt" は左引数が文字列的に右引数よりも小さければ、 真を返します。
二項演算子の "gt" は左引数が文字列的に右引数よりも大きければ、 真を返します。
二項演算子の "le" は左引数が文字列的に右引数よりも小さいか等しければ、 真を返します。
二項演算子の "ge" は左引数が文字列的に右引数よりも大きいか等しければ、 真を返します。
二項演算子の "==" は左引数が数値的に右引数と等しければ、 真を返します。
二項演算子の "!=" は左引数が数値的に右引数と等しくなければ、 真を返します。
二項演算子の "<=>" は左引数が数値的に右引数より小さいか、等しいか、 大きいかに従って、-1, 0, 1 を返します。 数値として NaN (非数) に対応しているプラットフォームでは、 NaN に対して "<=>" を使うと undef を返します。 NaN はどの値に対しても(NaN に対してでさえも) "<", "==", ">", "<=", ">=" のいずれも成立しないので、これらは全て偽となります。 NaN != NaN は真を返しますが、その他のどの値に対しても != は偽を返します。 NaN に対応していないプラットフォームでは、NaN は単に数としての値 0 を持つ 文字列です。
perl -le '$a = "NaN"; print "No NaN support here" if $a == $a'
perl -le '$a = "NaN"; print "NaN support here" if $a != $a'二項演算子の "eq" は左引数が文字列的に右引数と等しければ、 真を返します。
二項演算子の "ne" は左引数が文字列的に右引数と等しくなければ、 真を返します。
二項演算子の "cmp" は左引数が文字列的に右引数より小さいか、 等しいか、大きいかに従って、-1, 0, 1 を返します。
二項演算子の "~~" はスマートマッチングとして働きます。 スマートマッチングについては "Smart matching in detail" in perlsyn で 述べられています。
"lt", "le", "ge", "gt", "cmp" は use locale が有効な場合は 現在のロケールで指定された辞書(ソート)順が使われます。 perllocale を参照して下さい。
二項演算子の "&" は、両オペランドのビットごとに論理積をとって、 その結果を返します。 ("Integer Arithmetic" と "Bitwise String Operators" も参照して下さい。)
"&" は関係演算子より優先順位が低いので、例えば以下のようなテストでは、 かっこが重要です:
print "Even\n" if ($x & 1) == 0;二項演算子の "|" は、両オペランドのビットごとに論理和をとって、 その結果を返します。 ("Integer Arithmetic" と "Bitwise String Operators" も参照して下さい。)
二項演算子の "^" は、両オペランドのビットごとに排他論理和をとって、 その結果を返します。 ("Integer Arithmetic" と "Bitwise String Operators" も参照して下さい。)
"|" と "^" は関係演算子より優先順位が低いので、例えば以下のような テストでは、かっこが重要です:
print "false\n" if (8 | 2) != 10;二項演算子の "&&" は、短絡の論理積演算を行ないます。 つまり、左被演算子が偽であれば、右被演算子は評価さえ 行なわれないということです。 評価される場合には、スカラーかリストかというコンテキストは、 右被演算子にも及びます。
二項演算子の "||" は、短絡の論理和演算を行ないます。 つまり、左被演算子が真であれば、右被演算子は評価さえ 行なわれないということです。 評価される場合には、スカラーかリストかというコンテキストは、 右被演算子にも及びます。
C では直接等価なものはありませんが、Perl の // 演算子は C スタイル 論理和に関連しています。 実際、左辺の真偽ではなく定義されているかを判定することを除けば || と同じです。 したがって $a // $b は defined($a) || $b と似ていて (ただし、 defined($a) ではなく $a の値を返します)、defined($a) ? $a : $b と 完全に等価です。 これは、変数に対するデフォルト値を設定するのにとても有用です。 実際に、$a と $b の少なくとも片方が定義されているかを判定したいなら、 defined($a // $b) を使ってください。
||, //, && 演算子は、(C のように 単に 0 や 1 を返すのではなく) 最後に評価された値を返します。 これにより、かなり一般的に使えるホームディレクトリを探す方法は:
$home = $ENV{'HOME'} // $ENV{'LOGDIR'} //
(getpwuid($<))[7] // die "You're homeless!\n";特に、これは代入のために二つの集合を選択するためには 使うべきではないことを意味します。
@a = @b || @c; # this is wrong
@a = scalar(@b) || @c; # really meant this
@a = @b ? @b : @c; # this works fine, thoughPerl では、フロー制御に使う場合の多少読みやすい && と || の 同義語として、and 演算子と or 演算子が用意されています (下記参照)。 短絡の動作は全く同じです。 しかし、"and" と "or" の優先順位はかなり低くしてあるので、引数に括弧を 使っていないリスト演算子のあとに続けて使う場合にも、 安心して使うことができます:
unlink "alpha", "beta", "gamma"
or gripe(), next LINE;C スタイルの演算子では以下のように書く必要があります。
unlink("alpha", "beta", "gamma")
|| (gripe(), next LINE);代入で "or" を使うと、したいことと違うことになります。 以下を参照して下さい。
二項演算子の ".." は範囲演算子で、使われるコンテキストによって 異なる動作をする 2 つの演算子を合わせたものです。 リストコンテキストでは、左の値から右の値まで (1 づつ昇順で) 数えあげた値から なるリストを返します。 左側の値が右側の値より大きい場合は、空リストを返します。 範囲演算子は、foreach (1..10) のようなループを書くときや、 配列のスライス演算を行なうときに便利です。 現状の実装では、foreach ループの式の中で範囲演算子を使っても 一時配列は作りませんが、古い Perl は以下のようなことを書くと、 大量のメモリを消費することになります:
for (1 .. 1_000_000) {
# code
}範囲演算子は、マジカル自動インクリメントを使うことで文字列でも動作します。 以下を参照してください。
スカラコンテキストで使われたときには、".." は真偽値を返します。 この演算子は、フリップフロップのように 2 値安定で、 sed や awk や多くのエディタでの行範囲 (コンマ) 演算子を エミュレートするものとなります。 各々の ".." 演算子は、例えそれを含むサブルーチンの呼び出しを またいでも、それぞれに独立して自分の真偽状態を管理します。 はじめは、左被演算子が偽である間、演算全体も偽となっています。 範囲演算子は、いったん左被演算子が真になると、右被演算子が真である間、 真を返すようになります。 右被演算子が偽になると、演算子も偽を返すようになります。 (次に範囲演算子が評価されるまでは、偽とはなりません。 (awk でのように) 真となった、その評価の中で右被演算子をテストし、 偽とすることができますが、1 度は真を返すことになります。 sed でのように、次に評価されるまで右被演算子をテストしたくなければ、 2 個のドットの代わりに 3 つのドット ("...") を使ってください。 その他の点では、"..." は ".." と同様に振舞います．
右被演算子は、演算子の状態が「偽」である間は評価されることがなく、 左被演算子は、演算子の状態が「真」である間は評価されることがありません。 優先順位は、|| と && の少し下です。 偽としては空文字列が返され、 真としては (1 から始まる) 順に並んだ数値が返されます。 この通し番号は、新たに範囲が始まるごとにリセットされます。 範囲の最後の数字には、文字列 "E0" が末尾につけられます。 これは、数値としては何の影響もありませんが、範囲の終わりで何か特別なことを したい場合に、目印として使うことができます。 範囲の始まりで何かしたい場合には、通し番号が 1 よりも大きくなるのを 待っていればよいでしょう。
スカラの ".." の被演算子が定数表現であるときは、その被演算子は暗黙に、 現在の入力行番号(変数 $.) と等しい(==) 場合に真となります。
とても細かい話をすると、比較は実際には int(EXPR) == int(EXPR) ですが、 これは浮動小数点数を使うときにだけ問題になります; 前の段落で記述したように 明示的に $. を使ったとき、比較は int(EXPR) == int($.) となり、 $. に浮動小数点数がセットされ、ファイルから読み込みを行わない場合にのみ 問題になります。 さらに、"span" .. "spat" や 2.18 .. 3.14 は、それぞれのオペランドが 整数表現を使って評価されるため、スカラコンテキストでは望みどおりの結果に なりません。
例:
スカラ演算子として:
if (101 .. 200) { print; } # print 2nd hundred lines, short for
# if ($. == 101 .. $. == 200) { print; }
next LINE if (1 .. /^$/); # skip header lines, short for
# next LINE if ($. == 1 .. /^$/);
# (typically in a loop labeled LINE)
s/^/> / if (/^$/ .. eof()); # quote body
# parse mail messages
while (<>) {
$in_header = 1 .. /^$/;
$in_body = /^$/ .. eof;
if ($in_header) {
# do something
} else { # in body
# do something else
}
} continue {
close ARGV if eof; # reset $. each file
}以下は二つの範囲演算子の違いを示す単純な例です:
@lines = (" - Foo",
"01 - Bar",
"1 - Baz",
" - Quux");
foreach (@lines) {
if (/0/ .. /1/) {
print "$_\n";
}
}このプログラムは "Bar" を含む行だけを表示します。 範囲演算子を ... に変更すると、"Baz" の行も表示します。
これはリスト演算子の例です:
for (101 .. 200) { print; } # print $_ 100 times
@foo = @foo[0 .. $#foo]; # an expensive no-op
@foo = @foo[$#foo-4 .. $#foo]; # slice last 5 items(リストコンテキストでの) 範囲演算子は、被演算子が文字列であるときには、 マジカルインクリメントの機能を使います。 以下のように書くと:
@alphabet = ('A' .. 'Z');英語の大文字すべてを得られますし:
$hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15];と書けば、16 進の数字が得られますし、
@z2 = ('01' .. '31'); print $z2[$mday];とすれば、0 付きの日付が得られます。
マジカルインクリメントによって得られる値の中に指定した最終値に ちょうど一致するものが見つからないような場合には、 マジカルインクリメントによって得られる次の値の文字列長が、 最終値として指定した値のものより長くなるまでインクリメントが続けられます。
指定された初期値がマジカルインクリメント処理の一部でない場合 (つまり、"/^[a-zA-Z]*[0-9]*\z/" にマッチングする、空でない文字列の場合)、 初期値のみが返されます。 従って、以下はαのみを返します:
use charnames 'greek';
my @greek_small = ("\N{alpha}" .. "\N{omega}");小文字のギリシャ文字を得るためには、代わりに以下のようにしてください:
my @greek_small = map { chr } ( ord("\N{alpha}") .. ord("\N{omega}") );それぞれのオペランドは整数の形で評価されるので、2.18 .. 3.14 は リストコンテキストでは二つの要素を返します。
@list = (2.18 .. 3.14); # same as @list = (2 .. 3);三項演算子の "?:" は、C の場合と同じ条件演算子です。 これは、if-then-else のように働きます。 "?" の前の引数が真であれば ":" の前の引数が返されますが、 真でなければ、":" の後の引数が返されます。 例えば:
printf "I have %d dog%s.\n", $n,
($n == 1) ? '' : "s";スカラコンテキストかリストコンテキストかという状況は、 選択された 2 番目もしくは 3 番目の引数にまで伝わります。
$a = $ok ? $b : $c; # get a scalar
@a = $ok ? @b : @c; # get an array
$a = $ok ? @b : @c; # oops, that's just a count!2 番目と 3 番目の引数双方が左辺値 (代入可能ということ)であれば、 この演算子に代入を行なうこともできます:
($a_or_b ? $a : $b) = $c;この演算子は代入可能な結果を生み出すので、 括弧なしで代入を行うとおかしくなるかもしれません。 例えばこれは:
$a % 2 ? $a += 10 : $a += 2以下を意味し:
(($a % 2) ? ($a += 10) : $a) += 2以下のようにはなりません:
($a % 2) ? ($a += 10) : ($a += 2)恐らく以下のようにもっと単純に書くべきでしょう:
$a += ($a % 2) ? 10 : 2;"=" は通常の代入演算子です。
代入演算子は C の場合と同様の働きをします。 つまり、
$a += 2;は以下と等価です:
$a = $a + 2;しかし、tie() のようなもので起こる左辺値の被参照による 副作用が 2 回起こることはありません。 他の代入演算も同様に働きます。 以下のものが認識されます:
**= += *= &= <<= &&=
-= /= |= >>= ||=
.= %= ^= //=
x=グループ分けしてありますが、これらはいずれも代入演算子として 同じ優先順位となっています。
C と違って、スカラ代入演算子は有効な左辺値を作り出します。 代入を修正することは、代入を行なってから、その代入された変数を修正するのと 同じことになります。 これは、以下のように何かのコピーを変更したいときに便利です:
($tmp = $global) =~ tr [A-Z] [a-z];同様に、
($a += 2) *= 3;は以下と等価です:
$a += 2;
$a *= 3;同様に、リストコンテキストでのリストへの代入は代入可能な左辺値のリストとなり、 スカラコンテキストでのリストへの代入は代入の右側の式で作成された 要素の数を返します。
二項演算子の "," はコンマ演算子です。 スカラコンテキストではその左引数を評価し、その値を捨てて、 それから右引数を評価し、その値を返します。 これはちょうど、C のコンマ演算子と同じです。
リストコンテキストでは、これは単にリスト引数の区切り文字で、 双方の引数をそのリストに挿入する働きがあります。 これらの引数も左から右に評価されます。
=> 演算子はコンマ演算子の同義語ですが、 もし左オペランドが文字か下線で始まっていて、かつ文字、数字、下線でのみ 構成されている場合、これを文字列として扱うという効果もあります。 これには他の場所では演算子、定数、v-文字列、関数呼び出しとして扱われる オペランドを含みます。 この振る舞いについて迷うことがあるなら、左オペランドを明示的に クォートすることも出来ます。
さもなければ、=> 演算子はコンテキストによって、 カンマ演算子かリスト引数の区切り文字と全く同様に振る舞います。
例えば:
use constant FOO => "something";
my %h = ( FOO => 23 );は、以下と等価です:
my %h = ("FOO", 23);これは 違います:
my %h = ("something", 23);=> 演算子は、ハッシュのキーと値や、その他のリスト中の組となる 要素の関係を表現するのに便利です。
%hash = ( $key => $value );
login( $username => $password );(... と書く) ヤダヤダ演算子はコードのためのプレースホルダです。 Perl はこれをエラーを出すことなくパースしますが、ヤダヤダを 実行しようとすると、Unimplemented の文章と共に例外を発生させます:
sub unimplemented { ... }
eval { unimplemented() };
if( $@ eq 'Unimplemented' ) {
print "I found the yada yada!\n";
}ヤダヤダは完全な文の代わりにのみ使えます。 以下の例のヤダヤダは動作します:
{ ... }
sub foo { ... }
...;
eval { ... };
sub foo {
my( $self ) = shift;
...;
}
do { my $n; ...; print 'Hurrah!' };... は範囲演算子("Range Operators" を参照してください)の 3 ドット版でも あるので、より大きな文の一部の式としては使えません。 以下の例のヤダヤダは文法エラーになります:
print ...;
open my($fh), '>', '/dev/passwd' or ...;
if( $condition && ... ) { print "Hello\n" };式と文との違いをすぐに説明できない場合があります。 例えば、ブロックと無名ハッシュリファレンスのコンストラクタは、 Perl にヒントを与える中かっこがなければ同じに見えます。 ヤダヤダは Perl が { ... } をブロックと判断できなかった場合は 文法エラーとなります。 この場合、文ではなく式と推測するので、... はヤダヤダとは 判断されません:
my @transformed = map { ... } @input; # syntax error{ ... } がブロックであって、ハッシュリファレンスのコンストラクタでは ないことを示すためにブロックの中で ; を使えます。 これでヤダヤダは動作します:
my @transformed = map {; ... } @input; # ; disambiguates
my @transformed = map { ...; } @input; # ; disambiguatesリスト演算子の右側のものにとって、リスト演算子はとても低い優先順位になります。 これによってコンマで区切った式をリスト演算子の引数として 置くことができます。 これよりも優先順位が低いものは、論理演算子の "and", "or", "not" のみで、 余分な括弧を付けないリスト演算子の呼び出しを評価するために使えます:
open HANDLE, "filename"
or die "Can't open: $!\n";Terms and List Operators (Leftward) のリスト演算子の議論も参照して下さい。
単項演算子の "not" は右側に来る式の否定を返します。 これは、優先順位がずっと低いことを除いては "!" と等価です。
二項演算子の "and" は両側の式の論理積を返します。 これは、優先順位がずっと低いことを除けば && と等価です。 つまり、これも短絡演算を行ない、右側の式は左側の式が 「真」であった場合にのみ評価されます。
二項演算子の "or" は両側の式の論理和を返します。 これは、優先順位がずっと低いことを除いて || と等価です。 これはフローを制御するのに有用です:
print FH $data or die "Can't write to FH: $!";つまり、これも短絡演算を行ない、右側の式は左側の式が 「偽」であった場合にのみ評価されます。 優先度の関係で、これは代入には使わず、フローの制御のみに使うべきです。
$a = $b or $c; # bug: this is wrong
($a = $b) or $c; # really means this
$a = $b || $c; # better written this wayしかし、代入がリストコンテキストの時に "||" をフロー制御に使おうとする場合、 代入により大きな優先順位を持たせるために "or" が必要かもしれません。
@info = stat($file) || die; # oops, scalar sense of stat!
@info = stat($file) or die; # better, now @info gets its dueもちろん、常に括弧をつけてもよいです。
二項演算子の "xor" は両側の式の排他論理和を返します。 これはもちろん、短絡ではありません。
C にあって Perl に無いものは以下の通りです:
アドレス演算子。 ("\" 演算子がリファレンスのために用いられます。)
被アドレス参照演算子。 (Perl の被参照プリフィクス演算子が型づけを行ないます: $, @, %, &。)
型のキャスト演算子。
クォートはリテラル値であると考えるのが普通ですが、Perl において、 クォートは演算子として働き、さまざまな展開やパターンマッチの機能を 持っています。 そのような動作をさせるのに、Perl は慣習的にクォート文字を使っていますが、 どの種類のクォートも、自分でクォート文字を選べるようになっています。 以下の表では、{} がその選んだ区切文字のペアを示しています。
通常記法 汎用記法 意味 展開
=================================================
'' q{} リテラル 不可
"" qq{} リテラル 可
`` qx{} コマンド 可 *
qw{} 単語リスト 不可
// m{} パターンマッチ 可 *
qr{} パターン 可 *
s{}{} 置換 可 *
tr{}{} 変換 不可 (但し以下を参照のこと)
<<EOF ヒアドキュメント 可 * * '' がデリミタでない場合のみ選んだ区切文字が括弧の類でない場合には、前後の文字として同一のものを 使いますが、4 つの括弧 ((), <>, [], {}) の場合にはネストできます。 つまり、以下のものは、
q{foo{bar}baz}以下と同じです。
'foo{bar}baz'しかし、以下のコードはクォートされた Perl コードでは いつも正しく動くわけではないことに注意してください:
$s = q{ if($a eq "}") ... }; # WRONGこれは文法エラーとなります。 Text::Balanced モジュール(CPAN から、または Perl 5.8 からは標準配布の 一部です)はこれを適切に行います。
演算子とクォート文字の間に空白を置くことも出来ます。 ただし、# をクォート文字として使う場合は例外です。 q#foo# は文字列 foo としてパースされますが、 q #foo# は q 演算子の後にコメントがあるとみなされます。 この引数は次の行から取られます。つまり、以下のように書けます:
s {foo} # Replace foo
{bar} # with bar.以下のエスケープシーケンスが展開と文字変換の構文で利用可能です。
\t タブ (HT, TAB)
\n 改行 (NL)
\r 復帰 (CR)
\f 改ページ (FF)
\b バックスペース (BS)
\a アラーム (BEL)
\e エスケープ (ESC)
\033 8 進数で表した文字 (例: ESC)
\x1b 16 進数で表した文字 (例: ESC)
\x{263a} 16 進数で表したワイド文字 (例: SMILEY)
\c[ コントロール文字 (例: ESC)
\N{name} 名前つき Unicode 文字
\N{U+263D} Unicode 文字 (例: FIRST QUARTER MOON)\c に引き続く文字は、英字は大文字に変換された後、(ASCII システムでは) 7 番目のビット (0x40) を反転させることで別の文字にマッピングされます。 最も興味深い範囲は '@' から '_' (0x40 から 0x5F) で、結果として コントロール文字 0x00 から 0x1F になります。 '?' は DEL 文字にマッピングされます。 EBCDIC システムでは '@', 英字, '[', '\', ']', '^', '_', '?' のみが 動作し、結果として 0x00 から 0x1F と 0x7F になります。
\N{U+wide hex char} は、Unicode 番号が wide hex char の Unicode 文字を意味します。 \N{name} の文書に関しては、charnames を参照して下さい。
注意: C やその他の言語と違って、Perl は垂直タブ (VT - ASCII 11) のための \v エスケープシーケンスはありませんが、\ck または \x0b が使えます。 (\v は Perl の正規表現パターンでは意味があります; perlre を 参照してください。)
以下のエスケープシーケンスが展開と文字変換の構文で利用可能です。
\l 次の文字を小文字にする
\u 次の文字を大文字にする
\L \E まで小文字にする
\U \E まで大文字にする
\E 変更の終わり
\Q \E まで非単語文字をクォートするuse locale が有効の場合、\l, \L, \u, \U で使われる 大文字小文字テーブルは現在のロケールのものが使われます。 perllocale を参照して下さい。 (例えば、\N{} や、0x100 以上のワイド 16 進文字を使った) Unicode が 使われている場合、\l, \L, \u, \U で使われる大文字小文字 テーブルは Unicode で定義されているものになります。
全てのシステムでは "newline" と呼ばれる行端末子を表現するために 仮想的な "\n" が用いられます。 普遍の、物理的な "newline" 文字と言うものはありません。 オペレーティングシステム、デバイスドライバ、C ライブラリ、Perl が全て 協力して保存しようとすると言うのは単なる幻想です。 全てのシステムで "\r" を ASCII CR として、また "\n" を ASCII LF として読み込むわけではありません。 例えば Mac ではこれらは保存され、行端末子のないシステムでは、 "\n" を print しても実際のデータは何も出力しません。 一般に、システムで "newline" を意味したいときには "\n" を使いますが、 正確な文字が必要な場合はリテラルな ASCII を使います。 例えば、ほとんどのネットワークプロトコルでは行端末子として CR+LF ("\015\012" または "\cM\cJ") を予想し、また好みますが、 しばしば "\012" だけでも許容し、さらに時々は "\015" だけでも認めます。 もしネットワーク関係で "\n" を使う習慣がついていると、 いつか痛い目を見ることになるでしょう。
展開が行なわれる構文では、"$" や "@" で始まる変数が展開されます。 $a[3] や $href->{key}[0] のような添え字付き変数もまた 配列やハッシュのスライスのように展開されます。 しかし、$obj->meth のようなメソッド呼び出しは展開されません。
配列やスライスの展開は、要素を順番に、$" の値で分割して展開されるので、 join $", @array の展開と等価です。 @* のような「句読点」配列は名前が @{*} のように中かっこで囲われている 場合にのみ展開されますが、特殊配列 @_, @+, @- は中かっこなしでも 展開されます。
\Q シーケンスの中にリテラルな $ や @ を入れることはできません。 エスケープされない $ や @ は対応する変数に変換されます。 一方、エスケープすると、リテラルな文字列 \$ が挿入されます。 m/\Quser\E\@\Qhost/ などという風に書く必要があります。
パターンはさらに、正規表現として展開が行なわれます。 これは、変数が展開された後の 2 回目のパスで行なわれるので、変数に 正規表現を含めておき、パターンの中へ展開することができます。 もし、そうしたくないのであれば、\Q を使うと変数の内容を文字通りに 展開することができます。
上記の振る舞いを除けば、Perl は 複数の段階を踏んで展開を行ないません。 特に、シェルのプログラマの期待とは裏腹に、 バッククォートはダブルクォートの中では展開されませんし、シングルクォートが ダブルクォートの中で使われても、変数の展開を妨げることは ありません。
以下はパターンマッチングと関連する行動に関するクォート風の演算子です。
この演算子は STRING を正規表現としてクォートします (そして可能ならコンパイルします)。 STRING は m/PATTERN/ 内の PATTERN と同様に文字変換されます。 "'" がデリミタとして使用された場合、文字変換は行われません。 対応する /STRING/msixpo 表現の代わりに使われた Perl の値を返します。 返り値は元のパターンを正規化したものです。 これは不思議なことに、同じ文字を含む文字列とは異なります: ref(qr/x/) は、結果をデリファレンスすると未定義値を返すにも関わらず、 "Regexp" を返します。
例えば:
$rex = qr/my.STRING/is;
print $rex; # prints (?si-xm:my.STRING)
s/$rex/foo/;は以下と等価です:
s/my.STRING/foo/is;結果はマッチのサブパターンとして使えます:
$re = qr/$pattern/;
$string =~ /foo${re}bar/; # can be interpolated in other patterns
$string =~ $re; # or used standalone
$string =~ /$re/; # or this wayPerl は qr() 演算子を実行する瞬間にパターンをコンパイルするので、 qr() を使うことでいくつかの場面で速度的に有利になります。 特に qr() の結果が独立して使われる場合に有利になります。
sub match {
my $patterns = shift;
my @compiled = map qr/$_/i, @$patterns;
grep {
my $success = 0;
foreach my $pat (@compiled) {
$success = 1, last if /$pat/;
}
$success;
} @_;
}qr() の時点でパターンを内部表現にプリコンパイルすることにより、/$pat/ を 試みる毎に毎回パターンを再コンパイルするのを避けることができます (Perl はその他にも多くの内部最適化を行いますが、上の例で qr() 演算子を 使わなかった場合はどの最適化も行われません)。
オプションは以下の通りです:
m 文字列を複数行として扱う
s 文字列を一行として扱う (. が 改行にマッチングするようにする)
i パターンマッチにおいて大文字小文字を区別しない
x 拡張正規表現を使う
p マッチング時にマッチングした文字列を保存するので、
${^PREMATCH}, ${^MATCH}, ${^POSTMATCH} が定義される
o 一度だけコンパイルするプリコンパイルされたパターンがより大きいパターンに組み込まれている場合、 'msixp' の効果は適切に伝播します。 'o' 修飾子の効果は伝播せず、明示的に使われたパターンに制限されます。
STRING として有効な文法に関する追加の情報と、正規表現の意味論に関する 詳細については、perlre を参照してください。
パターンマッチで文字列検索を行ない、スカラコンテキストでは成功したときは真、 失敗したときは偽を返します。 =~ 演算子か !~ 演算子で検索対象の文字列を示さなかったときには、 $_ の文字列が検索対象となります。 (=~ で指定される文字列は、左辺値である必要はありません。 式を評価した結果でもかまいませんが、=~ の優先順位がいくぶん高いことに 注意してください。) perlre も参照してください。 use locale が有効の場合の議論については perllocale を参照して下さい。
オプションは qr// に記述されています; さらに、以下のマッチング処理 修飾子が利用可能です:
g グローバルにマッチ、つまり、すべてを探し出す
c /g が有効なとき、マッチングに失敗しても検索位置をリセットしない区切文字が "/" のときには、最初の m は付けても付けなくてもかまいません。 m を付けるときには、空白でもない、任意の文字のペアを 区切文字として使うことができます。 これは特に、"/" を含むパス名にパターンマッチングを行なうときに、 LTS (傾斜楊枝症候群) を避けるために便利でしょう。 "?" がデリミタなら、後述する m?PATTERN? にある「一度だけマッチング」 ルールが適用されます。 "'" がデリミタの場合、PATTERN に対する展開は行われません。 識別子として有効な文字を使う場合、m の後に空白が必要です。
PATTERN には、変数が含まれていてもよく、パターンが評価されるごとに、 (デリミタがシングルクォートでない限り)変数は展開され (パターンが再コンパイルされ) ます。 (変数 $(, $), $| は文字列の終わりを調べるパターンであると 解釈されるので、展開されません。) パターンがコンパイルされるのを 1 度だけにしたい場合には、 終わりの区切文字の後に /o 修飾子を付けます。 これにより、実行時に再コンパイルが頻繁に起こることが避けられ、展開する 値がスクリプトの実行中に変化しない場合に有効なものとなります。 しかし、/o を付けることは、パターンの中の変数を変更しないことを 約束するものです。 変更したとしても、Perl がそれに気付くことはありません。 "STRING/msixpo"" in "qr も参照して下さい。
PATTERN を評価した結果が空文字列となった場合には、最後にマッチに 成功した 正規表現が、代わりに使われます。 この場合、空パターンに対して g の c フラグだけが有効です - その他のフラグは元のパターンから取られます。 以前に成功したマッチングがない場合、これは(暗黙に)真の空パターンとして 動作します(つまり常にマッチングします)。
Perl が // (空正規表現) と // (定義性和演算子) を混同する 可能性があることに注意してください。 Perl は普通これをかなりうまく処理しますが、$a/// (($a) / (//) それとも $a // /?) や print $fh // (print $fh(// それとも print($fh //?) のような病的な状況ではこれが起こりえます。 これらの例の全てでは、Perl は定義性和を意味していると仮定します。 もし空正規表現を意味したいなら、あいまいさをなくすために単に かっこや空白を使うか、空正規表現に接頭辞 m を付けてください (つまり // を m// にします)。
/gオプションが使われなかった場合、リストコンテキストでのm//は パターンの中の括弧で括られた部分列にマッチしたもので構成されるリストを 返します。 これは、($1, $2, $3, ...) ということです。 (この場合、$1 なども設定されます。 この点で Perl 4 の動作と違っています。) パターンに括弧がない場合は、返り値は成功時はリスト (1) です。 括弧のあるなしに関わらず、失敗時は空リストを返します。
例:
open(TTY, '/dev/tty');
<TTY> =~ /^y/i && foo(); # do foo if desired
if (/Version: *([0-9.]*)/) { $version = $1; }
next if m#^/usr/spool/uucp#;
# poor man's grep
$arg = shift;
while (<>) {
print if /$arg/o; # compile only once
}
if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))最後の例は、$foo を最初の 2 つの単語と行の残りに分解し、 $F1 と $F2 と $Etc に代入しています。 変数に代入されれば、すなわちパターンがマッチすれば、 if の条件が真となります。
/g 修飾子は、グローバルなパターンマッチを指定するもので、 文字列の中で可能な限りたくさんマッチを行ないます。 この動作は、コンテキストに依存します。 リストコンテキストでは、正規表現内の括弧付けされたものにマッチした 部分文字列のリストが返されます。 括弧がなければ、パターン全体を括弧で括っていたかのように、 すべてのマッチした文字列のリストが返されます。
スカラコンテキストでは、m//g を実行する毎に次のマッチを探します。 マッチした場合は真を返し、もうマッチしなくなったら偽を返します。 最後のマッチの位置は pos() 関数で読み出しや設定ができます。 "pos" in perlfunc を参照して下さい。 マッチに失敗すると通常は検索位置を文字列の先頭にリセットしますが、 /c 修飾子をつける(つまり m//gc)ことでこれを防ぐことができます。 ターゲットとなる文字列が変更された場合も検索位置はリセットされます。
m//g マッチを m/\G.../g と混ぜることもできます。 \G は前回の m//g があればその同じ位置でマッチする ゼロ文字幅のアサートです。 /g 修飾子なしの場合、\G アサートは pos() に固定しますが、 マッチはもちろん一度だけ試されます。 以前に /g マッチを適用していないターゲット文字列に対して /g なしで \G を使うと、文字列の先頭にマッチする \A アサートを使うのと 同じことになります。 \G は現在のところ、パターンのまさに先頭を示す場合にのみ正しく 対応することにも注意してください。
例:
# list context
($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);
# scalar context
$/ = "";
while (defined($paragraph = <>)) {
while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
$sentences++;
}
}
print "$sentences\n";
# using m//gc with \G
$_ = "ppooqppqq";
while ($i++ < 2) {
print "1: '";
print $1 while /(o)/gc; print "', pos=", pos, "\n";
print "2: '";
print $1 if /\G(q)/gc; print "', pos=", pos, "\n";
print "3: '";
print $1 while /(p)/gc; print "', pos=", pos, "\n";
}
print "Final: '$1', pos=",pos,"\n" if /\G(.)/;最後のものは以下のものを表示するはずです:
1: 'oo', pos=4
2: 'q', pos=5
3: 'pp', pos=7
1: '', pos=7
2: 'q', pos=8
3: '', pos=8
Final: 'q', pos=8\G なしでのマッチが行われたため、最後のマッチでは p ではなく q がマッチすることに注意してください。 また、最後のマッチは pos を更新しないことに注意してください。 pos は /g マッチでのみ更新されます。 もし最後のマッチで p にマッチした場合、かなりの確率で 古い (5.6.0 以前の) Perl で実行しているはずです。
lex 風にスキャンするために便利な指定は /\G.../gc です。 文字列を部分ごとに処理するためにいくつかの正規表現をつなげて、どの 正規表現にマッチしたかによって異なる処理をすることができます。 それぞれの正規表現は前の正規表現が飛ばした部分に対して マッチを試みます。
$_ = <<'EOL';
$url = URI::URL->new( "http://example.com/" ); die if $url eq "xXx";
EOL
LOOP:
{
print(" digits"), redo LOOP if /\G\d+\b[,.;]?\s*/gc;
print(" lowercase"), redo LOOP if /\G[a-z]+\b[,.;]?\s*/gc;
print(" UPPERCASE"), redo LOOP if /\G[A-Z]+\b[,.;]?\s*/gc;
print(" Capitalized"), redo LOOP if /\G[A-Z][a-z]+\b[,.;]?\s*/gc;
print(" MiXeD"), redo LOOP if /\G[A-Za-z]+\b[,.;]?\s*/gc;
print(" alphanumeric"), redo LOOP if /\G[A-Za-z0-9]+\b[,.;]?\s*/gc;
print(" line-noise"), redo LOOP if /\G[^A-Za-z0-9]+/gc;
print ". That's all!\n";
}出力は以下のようになります(何行かに分割しています):
line-noise lowercase line-noise lowercase UPPERCASE line-noise
UPPERCASE line-noise lowercase line-noise lowercase line-noise
lowercase lowercase line-noise lowercase lowercase line-noise
MiXeD line-noise. That's all!これは、reset() 演算子を呼び出すごとに 1 度だけしか マッチしないことを除いては /pattern/ による検索と全く同じです。 たとえば、ファイルの集まりの中で個々のファイルについて、あるものを 探すとき、最初の 1 つだけの存在がわかれば良いのであれば、この機能を 使って最適化をはかることができます。 現在のパッケージにローカルとなっている ?? のパターンだけが リセットされます。
while (<>) {
if (?^$?) {
# blank line between header and body
}
} continue {
reset if eof; # clear ?? status for next file
}この方法は、あまりお勧めしません。 Perl の遠い将来のバージョン(おそらく 2168 年頃)では削除されるかもしれません。
文字列中でパターンを検索し、もし見つかれば、置換テキストで置き換え、 置換した数を返します。 見つからなければ、偽 (具体的には、空文字列) を返します。
=~ 演算子や !~ 演算子によって文字列が指定されていなければ、 変数 $_ が検索され、修正されます。 (=~ で指定される文字列は、スカラ変数、配列要素、ハッシュ要素、 あるいは、これらへの代入式といった左辺値でなければなりません。)
あとで述べますが、区切り文字はスラッシュとは限りません。 シングルクォートを区切り文字として使った場合には、 PATTERN にも REPLACEMENT にも変数の展開を行ないません。 それ以外の場合、文字列の最後を表わすものには見えない $ が PATTERN に含まれると、実行時に変数がパターン内に展開されます。 最初に変数が展開されるときにだけパターンのコンパイルを行ないたいときには、 /o オプションを使ってください。 パターンの評価結果が空文字列になった場合には、最後に成功した正規表現が 代わりに使われます。 これについてさらに詳しくは、perlre を参照してください。 use locale が有効の場合の議論については perllocale を参照して下さい。
オプションは、m// のものに加えて、以下の置換固有のものがあります:
e 式の右側の評価を行なう
ee 右側を文字列として評価して、その結果を評価する空白ではない任意の区切り文字で、スラッシュを置き換えられます。 識別子として許されている文字を使うときには s の後に空白を 追加してください。 先に述べたように、シングルクォートを使うと置換文字列での展開は されません (/e修飾子を使えば可能です)。 Perl 4 と違って、 Perl 5 はバッククォートを通常のデリミタとして扱います。 置換テキストはコマンドとして評価されません。 PATTERN を括弧類で括った場合には、REPLACEMENT 用にもう一組の区切り文字を 用意します。 これは、括弧類であっても、なくてもかまいません; s(foo)(bar) や s<foo>/bar/。 /e は置換文字列を完全な Perl の式として扱い、その場所で直ちに解釈します。 しかし、これはコンパイル時に構文チェックされます。 二番目の e 修飾子を指定すると、置換部分がまず Perl の式として eval されます。
例:
s/\bgreen\b/mauve/g; # don't change wintergreen
$path =~ s|/usr/bin|/usr/local/bin|;
s/Login: $foo/Login: $bar/; # run-time pattern
($foo = $bar) =~ s/this/that/; # copy first, then change
$count = ($paragraph =~ s/Mister\b/Mr./g); # get change-count
$_ = 'abc123xyz';
s/\d+/$&*2/e; # yields 'abc246xyz'
s/\d+/sprintf("%5d",$&)/e; # yields 'abc 246xyz'
s/\w/$& x 2/eg; # yields 'aabbcc 224466xxyyzz'
s/%(.)/$percent{$1}/g; # change percent escapes; no /e
s/%(.)/$percent{$1} || $&/ge; # expr now, so /e
s/^=(\w+)/pod($1)/ge; # use function call
# expand variables in $_, but dynamics only, using
# symbolic dereferencing
s/\$(\w+)/${$1}/g;
# Add one to the value of any numbers in the string
s/(\d+)/1 + $1/eg;
# This will expand any embedded scalar variable
# (including lexicals) in $_ : First $1 is interpolated
# to the variable name, and then evaluated
s/(\$\w+)/$1/eeg;
# Delete (most) C comments.
$program =~ s {
/\* # Match the opening delimiter.
.*? # Match a minimal number of characters.
\*/ # Match the closing delimiter.
} []gsx;
s/^\s*(.*?)\s*$/$1/; # trim whitespace in $_, expensively
for ($variable) { # trim whitespace in $variable, cheap
s/^\s+//;
s/\s+$//;
}
s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields最後の例で \ の代わりに $ を使っているのに注意してください。 sed と違って、\<数字> の形式はパターンの方でのみ使用できます。 その他の場所では、$<数字> を使います。
ときには、/g を付けるだけでは、あなたが望んでいるような形で すべてを変更することができないことがあります。 良くある例を 2 つ示します:
# put commas in the right places in an integer
1 while s/(\d)(\d\d\d)(?!\d)/$1,$2/g;
# expand tabs to 8-column spacing
1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;シングルクォートされた、リテラル文字列です。 バックスラッシュは、後ろに続くものが区切文字か、別のバックスラッシュで ある場合を除いて単なるバックスラッシュです。 区切文字やバックスラッシュが続く場合には、その区切文字自身もしくは バックスラッシュそのものが展開されます。
$foo = q!I said, "You said, 'She said it.'"!;
$bar = q('This is it.');
$baz = '\n'; # a two-character stringダブルクォートされた、リテラル文字列です。
$_ .= qq
(*** The previous line contains the naughty word "$1".\n)
if /\b(tcl|java|python)\b/i; # :-)
$baz = "\n"; # a one-character string展開され、/bin/sh またはそれと等価なものでシステムのコマンドとして 実行される(であろう)文字列です。 シェルのワイルドカード、パイプ、リダイレクトが有効です。 そのコマンドの、標準出力を集めたものが返されます。 標準エラーは影響を与えません。 スカラコンテキストでは、(複数行を含むかもしれない) 1 つの文字列が戻ってきます。 コマンドが失敗したときは未定義値を返します。 リストコンテキストでは、($/ もしくは $INPUT_RECORD_SEPARATOR を どのように設定していても) 行のリストを返します。 コマンドが失敗したときは空リストを返します。
バッククォートは標準エラーには影響を与えないので、標準エラーを 使いたい場合は(シェルが対応しているものとして)シェルのファイル記述子の 文法を使ってください。 コマンドの STDERR と STDOUT を共に取得したい場合は:
$output = `cmd 2>&1`;コマンドの STDOUT は取得するが STDERR は捨てる場合は:
$output = `cmd 2>/dev/null`;コマンドの STDERR は取得するが STDOUT は捨てる場合は (ここでは順序が重要です):
$output = `cmd 2>&1 1>/dev/null`;STDERR を取得するが、STDOUT は古い STDERR のために残しておくために STDOUT と STDERR を交換するには:
$output = `cmd 3>&1 1>&2 2>&3 3>&-`;コマンドの STDOUT と STDERR の両方を別々に読み込みたい場合、 一番簡単な方法は別々のファイルにリダイレクトし、 プログラムが終了してからそのファイルを読むことです:
system("program args 1>program.stdout 2>program.stderr");コマンドによって使われる STDIN ファイルハンドルは Perl の STDIN を 継承します。 例えば:
open BLAM, "blam" || die "Can't open: $!";
open STDIN, "<&BLAM";
print `sort`;はファイル "blam" の内容をソートして表示します。
シングルクォートをデリミタとして使うと Perl のダブルクォート展開から 保護され、そのままシェルに渡されます:
$perl_info = qx(ps $$); # that's Perl's $$
$shell_info = qx'ps $$'; # that's the new shell's $$この文字列がどのように評価されるかは完全にシステムのコマンドインタプリタに 依存します。 ほとんどのプラットフォームでは、シェルのメタ文字をリテラルに 扱ってほしい場合はそれを守る必要があります。 文字をエスケープする方法が明確ではないので、これは理論的には難しいことです。 逆クォートを安全にエミュレートするために手動で fork() と exec() を 行うためのきれいで安全な例については perlsec を参照してください。
(特に DOS 風の)プラットフォームには、シェルが複数行のコマンドを扱うことが できないものがあるので、文字列に改行を入れるとあなたの望まない結果に なる場合があります。 シェルが対応していれば、コマンド分割文字で分割することで 1 行に複数のコマンドを入れて解釈させることができます (この文字は、多くの Unix シェルでは ;、Windows NT cmd シェルでは & です)。
v5.6.0 以降、Perl は子プロセスの実行前に書き込み用に開いている全ての ファイルをフラッシュしようとしますが、これに対応していない プラットフォームもあります(perlport を参照してください)。 安全のためには、$| (English モジュールでは $AUTOFLUSH)をセットするか、 開いている全てのハンドルに対して IO::Handle の autoflush() メソッドを 呼び出す必要があります。
コマンド行の長さに制限があるコマンドシェルがあることに注意してください。 全ての必要な変換が行われた後、コマンド文字列がこの制限を越えないことを 保障する必要があります。 特定の環境に関するさらなる詳細についてはプラットフォーム固有の リリースノートを参照してください。
この演算子を使うと、プログラムの移殖が困難になります。 呼び出されるシェルコマンドはシステムによって異なり、実際全く 存在しないこともあるからです。 一つの例としては、POSIX シェルの type コマンドは DOS の type コマンドと 大きく異なっています。 これは、何かを為すために正しい方法として逆クォートを使うことを 避けるべきであることを意味しません。 Perl は接着剤のような言語として作られ、接着されるべきものの一つは コマンドです。 単にあなたが何をしようとしているかを理解しておいてください。
さらなる議論については "I/O Operators" を参照して下さい。
埋め込まれた空白を区切文字として、STRING から抜き出した単語のリストを 評価します。 これは、以下の式と大体同じと考えられます:
split(' ', q/STRING/);違いは、実際のリストをコンパイル時に生成し、スカラコンテキストではリストの 最後の要素を返すことです。 従って、以下の表現は:
qw(foo bar baz)以下のリストと文法的に等価です。
'foo', 'bar', 'baz'よく行なわれる例としては以下のものです:
use POSIX qw( setlocale localeconv )
@EXPORT = qw( foo bar baz );よくある間違いは、単語をカンマで区切ったり、複数行の qw 文字列の中に コメントを書いたりすることです。 このために、usr warnings プラグマと -w スイッチ (つまり、$^W 変数) は STRING に "," や "#" の文字が入っていると 警告を出します。
検索リスト (SEARCHLIST) に含まれる文字を、対応する置換リスト (REPLACEMENTLIST) の文字に変換します。 置換または削除が行なわれた、文字数を返します。 =~ 演算子や !~ 演算子で文字列が指定されていなければ、$_ の文字列が 変換されます。 (=~ で指定される文字列は、スカラ変数、配列要素、ハッシュ要素、 あるいはこれらへの代入式といった左辺値でなければなりません。)
文字の範囲はハイフンを使って指定できます。 tr/A-J/0-9/ は tr/ACEGIBDFHJ/0246813579/ と同じ置換を行います。 sed の信仰者のために y が tr の同義語として提供されています。 SEARCHLIST を括弧類で括った場合には、 REPLACEMENTLIST 用に、もう一組の区切り文字を用意します。 これは、括弧類であっても、なくてもかまいません。 例: tr[A-Z][a-z] や tr(+\-*/)/ABCD/。
tr は \d や [:lower:] といった正規表現文字クラスを 使わない ことに注意してください。 tr 演算子は tr(1) ユーティリティと等価ではありません。 文字列の大文字小文字をマップしたい場合は、 "lc" in perlfunc と "uc" in perlfunc を参照して下さい。 また正規表現が必要な場合には一般的に s 演算子を使うことを 考慮してみてください。
範囲指定という考え方は文字セットが異なる場合はやや移植性に欠けることにも 注意してください -- そして同じ文字セットでも恐らく期待しているのとは違う 結果を引き起こすこともあります。 健全な原則としては、範囲の最初と最後をどちらもアルファベット (大文字小文字も同じ)(a-e, A-E)にするか、どちらも数字にする(0-4)ことです。 それ以外は全て安全ではありません。 疑わしいときは、文字セットを完全に書き出してください。
オプションは以下の通りです:
c SEARCHLIST を補集合にする
d 見つかったが置換されなかった文字を削除する
s 置換された文字が重なったときに圧縮する/c 修飾子が指定されると、SEARCHLIST には補集合が指定されたものと 解釈されます。 /d 修飾子が指定されると、SEARCHLIST に指定されて、 REPLACEMENTLIST に対応するものがない文字が削除されます。 (これは、SEARCHLIST で見つかったものを削除する、ただそれだけの、ある種の tr プログラムの動作よりと比べれば、いく分柔軟なものになっています。) /s 修飾子が指定されると、同じ文字に文字変換された文字の並びを、 その文字 1 文字だけに圧縮します。
/d 修飾子が使われると、REPLACEMENTLIST は、常に指定された通りに 解釈されます。 /d が指定されない場合で、REPLACEMENTLIST が SEARCHLIST よりも短いと、 同じ長さになるまで、REPLACEMENTLIST の最後の文字が 繰り返されているものとして扱われます。 REPLACEMENTLIST が空文字列でのときには、SEARCHLIST と同じになります。 後者は、ある文字クラスに含まれる文字数を数えるときや、 ある文字クラスの文字の並びを圧縮するようなときに便利です。
例:
$ARGV[1] =~ tr/A-Z/a-z/; # canonicalize to lower case
$cnt = tr/*/*/; # count the stars in $_
$cnt = $sky =~ tr/*/*/; # count the stars in $sky
$cnt = tr/0-9//; # count the digits in $_
tr/a-zA-Z//s; # bookkeeper -> bokeper
($HOST = $host) =~ tr/a-z/A-Z/;
tr/a-zA-Z/ /cs; # change non-alphas to single space
tr [\200-\377]
[\000-\177]; # delete 8th bit複数の文字変換が一つの文字について指定されると、最初のものだけが使われます。
tr/AAA/XYZ/は A を X に変換します。
変換テーブルはコンパイル時に作られるので、SEARCHLIST も REPLACEMENTLIST もダブルクォート展開の対象とはなりません。 変数を使いたい場合には、eval() を使わなければならないということです:
eval "tr/$oldlist/$newlist/";
die $@ if $@;
eval "tr/$oldlist/$newlist/, 1" or die $@;クォートの行指向形式は、シェルの「ヒアドキュメント」構文を基にしています。 << に引き続いて、クォートされるテキストを終了させる文字列を指定でき、 現在の行の次の行から終端文字列までの全ての行がその項目の値となります。
終端文字列には、識別子(単語) かクォートされたテキストが使えます。 クォートされていない識別子は、ダブルクォートのように扱われます。 識別子がクォートされていない場合は、<< と識別子の間に 空白を入れてはいけません。 (もし空白を入れると、空識別子として扱われます; これは有効で、 最初の空行にマッチするようになります。) 終端文字列は終端行に単体で(クォートされず、前後にも空白なしで) 現れなければなりません。
終端文字列がクォートされている場合には、そのクォートの種類によって、 クォートされるテキストの扱い決められます。
ダブルクォートは、通常のダブルクォートされた文字列と全く同じ規則を使って 変数展開されることを示します。
print <<EOF;
The price is $Price.
EOF
print << "EOF"; # same as above
The price is $Price.
EOFシングルクォートは、内容が展開されずにリテラルに扱われることを 意味します。 これはシングルクォート文字列と似ていますが、バックスラッシュは 特別な意味を持たず、他の全てのクォート構造違って、\\ は 二つのバックスラッシュとして扱われることが違います。
これは、perl において、内容のエスケープについて心配する必要のない 唯一の形で、コードジェネレータがうまく使えるものです。
ヒアドキュメントのの内容は、文字列がバッククォートで 埋め込まれているかのように扱われます。 したがって、その内容、はダブルクォートされているかのように変数展開され、 その後シェル経由で実行され、実行された結果になります。
print << `EOC`; # execute command and get results
echo hi there
EOC複数のヒアドキュメントを連続してスタックすることも可能です:
print <<"foo", <<"bar"; # you can stack them
I said foo.
foo
I said bar.
bar
myfunc(<< "THIS", 23, <<'THAT');
Here's a line
or two.
THIS
and here's another.
THAT以下のようなことをしたいのではないということが Perl にはわからないので、 文を終わらせるためには末尾にセミコロンをつけなければならないことを 忘れないで下さい:
print <<ABC
179231
ABC
+ 20;ヒアドキュメントから行終端子を除去したい場合は、chomp() を使ってください。
chomp($string = <<'END');
This is a string.
ENDヒアドキュメントをソースのほかの部分からインデントしたい場合、 各行の先頭の空白は手動で取り除く必要があります:
($quote = <<'FINIS') =~ s/^\s+//gm;
The Road goes ever on and on,
down from the door where it began.
FINISs///eg のようなデリミタ構造の中でヒアドキュメントを使う場合、 クォートされたものは最後のデリミタに引き続くものとして来なければなりません。 従って、以下のようではなく:
s/this/<<E . 'that'
the other
E
. 'more '/eg;以下のように書かなければなりません:
s/this/<<E . 'that'
. 'more '/eg;
the other
Eプログラムの最後の行に終端識別子がある場合、その後には 改行がなければなりません; さもなければ、Perl は Can't find string terminator "END" anywhere before EOF... という 警告を出します。
さらに、文字列終端識別子に対するクォートルールは Perl のクォートルールとは 関係がありません。 q(), qq() および同種のものは '' や "" の 代わりのなるものには対応しておらず、文字をクォートするための バックスラッシュだけが展開されます:
print << "abc\"def";
testing...
abc"def最後に、クォートされた文字列は複数行にかかることはありません。 識別子に関する一般的なルールは、文字列リテラルでなければならいことです。 これに従っていれば、安全のはずです。
何か複数の解釈が可能な表現があった場合、Perl は最も確からしい解釈を 選択するために DWIM ("Do What I Mean")原則を使います。 この戦略は非常に成功したので、Perl プログラマはしばしば 自分が書いたものの矛盾を疑いません。 しかし時間がたつにつれて、Perl の概念は作者が本当に意味していたものから かなり変わりました。
この章では Perl がどのようにクォートされた構造を扱うかを 明確にしようと思います。 これを学ぼうとする最もよくある理由は正規表現の迷宮をほぐすためですが、 パースの初期ステップは全てのクォート演算子で同じなので、全て同時に扱います。
Perl のパースに関するルールで最も重要なものは以下で述べているうち 最初のものです。 つまり、クォートされた構造を処理するときは、Perl はまずその構造の 最後を探して、それから中身を解釈します。 このルールがわかれば、とりあえずはこの章の残りは読み飛ばしてもかまいません。 その他のルールは最初のルールに比べてユーザーの予想に反する頻度は はるかに少ないです。
以下で議論するパスには同時に実行されるものもありますが、 結果は同じことなので、別々に考えることにします。 クォート構造の種類によって、Perl が実行するパスの数は 1 から 4 まで異なりますが、これらのパスは常に同じ順番で実行されます。
最初のパスは、クォート構造の末尾を探して、パース中に使うデリミタの情報が どこかを探すものです。 検索中に、開始デリミタと終了デリミタの間のテキストは安全な場所に コピーされます。 コピーされたテキストはデリミタに依存しません。
構造がヒアドキュメントの場合、終了デリミタは内容として終端文字列を持つ 行です。 従って、<<EOF は、"\n" の直後の、終端行の最初の列から始まる EOF で 終端します。 ヒアドキュメントの終端行を探すとき、読み飛ばされるものはありません。 言い換えると、ヒアドキュメント文法以降の行は、1 行毎に終端文字列と 比較されます。
ヒアドキュメント以外の構造では、1 文字が開始デリミタと終了デリミタとして 使われます。 開始デリミタが組の開き文字((, [, {, < のいずれか)の場合、 終了デリミタは対応する組の閉じ文字(つまり ), ], }, >) です。 開始デリミタが / 組になる文字や、組の閉じ文字の場合、終了デリミタは 開始デリミタと同じです。 従って / は qq// 構造を終端し、一方 ] は qq[] と qq]] 構造を 終端します。
1 文字のデリミタを探す場合、エスケープされたデリミタと \\ は 読み飛ばします。 例えば、/ を探しているときには、\\ と \/ の組み合わせを 読み飛ばします。 デリミタがかっこでくくられている場合は、ネストした組も読み飛ばされます。 例えば、開きの [ と組になる閉じの ] を探しているときには、 \\, \], \[ の組み合わせをは全て読み飛ばし、 さらにネストした [, ] も読み飛ばします。 しかし、(qq\\ や tr\\\ のように)バックスラッシュがデリミタとして 使われた場合、何も読み飛ばしません。 末尾の検索中、デリミタをエスケープするバックスラッシュは除去されます (述べたとおりに正確に、安全な場所にコピーはされません)。
3 つのデリミタからなる構造 (s///, y///, tr///) の場合、 検索はもう一度繰り返されます。 最初のデリミタが開きかっこでない場合、s!!! and tr))) のように 3 つのデリミタは同じでなければなりません; この場合、2 番目のデリミタが左側の終端と右側の開始を同時に行います。 左側のデリミタがかっこを構成するもの (これは (), [], {}, <> のいずれか) の場合、右側も s(){} や tr[]// のようなデリミタである必要があります。 これらの場合、右側と左側の間には空白やコメントを置けますが、 コメントは少なくとも一つの空白の後である必要があります; さもなければコメントの開始文字が右側の開始デリミタとして扱われてしまいます。
検索する間、構造の文脈は考慮しません。 従って:
"$hash{"$foo/$bar"}"または:
m/
bar # NOT a comment, this slash / terminated m//!
/xは正しいクォート表現ではありません。 クォートは最初の " や / で終わりとなり、残りの部分は文法エラーと なります。 m// を終わらせているスラッシュの次に来ているのが 空白 なので、 上の例では m//x ではなく、/x なしの m// となります。 従って、中にある # はリテラルな # として扱われます。
この検索の間、\c\ (マルチバイト文字制御文法)に注意は払われません。 従って、qq/\c\/ の 2 番目の \ は \/ の一部として扱われ、 引き続く / はデリミタとして認識されません。 代わりに、クォート構造の末尾に \034 か \x1c を使ってください。
次のステップは、得られた(デリミタに依存しない)テキストに対する展開です。 複数のケースがあります。
<<'EOF'展開は行われません。 \\ の組み合わせはそのままであることに注意してください; ヒアドキュメントではデリミタのエスケープはできないからです。
m'', the pattern of s'''このステージでは展開は行われません。 \\ を含む、バックスラッシュ付きのシーケンスは "parsing regular expressions" で扱われます。
'', q//, tr''', y''', the replacement of s'''\\ の組における \ の削除のみが行われます。 従って、tr''' や y''' の中にある - は文字通りハイフンとして扱われ、 文字範囲は使えません。 s''' の置換文字列での \1 は $1 としては動作しません。
tr///, y///変数展開は行われません。 \Q, \U, \E のような、大文字小文字やクォートに関する、文字列を 変更するような組み合わせは認識されません。 \200 や \t のようなその他のエスケープシーケンスや、 \\ や \- のようなバックスラッシュ付きの文字は、適切なリテラルに 変換されます。 文字 - は特別扱いされるので、\- はリテラルな - として扱われます。
"", ``, qq//, qx//, <file*glob>, <<"EOF"\Q, \U, \u, \L, \l (おそらくは \E との組)は 対応する Perl 構造に変換されます。 従って、"$foo\Qbaz$bar" は内部的に $foo . (quotemeta("baz" . $bar)) に変換されます。 \200 や \t のような、その他のエスケープシーケンスや、\\ や \- のような、バックスラッシュがつけられた文字は適切な拡張に 置換されます。
\Q と \E の間にある全てのもの が通常の方法で展開されます。 "\Q\\E" のようなものは内部にあるのは \E ではなく、 \Q, \\, E であるので、結果は "\\\\E" と同じになります。 一般的なルールとして、\Q と \E の間にあるバックスラッシュは 直感に反した結果になります。 それで、"\Q\t\E" は quotemeta("\t") に変換され、これは(TAB は 英数字ではないので "\\\t" と同じです。 以下のようなことにも注意してください:
$str = '\t';
return "\Q$str";これは "\Q\t\E" を書いた人の憶測上の 意図 により近いです。
展開されたスカラと配列は内部で join と . の結合操作に変換されます。 従って、"$foo XXX '@arr'" は以下のようになります:
$foo . " XXX '" . (join $", @arr) . "'";上記の全ての操作は、左から右に同時に行われます。
"\Q STRING \E" の結果は全てのメタ文字がクォートされているので、 \Q\E の組の内側にリテラルの $ や @ を挿入する方法はありません。 \ によって守られている場合、$ はクォートされて "\\\$" と なります。 そうでない場合、これは展開されるスカラ変数の開始として解釈されます。
展開コードは、展開するスカラ変数がどこで終わるかを決定する必要が あることにも注意してください。 例えば、"a $b -> {c}" が実際には以下のどちらかになります:
"a " . $b . " -> {c}";または:
"a " . $b -> {c};ほとんどの場合、要素と、マッチする中かっこや大かっこの間に空白を含まない、 最も長いテキストになります。 出力は発見的な推定器をよる投票によって決定されるので、結果は厳密には 予測できません。 幸い、紛らわしい場合でも普通は正しいです。
s///\Q, \U, \u, \L, \l の処理と展開が qq// 構造と 同じように起こります。
このステップでは、より健全な文法をまだ導入していない、手に負えない sed ハッカーのために、s/// の置換テキストの中にある \1 を、しぶしぶながら $1 に変換します。 use warnings プラグマやコマンドラインオプション -w (これは $^W 変数です) がセットされていると警告が生成されます。
RE in ?RE?, /RE/, m/RE/, s/RE/foo/,\Q, \U, \u, \L, \l \E の処理と展開が qq// 構造と (ほとんど)同じように起こります。
\N{...} の処理もここで行われ、正規表現コンパイラのための中間形式に コンパイルされます。 (これは、後述するように、正規表現のコンパイルは実行時に行われ、 \N{...} はコンパイル時の構文だからです。)
しかし、その他の、\ の後に文字が続く組み合わせは置換されず、単に 読み飛ばされます; これは以下のステップで正規表現としてパースするためです。 ここでは \c は読み飛ばされるので、正規表現中の \c@ の @ は 配列のシンボル(例えば @foo) と扱われる可能性があります; 一方 qq// 内の同じテキストは \c@ と展開されます。
さらに、(?{BLOCK}), (?# comment ), //x 正規表現での # の コメントの中では、どのような処理も行われません。 これは //x 修飾子が影響を与える最初のステップです。
パターン内の展開ではいくつか特殊な動作をします: $|, $(, $), @+, @- は展開されず、 $var[SOMETHING] は(いくつかの異なる推定器によって)配列の要素か $var の後に正規表現が続いているのかが投票されます。 これは ${arr[$bar]} が便利になるところです: /${arr[0-9]}/ は 配列要素 -9 として解釈され、/$arr[0-9]/ の場合のように $arr の後に 数値が続いているような正規表現としては解釈されません。 異なった推定器によって投票されることがあるので、結果は予測できません。
\\ を処理しないことにより、後処理したテキストに特定の制限があります。 デリミタが / の場合、このステップの結果として \/ を得ることは できません。 / は正規表現を終わらせ、\/ は前のステップで / に展開され、 \\/ はそのまま残されます。 / は正規表現の中では \/ と等価なので、これはたまたまデリミタが 正規検索エンジンにとって特別な文字の場合、つまり s*foo*bar*, m[foo], ?foo? のような場合、あるいは以下のように英数字でなければ、 問題にはなりません:
m m ^ a \s* b mmx;上記の正規表現では、説明のために意図的にわかりにくくしていますが、 デリミタは m で、修飾子は mx で、デリミタを取り除いた後の 正規表現は m/ ^ a \s* b /mx と同じです。 デリミタを英数字や空白でないものに制限するべきである理由は複数あります。
これは正規表現以外の全ての構造にとって最後のステップです。 正規表現はさらに処理が続きます。
以前のステップは Perl コードのコンパイル中に実行されますが、 これは実行時に起こりますが、もし適切ならコンパイル時に 計算できるように最適化されることもあります。 上記の前処理の後、そして必要なら連結、結合、大文字小文字変換、 メタクォート化が行われた後、結果の 文字列 がコンパイルのために 正規表現エンジンに渡されます。
正規表現エンジンで起こることについては perlre で議論した方が よいでしょうが、継続性のために、ここでそれを行います。
これも //x 修飾子の存在が関連するステップの一つです。 正規表現エンジンは文字列を左から右にスキャンして、有限状態オートマトンに 変換します。
バックスラッシュ付きの文字は(\{ のように)対応するリテラル文字列に 置換されるか、あるいは(\b のように)有限状態オートマトンの特別な ノードを生成します。 (| のような)正規表現エンジンにとって特別な文字は対応するノードか ノードのグループを生成します。 残りの全てはマッチするリテラル文字列に変換されるか、そうでなければ (//x が指定された時の空白と # スタイルのコメントと同様に) 無視されます。
文字クラス構造 [...] のパースは他のパターンとはルールが異なります。 この構造の終端は {} でデリミタされた構造の終端を検索するのと同じルールで 検索されます; 唯一の例外は、[ の直後の ] はバックスラッシュが 先行しているものとして扱われます。 同様に、(?{...}) の終端は {} でデリミタされた構造の終端を 検索されるのと同じルールで検索されます。
正規表現に与えられる文字列と、結果としての有限状態オートマトンの両方を 検査できます。 use re プラグマの debug/debugcolor 引数と、 "Command Switches" in perlrun に記述されている -Dr コマンドライン オプションを参照してください。
このステップは完全性のためだけにリストされています。 これは意味論的には変化がないので、このステップの詳細は文書化されておらず、 将来予告なしに変更されることがあります。 このステップはここまでの処理で生成された有限オートマトンに対して 適用されます。
split() で /^/ を暗黙に /^/m に最適化するのもこのステップです。
知っておいた方がよい I/O 演算子もいくつかあります。
バッククォートで括られた文字列は、まず、ダブルクォート補完のように 変数の展開が行なわれます。 その後、シェルでの場合と同じように、外部コマンドとして解釈され、 そのコマンドの出力がこのバッククォート文字列の値となります。 スカラーコンテキストでは、出力すべてを含む一個の文字列が返されます。 リストコンテキストでは、出力の 1 行 1 行が個々の要素となるリストが返されます。 ($/ を設定すれば、行の終わりを示す文字を変えることができます。) コマンドは、この擬似リテラルが評価されるごとに実行されます。 コマンドのステータス値は $? に返されます ($? の解釈については、 perlvar を参照してください)。 csh での場合とは違って、結果のデータに対する変換は行なわれず、 改行は改行のままです。 どのシェルとも違って、シングルクォートがコマンド中の変数名を 解釈させないようにすることはありません。 シェルにリテラルなドル記号を渡すには、バックスラッシュで エスケープしなければなりません。 バッククォートの一般形は、qx// です。 (バッククォートは常にシェル展開されます。 セキュリティに関しては perlsec を参照して下さい)
スカラーコンテキストで山括弧の中のファイルハンドルを評価すると、 そのファイルから、次の行を読み込むことになります (改行があればそれも含まれます)。 ファイルの最後またはエラーの場合は undef を返します。 $/ が undef に設定されている場合(ファイル吸い込みモードと呼ばれます) でファイルが空の場合、 最初は '' を返し、次は undef を返します。
通常は、返された値を変数に代入しなければなりませんが、自動的に 代入される場合が 1 つだけあります。 この入力シンボルが、while 文(for(;;) の形になっていたとしても)の条件式中に 単独で現れた場合だけは、その値が自動的にグローバル変数 $_ に代入されます。 以前の値は破壊されます。 (これは、奇妙に思えるかもしれませんが、ほとんどすべての Perl スクリプトで これが必要になることでしょう。) $_ 変数は暗黙にはローカル化されません。 そうしたい場合はループの前に local $_; と書く必要があります。
以下のものは、お互いに同値なものです:
while (defined($_ = <STDIN>)) { print; }
while ($_ = <STDIN>) { print; }
while (<STDIN>) { print; }
for (;<STDIN>;) { print; }
print while defined($_ = <STDIN>);
print while ($_ = <STDIN>);
print while <STDIN>;以下は同様の振る舞いをしますが、$_ を使いません:
while (my $line = <STDIN>) { print $line }これらのループ構造の中で、代入された値は (代入が自動か明示的かに関わりなく) 定義されているかどうかを見るためにテストされます。 定義テストは、行が Perl にとって偽となる文字列値を持っているかどうかの 問題を避けます。例えば newline のついていない "" や "0" です。 もし本当にこのような値でループを終了させたいときは、 以下のように明示的にテストするべきです:
while (($_ = <STDIN>) ne '0') { ... }
while (<STDIN>) { last unless $_; ... }その他の真偽値コンテキストでは、明示的な defined や比較なしに <filehandle> を使うと、use warnings プラグマや -w コマンドラインスイッチ ($^W 変数) が有効なときには、 警告を発生させます。
STDIN、STDOUT、STDERR というファイルハンドルは、あらかじめ定義されています。 (stdin、stdout、stderr というファイルハンドルも、 ローカルな名前でこれらのグローバルな名前が見えなくなっている パッケージを除けば、使用することができます。) その他のファイルハンドルは、open() 関数などで作ることができます。 これに関する詳細については perlopentut と "open" in perlfunc を 参照して下さい。
<FILEHANDLE> がリストを必要とするコンテキストで用いられると、 1 要素に 1 行の入力行すべてからなるリストが返されます。 これを使うと簡単にかなり大きなデータになってしまいますので、 注意を要します。
<FILEHANDLE> は readline(*FILEHANDLE) とも書けます。 "readline" in perlfunc を参照して下さい。
ヌルファイルハンドル <> は特別で、sed や awk の動作を エミュレートするために使われます。 <> からの入力は、標準入力からか、コマンドライン上に並べられた個々の ファイルから行なわれます。 動作の概要は、以下のようになります。 最初に <> が評価されると、配列 @ARGV が調べられ、空であれば、 $ARGV[0] に "-"を設定します。 これは、open されるとき標準入力となります。 その後、配列 @ARGV がファイル名のリストとして処理されます。
while (<>) {
... # code for each line
}は以下ののような Perl の擬似コードと等価です:
unshift(@ARGV, '-') unless @ARGV;
while ($ARGV = shift) {
open(ARGV, $ARGV);
while (<ARGV>) {
... # code for each line
}
}但し、わずらわしく書かなくても、動作します。 実際に @ARGV を shift しますし、その時点のファイル名を変数 $ARGV に 入れています。 また、内部的にファイルハンドル ARGV を使っています。 <> は <ARGV> の同義語で、マジカルです。 (上記の擬似コードは、<ARGV> を通常のものとして扱っているので、 うまく動作しません。)
空ファイルハンドルは 2 引数の "open" in perlfunc を使った特別な文字列なので、 もし以下のようなスクリプトを書いて:
while (<>) {
print;
}これを perl dangerous.pl 'rm -rfv *|' として呼び出すと、実際には パイプを開き、rm コマンドを実行して、 rm の出力をパイプから読みます。 もし @ARGV の全ての要素をファイル名として解釈させたいなら、 CPAN にある ARGV::readonly モジュールが使えます。
最終的に、@ARGV に扱いたいと思っているファイル名が含まれるのであれば、 最初に <> を評価する前に @ARGV を変更することも可能です。 行番号 ($.) は、入力ファイルがあたかも 1 つの大きなファイルで あるかのように、続けてカウントされます。 個々のファイルごとにリセットする方法は、"eof" in perlfunc の例を 参照してください。
最初から @ARGV に自分でファイルのリストを設定してもかまいません。 以下は @ARGV が与えられなかったときに全てのテキストファイルを @ARGV に設定します。
@ARGV = grep { -f && -T } glob('*') unless @ARGV;ここにパイプコマンドを置くことも出来ます。 例えば、以下は圧縮された引数を自動的に gzip のフィルタに通します:
@ARGV = map { /\.(gz|Z)$/ ? "gzip -dc < $_ |" : $_ } @ARGV;スクリプトにスイッチを渡したいのであれば、Getopts モジュールを 使うこともできますし、実際の処理の前にのようなループを置くこともできます。
while ($_ = $ARGV[0], /^-/) {
shift;
last if /^--$/;
if (/^-D(.*)/) { $debug = $1 }
if (/^-v/) { $verbose++ }
# ... # other switches
}
while (<>) {
# ... # code for each line
}シンボル <> がファイルの最後で undef を返すのは一度きりです。 そのあとでもう一度呼び出すと、新たに別の @ARGV を処理するものとみなされ、 その時に @ARGV を設定しなおしていないと、STDIN からの入力を 読み込むことになります。
山括弧の中の文字列が (<$foo> のような) 単純スカラ変数であれば、 その変数が入力を行なうファイルハンドルの名前そのもの、名前への型グロブ、 名前へのリファレンスのいずれかを示しているとみなされます。
$fh = \*STDIN;
$line = <$fh>;山括弧の中の文字列がファイルハンドルでもファイルハンドル名、型グロブ、 型グロブリファレンスのいずれかが入った単純スカラ変数でもなければ、 グロブを行なうファイル名のパターンと解釈され、コンテキストによって ファイル名のリストか、そのリストの次のファイル名が返されます。 この区別は単に構文的に行われます。 <$x> は常に間接ハンドルから readline() しますが、 <$hash{key}> は常に glob() します。 $x は単純スカラー変数ですが、$hash{key} は違う(ハッシュ要素)からです。 <$x > (余分な空白に注意) ですら readline($x) ではなく glob("$x ") として扱われます。
まず、1 段階だけダブルクォート展開が行なわれますが、前の段落に書いた 間接ファイルハンドルと同じになる、<$foo> のようには書けません。 (Perl の古いバージョンでは、ファイル名グロブと解釈させるために <${foo}> のように中括弧を入れていました。 最近ではより明確にするために、glob($foo) と内部関数を 呼ぶこともできます。 おそらく、まず、こちらの方で試すのが正解でしょう。) 例:
while (<*.c>) {
chmod 0644, $_;
}はだいたい以下と等価です:
open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
while (<FOO>) {
chomp;
chmod 0644, $_;
}但し実際のグロブは内部的に標準の File::Glob モジュールを使います。 もちろん、もっと簡単に以下のように書けます:
chmod 0644, <*.c>;(ファイル)グロブは新しいリストを開始するときにだけ(組み込みの)引数を 評価します。 全ての値は開始する前に読み込んでいなければなりません。 これはリストコンテキストでは、とにかく自動的に全てを取り込むので 重要ではありません。 しかし、スカラーコンテキストではこの演算子は呼び出された時の 次の値か、リストがなくなったときには undef を返します。 ファイルハンドルを読み込む場合は、グロブが while の条件部にある場合は 自動的な defined が生成されます。 なぜならそうしないと、本来の glob の返り値 (0 というファイル) が ループを終了させるからです。 ここでも、undef は一度だけ返されます。 従って、もしグロブから一つの値だけを想定している場合、 以下のように書くことが:
($file) = <blurch*>;以下のように書くよりはるかに良いです:
$file = <blurch*>;なぜなら後者はファイル名を返す場合と偽を返す場合があるからです。
変数変換に挑戦する場合、明らかに glob() 関数を使う方が良いです。 なぜなら古い表記は間接ファイルハンドル表記と混乱するかも知れないからです。
@files = glob("$dir/*.[ch]");
@files = glob($files[$i]);C と同じように Perl でも、演算子に対するすべての引数がスタティックで、 副作用がないと判断できれば、コンパイル時に式の評価を行なってしまいます。 特に、変数置換の無いリテラルどうしの文字列連結はコンパイル時に行なわれます。 バックスラッシュの解釈もコンパイル時に行なわれます。
'Now is the time for all' . "\n" .
'good men to come to.'と書いても、内部的に 1 つの文字列になります。同様に
foreach $file (@filenames) {
if (-s $file > 5 + 100 * 2**16) { }
}と書くとコンパイラは、式が表わす数値をあらかじめ計算しますので、 インタプリタで計算する必要がなくなっています。
Perl は公式には無実行演算子はありませんが、裸の定数 0 と 1 は 特別に無効コンテキストでも警告を出さないことになっているので、 例えば安全に以下のように書けます:
1 while foo();任意のサイズのビット列はビット単位演算子(~ | & ^)で操作できます。
二項ビット単位演算子のオペランドが異なった長さの文字列だった場合、 | と ^ の演算子は短い側のオペランドの右側に追加のゼロが ついているとみなします。 一方 & 演算子は長い方のオペランドが短い方に切り詰められます。 この拡張や短縮の粒度はバイト単位です。
# ASCII-based examples
print "j p \n" ^ " a h"; # prints "JAPH\n"
print "JA" | " ph\n"; # prints "japh\n"
print "japh\nJunk" & '_____'; # prints "JAPH\n";
print 'p N$' ^ " E<H\n"; # prints "Perl\n";ビット列を操作したい場合は、確実にビット列が渡されるようにしてください: オペランドが数字の場合、数値 ビット単位演算を仮定します。 明示的に演算の型を指定するときには、以下の例のように "" か 0+ を使ってください。
$foo = 150 | 105; # yields 255 (0x96 | 0x69 is 0xFF)
$foo = '150' | 105; # yields 255
$foo = 150 | '105'; # yields 255
$foo = '150' | '105'; # yields string '155' (under ASCII)
$baz = 0+$foo & 0+$bar; # both ops explicitly numeric
$biz = "$foo" ^ "$bar"; # both ops explicitly stringyビットベクタの個々のビットをどのように操作するかの情報については "vec" in perlfunc を参照して下さい。
デフォルトでは、Perl は演算を浮動小数で行なわなければならないものと しています。 しかし、(もしそうしたいなら)
use integer;と書けば、その場所から現在の BLOCK の終わりまでは、整数演算を 行なってよいと、コンパイラに指示することができます。 内部の BLOCK で、
no integer;と書けば、その BLOCK の終わりまでは、指示を取り消すことになります。 これは全てを整数だけを使って処理することを意味するわけではないことに 注意してください。 これは単に Perl が整数を使いたいと思ったときに使うかもしれない、 というだけです。 例えば、use integer の指定があっても、sqrt(2) とすると、 1.4142135623731 といった結果が返ってきます。
数値を使う場合、ビット単位演算子 ("&", "|", "^", "~", "<<", ">>") は 常に整数の結果を生成します(但し "Bitwise String Operators" も 参照して下さい)。 しかし、それでも use integer は意味があります。 デフォルトでは、これらの結果は符号なし整数として解釈されますが、 use integer が有効の場合は、符号付き整数として解釈されます。 例えば、~0 は通常大きな整数の値として評価されます。 しかし、use integer; ~0 は 2 の補数のマシンでは -1 になります。
use integer が整数演算を提供する一方、数を特定の桁で自動的に丸めたり 切り捨てたりする機構はありません。 数を丸めるには、sprintf() や printf() を使うのが一番簡単な方法です。 perlfaq4 を参照して下さい。
浮動小数点数は数学者が実数と呼ぶものの近似でしかありません。 実数は浮動小数点より無限に続くので、多少角が丸められます。 例:
printf "%.20g\n", 123456789123456789;
# produces 123456789123456784浮動小数点数が等しいかどうかをちょうど同じかどうかで比較するのは いいアイデアではありません。 以下に、二つの浮動小数点数が指定された桁まで等しいかどうかを 比較する(比較的重い)次善の策を示します。 この問題に関するより厳密な扱いについては Knuth, volume II を参照して下さい。
sub fp_equal {
my ($X, $Y, $POINTS) = @_;
my ($tX, $tY);
$tX = sprintf("%.${POINTS}g", $X);
$tY = sprintf("%.${POINTS}g", $Y);
return $tX eq $tY;
}POSIX モジュール(Perl 標準配布パッケージの一部) は ceil(), floor() 及び その他の数学関数や三角関数を実装しています。 Math::Complex モジュール(Perl 標準配布パッケージの一部)は 実数と虚数の両方で動作する数学関数を定義しています。 Math::Complex は POSIX ほど効率的ではありませんが、 POSIX は複素数は扱えません。
金融アプリケーションにおける丸めは深刻な影響を与える可能性があり、 使用する丸めメソッドは指定された精度で行われるべきです。 このような場合、Perl が使用するシステム丸めを信用せず、 代わりに自分自身で丸め関数を実装するべきです。
標準の Math::BigInt と Math::BigFloat モジュールは多倍長演算を提供し、 演算子をオーバーロードしますが、これらは現在のところかなり遅いです。 多少の領域とかなりの速度を犠牲にして、桁数が制限されていることによる ありがちな落とし穴を避けることができます。
use Math::BigInt;
$x = Math::BigInt->new('123456789123456789');
print $x * $x;
# prints +15241578780673678515622620750190521(メモリと CPU 時間のみに依存する)無制限か固定の精度での計算ができる モジュールがいくつかあります。 さらに外部 C ライブラリを使ってより速い実装を提供する 非標準のモジュールもあります。
以下は短いですが不完全なリストです。
Math::Fraction 9973 / 12967 のような、大きくて無制限の分数
Math::String 文字列を数値のように扱う
Math::FixedPrecision 固定精度で計算する
Math::Currency 通貨の計算用
Bit::Vector (C を使って)ビットベクタを速く操作する
Math::BigIntFast 大きな数のための Bit::Vector のラッパー
Math::Pari Pari C ライブラリへのアクセスを提供する
Math::BigInteger 外部 C ライブラリを使う
Math::Cephes 外部の Cephes C を使う(大きな数はなし)
Math::Cephes::Fraction Cephes ライブラリを使った分数
Math::GMP これも外部 C ライブラリを使ううまく選んでください。