[pod] [xml]

NAME operator

perlop - Perl の演算子と優先順位

DESCRIPTION

Operator Precedence and Associativity operator, precedence precedence associativity

(演算子の優先順位と結合性)

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 を参照して下さい。

Terms and List Operators (Leftward) list operator operator, list term

(項とリスト演算子 (左方向))

「項」は 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"も参照してください。

The Arrow Operator arrow dereference ->

(矢印演算子)

C や C++ と同じように "->" は中置の被参照演算子です。 右側が [...], {...}, (...) のいずれかの形の添字であれば、左側は配列、ハッシュ、 サブルーチンへのハードリファレンスかシンボリックリファレンス (あるいは 技術的には、配列またはハードリファレンスが代入可能であれば ハードリファレンスを保持できる場所) でなければなりません。perlreftut と perlref を参照してください。

そうでなければ、右側はメソッド名かサブルーチンのリファレンスを持った 単純スカラ変数で、左側はオブジェクト (bless されたリファレンス) か クラス名でなければなりません。 perlobj を参照してください。

Auto-increment and Auto-decrement increment auto-increment ++ decrement auto-decrement --

(インクリメントとデクリメント)

"++" と "--" は、C の場合と同じように動作します。 つまり、変数の前に置かれれば、値を返す前に変数を 1 インクリメントまたは デクリメントし、後に置かれれば、値を返した後で変数を インクリメントまたはデクリメントします。

    $i = 0;  $j = 0;
    print $i++;  # prints 0
    print ++$j;  # prints 1

C と同様、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 になります)。

デクリメント演算子には、マジカルなものはありません。

Exponentiation ** exponentiation power

(指数演算子)

二項演算子の "**" は指数演算子です。 この演算子は、単項のマイナスよりも結合が強い演算子で、 -2**4 は (-2)**4 ではなく、-(2**4) と解釈されます。 (これは C の pow(3) を使って実装されていますので、 内部的には double で動作します。)

Symbolic Unary Operators unary operator operator, unary

(単項演算子)

単項演算子の "!" は論理否定を行ないます。 つまり 「not」 ということです。 この演算子の優先順位を低くしたものとして、not が用意されています。 !

単項演算子の "-" は被演算子が数値であれば、算術否定を行ないます。 被演算子が識別子ならば、マイナス記号にその識別子をつなげた 文字列が返されます。 これ以外で被演算子の最初の文字がプラスかマイナスのときには、 その記号を逆のものに置き換えた文字列を返します。 この規則の結果、-bareword が文字列 "-bareword" に等価となります。 しかし、文字列が英字以外("+" と "-" を除く)で始まっていると、 Perl は文字列を数値に変換しようとし、それから算術否定が実行されます。 もし文字列が明確に数値に変換できない場合、Perl は Argument "the string" isn't numeric in negation (-) at ... という 警告を出します。 - negation, arithmetic

単項演算子の "~" はビットごとの否定を行ないます。 つまり、1 の補数を返します。 例えば、0666 & ~027 は 0640 です。 (Integer Arithmetic と Bitwise String Operators も参照して下さい。) 結果の幅はプラットホーム依存であることに注意してください。 ~0 は 32-bit プラットホームでは 32 ビット幅ですが、 64-bit プラットホームでは 64 ビット幅ですので、 特定のビット幅を仮定する場合は、 余分なビットをマスクするために & 演算子を使うことを忘れないでください。 ~ negation, binary

単項演算子の "+" は、たとえ文字列に対して用いられた場合にも、何もしません。 関数名に続けて括弧付きの式を書く場合に、関数の引数リストと 解釈されないようにするために用いることができます。 (下記 Terms and List Operators (Leftward) の例を参照してください。) +

単項演算子の "\" はその後に続くものへのリファレンスを生成します。 perlreftut と perlref を参照してください。 この用法も文字列中のバックスラッシュも、後に続くものが展開されるのを 防ぐことになりますが、動作を混同しないでください。 \ reference backslash

Binding Operators binding operator, binding =~ !~

(拘束演算子)

二項演算子の "=~" は、スカラ式をパターンマッチに拘束します。 デフォルトで $_ の文字列を検索したり、変更したりする演算があります。 この演算子は、そのような演算を他の文字列に対して行なわせるようにするものです。 右引数は、検索パターン、置換、文字変換のいずれかです。 左引数は、デフォルトの $_ の代わりに検索、置換、文字変換の対象となるものです。 スカラコンテキストで使うと、返り値は一般的に演算の結果が成功したか否かです。 リストコンテキストでの振る舞いは演算子に依存します。 詳しくは /"Regexp Quote-Like Operators" を、これらの演算子を使った 例については perlretut を参照して下さい。

右引数が検索パターン、置換、文字変換ではなく、式であれば、 それは実行時に決まる検索パターンと解釈されます。 これは、内容が 2 回展開されることを意味することに注意してください; つまり:

  '\\' =~ q'\\';

は正しくありません; 正規表現エンジンは最終的にパターン \ を コンパイルしようとして、これは文法エラーと考えるからです。

二項演算子の "!~" は、返される値が論理否定されることを除いて "=~" と同じです。

Multiplicative Operators operator, multiplicative

(乗法演算子)

二項演算子の "*" は 2 つの数値の積を返します。 *

二項演算子の "/" は 2 つの数値の商を返します。 / slash

二項演算子の "%" は 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 コンパイラで実装された剰余演算子を使います。 この演算子は被演算子が負の場合の挙動が不確実ですが、 より高速です。 % remainder modulus mod

二項演算子の "x" は繰り返し演算子です。 スカラコンテキストまたは左辺値が括弧で括られていない場合は、 左被演算子を右被演算子に示す数だけ繰り返したもので構成される 文字列を返します。 リストコンテキストでは、左被演算子が括弧で括られているか、qw/STRING の 形のリストの場合、リストを繰り返します。 右オペランドが 0 か負数の場合、コンテキストによって、空文字列か空リストを 返します。 x

    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

Additive Operators operator, additive

(加法演算子)

二項演算子の "+" は 2 つの数値の和を返します。 +

二項演算子の "-" は 2 つの数値の差を返します。 -

二項演算子の "." は 2 つの文字列を連結します。 string, concatenation concatenation cat concat concatenate .

Shift Operators shift operator operator, shift << >> right shift left shift bitwise shift shl shr shift, right shift, left

(シフト演算子)

二項演算子の "<<" は左引数の値を、右引数で示すビット数だけ、 左にシフトした値を返します。 引数は整数でなければなりません。 (Integer Arithmetic も参照して下さい。)

二項演算子の ">>" は左引数の値を、右引数で示すビット数だけ、 右にシフトした値を返します。 引数は整数でなければなりません。 (Integer Arithmetic も参照して下さい。)

Perl での "<<" と ">>" は C での "<<" と ">>" を直接利用して 実装されていることに注意してください。 use integer (Integer Arithmetic を参照してください)が有効な場合、 C の符号付き整数が使われ、そうでない場合は C の符号なし整数が使われます。 どちらの場合も、この実装は Perl がビルドされた整数型のサイズ(32 ビットか 64 ビット)よりも大きい結果を生成することはありません。

整数の範囲をオーバーフローした場合の結果は、C でも未定義なので、未定義です。 言い換えると、32 ビット整数を使っているとき、1 << 32 は未定義です。 シフトするビット数として負の数を指定した場合も未定義です。

Named Unary Operators operator, named unary

(名前付き単項演算子)

さまざまな名前付き単項演算子が、引数を 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" と等価であることを 意味します。 -X filetest operator, filetest

"Terms and List Operators (Leftward)" も参照して下さい。

Relational Operators relational operator operator, relational

(比較演算子)

二項演算子の "<" は左引数が数値的に右引数よりも小さければ、 真を返します。

二項演算子の ">" は左引数が数値的に右引数よりも大きければ、 真を返します。

二項演算子の "<=" は左引数が数値的に右引数よりも小さいか等しければ、 真を返します。

二項演算子の ">=" は左引数が数値的に右引数よりも大きいか等しければ、 真を返します。

二項演算子の "lt" は左引数が文字列的に右引数よりも小さければ、 真を返します。

二項演算子の "gt" は左引数が文字列的に右引数よりも大きければ、 真を返します。

二項演算子の "le" は左引数が文字列的に右引数よりも小さいか等しければ、 真を返します。

二項演算子の "ge" は左引数が文字列的に右引数よりも大きいか等しければ、 真を返します。

Equality Operators equality equal equals operator, equality

(等価演算子)

二項演算子の "==" は左引数が数値的に右引数と等しければ、 真を返します。

二項演算子の "!=" は左引数が数値的に右引数と等しくなければ、 真を返します。

二項演算子の "<=>" は左引数が数値的に右引数より小さいか、等しいか、 大きいかに従って、-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 を返します。

二項演算子の "~~" はスマートマッチングとして働きます。 スマートマッチングについては perlsyn/"Smart matching in detail" で 述べられています。 この演算子は "~~" 機能が有効な場合にのみ使用可能です: 更なる情報については feature を参照してください。 ~~

"lt", "le", "ge", "gt", "cmp" は use locale が有効な場合は 現在のロケールで指定された辞書(ソート)順が使われます。 perllocale を参照して下さい。

Bitwise And operator, bitwise, and bitwise and &

(ビットごとの AND)

二項演算子の "&" は、両オペランドのビットごとに論理積をとって、 その結果を返します。 (Integer Arithmetic と Bitwise String Operators も参照して下さい。)

"&" は関係演算子より優先順位が低いので、例えば以下のようなテストでは、 かっこが重要です:

	print "Even\n" if ($x & 1) == 0;

Bitwise Or and Exclusive Or operator, bitwise, or bitwise or | operator, bitwise, xor bitwise xor ^

(ビットごとの OR と XOR)

二項演算子の "|" は、両オペランドのビットごとに論理和をとって、 その結果を返します。 (Integer Arithmetic と Bitwise String Operators も参照して下さい。)

二項演算子の "^" は、両オペランドのビットごとに排他論理和をとって、 その結果を返します。 (Integer Arithmetic と Bitwise String Operators も参照して下さい。)

"|" と "^" は関係演算子より優先順位が低いので、例えば以下のような テストでは、かっこが重要です:

	print "false\n" if (8 | 2) != 10;

C-style Logical And && logical and operator, logical, and

(C スタイルの論理積)

二項演算子の "&&" は、短絡の論理積演算を行ないます。 つまり、左被演算子が偽であれば、右被演算子は評価さえ 行なわれないということです。 評価される場合には、スカラーかリストかというコンテキストは、 右被演算子にも及びます。

C-style Logical Or || operator, logical, or

(C スタイルの論理和)

二項演算子の "||" は、短絡の論理和演算を行ないます。 つまり、左被演算子が真であれば、右被演算子は評価さえ 行なわれないということです。 評価される場合には、スカラーかリストかというコンテキストは、 右被演算子にも及びます。

C-style Logical Defined-Or // operator, logical, defined-or

(C スタイルの定義性和)

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, though

Perl では、フロー制御に使う場合の多少読みやすい && と || の 同義語として、and 演算子と or 演算子が用意されています (下記参照)。 短絡の動作は全く同じです。 しかし、"and" と "or" の優先順位はかなり低くしてあるので、引数に括弧を 使っていないリスト演算子のあとに続けて使う場合にも、 安心して使うことができます:

    unlink "alpha", "beta", "gamma"
	    or gripe(), next LINE;

C スタイルの演算子では以下のように書く必要があります。

    unlink("alpha", "beta", "gamma")
	    || (gripe(), next LINE);

代入で "or" を使うと、したいことと違うことになります。 以下を参照して下さい。

Range Operators operator, range range .. ...

(範囲演算子)

二項演算子の ".." は範囲演算子で、使われるコンテキストによって 異なる動作をする 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) ...
    next LINE if (1 .. /^$/);  # skip header lines, short for
                               #   ... 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) {
            # ...
        } else { # in body
            # ...
        }
    } 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);

Conditional Operator operator, conditional operator, ternary ternary ?:

(条件演算子)

三項演算子の "?:" は、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;

Assignment Operators assignment operator, assignment = **= += *= &= <<= &&= -= /= |= >>= ||= //= .= %= ^= x=

(代入演算子)

"=" は通常の代入演算子です。

代入演算子は C の場合と同様の働きをします。 つまり、

    $a += 2;

は以下と等価です。

    $a = $a + 2;

しかし、tie() のようなもので起こる左辺値の被参照による 副作用が 2 回起こることはありません。 他の代入演算も同様に働きます。 以下のものが認識されます:

    **=    +=    *=    &=    <<=    &&=
           -=    /=    |=    >>=    ||=
           .=    %=    ^=           //=
                 x=

グループ分けしてありますが、これらはいずれも代入演算子として 同じ優先順位となっています。

C と違って、スカラ代入演算子は有効な左辺値を作り出します。 代入を修正することは、代入を行なってから、その代入された変数を修正するのと 同じことになります。 これは、以下のように何かのコピーを変更したいときに便利です:

    ($tmp = $global) =~ tr [A-Z] [a-z];

同様に、

    ($a += 2) *= 3;

は以下と同等です。

    $a += 2;
    $a *= 3;

同様に、リストコンテキストでのリストへの代入は代入可能な左辺値のリストとなり、 スカラコンテキストでのリストへの代入は代入の右側の式で作成された 要素の数を返します。

Comma Operator comma operator, comma ,

(コンマ演算子)

二項演算子の "," はコンマ演算子です。 スカラコンテキストではその左引数を評価し、その値を捨てて、 それから右引数を評価し、その値を返します。 これはちょうど、C のコンマ演算子と同じです。

リストコンテキストでは、これは単にリスト引数の区切り文字で、 双方の引数をそのリストに挿入する働きがあります。 これらの引数も右から左に評価されます。

=> 演算子はコンマ演算子の同義語ですが、(5.001 以降)左辺値の単語 (単語文字で構成される全体)を必ず文字列として扱うという効果もあります。 これには他の場所では定数や関数呼び出しとして扱われる単語を含みます。

    use constant FOO => "something";
    my %h = ( FOO => 23 );

は、以下と等価です:

    my %h = ("FOO", 23);

これは 違います:

    my %h = ("something", 23);

左側の引数が単語でなかった場合、まずは式として解釈され、それから それを使った文字列値として解釈されます。

=> 演算子は、ハッシュのキーと値や、その他のリスト中の組となる 要素の関係を表現するのに便利です。

        %hash = ( $key => $value );
        login( $username => $password );

List Operators (Rightward) operator, list, rightward list operator

(リスト演算子 (右方向))

リスト演算子の右側のものにとって、リスト演算子はとても低い優先順位になります。 これによってコンマで区切った式をリスト演算子の引数として 置くことができます。 これよりも優先順位が低いものは、論理演算子の "and", "or", "not" のみで、 余分な括弧を付けないリスト演算子の呼び出しを評価するために使えます:

    open HANDLE, "filename"
	or die "Can't open: $!\n";

Terms and List Operators (Leftward) のリスト演算子の議論も参照して下さい。

Logical Not operator, logical, not not

(論理否定)

単項演算子の "not" は右側に来る式の否定を返します。 これは、優先順位がずっと低いことを除いては "!" と等価です。

Logical And operator, logical, and and

(論理積)

二項演算子の "and" は両側の式の論理積を返します。 これは、優先順位がずっと低いことを除けば && と等価です。 つまり、これも短絡演算を行ない、右側の式は左側の式が 「真」であった場合にのみ評価されます。

Logical or, Defined or, and Exclusive Or operator, logical, or operator, logical, xor operator, logical, defined or operator, logical, exclusive or or xor

(論理和と定義性和と排他論理和)

二項演算子の "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 Operators Missing From Perl operator, missing from perl & * typecasting (TYPE)

(Perl にない C の演算子)

C にあって Perl に無いものは以下の通りです:

Quote and Quote-like Operators operator, quote operator, quote-like q qq qx qw m qr s tr ' '' " "" // ` `` << escape sequence escape

(クォートとクォート風の演算子)

クォートはリテラル値であると考えるのが普通ですが、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 \n \r \f \b \a \e \x \0 \c \N

    \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 文字

\c に引き続く文字は、英字は大文字に変換された後、(ASCII システムでは) 7 番目のビット (0x40) を反転させることで別の文字にマッピングされます。 最も興味深い範囲は '@' から '_' (0x40 から 0x5F) で、結果として コントロール文字 0x00 から 0x1F になります。 '?' は DEL 文字にマッピングされます。 EBCDIC システムでは '@', 英字, '[', '\', ']', '^', '_', '?' のみが 動作し、結果として 0x00 から 0x1F と 0x7F になります。

注意: C やその他の言語と違って、Perl は垂直タブ (VT - ASCII 11) のための \v エスケープシーケンスはありませんが、\ck または \x0b が使えます。

以下のエスケープシーケンスが展開と文字変換の構文で利用可能です。 \l \u \L \U \E \Q

    \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 で定義されているものになります。 \N{name} のドキュメントに関しては、charnames を参照して下さい。

全てのシステムでは "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" を使う習慣がついていると、 いつか痛い目を見ることになるでしょう。

展開が行なわれる構文では、"$" や "@" で始まる変数が展開されます。 Subscripted variables such as $a[3] or $href->{key}[0] もまた配列やハッシュのスライスのように展開されます。 しかし、$obj->meth のようなメソッド呼び出しは展開されません。

配列やスライスの展開は、要素を順番に、$" の値で分割して展開されるので、 join $", @array の展開と等価です。 @* のような「句読点」配列は名前が @{*} のように中かっこで囲われている 場合にのみ展開されますが、特殊配列 @_, @+, @- は中かっこなしでも 展開されます。

\Q シーケンスの中にリテラルな $ や @ を入れることはできません。 エスケープされない $ や @ は対応する変数に変換されます。 一方、エスケープすると、リテラルな文字列 \$ が挿入されます。 m/\Quser\E\@\Qhost/ などという風に書く必要があります。

パターンはさらに、正規表現として展開が行なわれます。 これは、変数が展開された後の 2 回目のパスで行なわれるので、変数に 正規表現を含めておき、パターンの中へ展開することができます。 もし、そうしたくないのであれば、\Q を使うと変数の内容を文字通りに 展開することができます。

上記の振る舞いを除けば、Perl は 複数の段階を踏んで展開を行ないません。 特に、シェルのプログラマの期待とは裏腹に、 バッククォートはダブルクォートの中では展開されませんし、シングルクォートが ダブルクォートの中で使われても、変数の展開を妨げることは ありません。

Regexp Quote-Like Operators operator, regexp

(正規表現のクォート風の演算子)

以下はパターンマッチングと関連する行動に関するクォート風の演算子です。

Quote-Like Operators operator, quote-like

(クォート風演算子)

Gory details of parsing quoted constructs quote, gory details

(クォートされた構造のパースに関する詳細)

何か複数の解釈が可能な表現があった場合、Perl は最も確からしい解釈を 選択するために DWIM ("Do What I Mean")原則を使います。 この戦略は非常に成功したので、Perl プログラマはしばしば 自分が書いたものの矛盾を疑いません。 しかし時間がたつにつれて、Perl の概念は作者が本当に意味していたものから かなり変わりました。

この章では Perl がどのようにクォートされた構造を扱うかを 明確にしようと思います。 これを学ぼうとする最もよくある理由は正規表現の迷宮をほぐすためですが、 パースの初期ステップは全てのクォート演算子で同じなので、全て同時に扱います。

Perl のパースに関するルールで最も重要なものは以下で述べているうち 最初のものです。 つまり、クォートされた構造を処理するときは、Perl はまずその構造の 最後を探して、それから中身を解釈します。 このルールがわかれば、とりあえずはこの章の残りは読み飛ばしてもかまいません。 その他のルールは最初のルールに比べてユーザーの予想に反する頻度は はるかに少ないです。

以下で議論するパスには同時に実行されるものもありますが、 結果は同じことなので、別々に考えることにします。 クォート構造の種類によって、Perl が実行するパスの数は 1 から 4 まで異なりますが、これらのパスは常に同じ順番で実行されます。

I/O Operators operator, i/o operator, io io while filehandle <> @ARGV

(I/O 演算子)

知っておいた方がよい 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 と perlfunc/open を 参照して下さい。 stdin stdout sterr

<FILEHANDLE> がリストを必要とするコンテキストで用いられると、 1 要素に 1 行の入力行すべてからなるリストが返されます。 これを使うと簡単にかなり大きなデータになってしまいますので、 注意を要します。

<FILEHANDLE> は readline(*FILEHANDLE) とも書けます。 perlfunc/readline を参照して下さい。

ヌルファイルハンドル <> は特別で、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> を通常のものとして扱っているので、 うまく動作しません。)

最終的に、@ARGV に扱いたいと思っているファイル名が含まれるのであれば、 最初に <> を評価する前に @ARGV を変更することも可能です。 行番号 ($.) は、入力ファイルがあたかも 1 つの大きなファイルで あるかのように、続けてカウントされます。 個々のファイルごとにリセットする方法は、perlfunc/eof の例を 参照してください。

最初から @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]);

Constant Folding constant folding folding

(定数の畳み込み)

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) {  }
    }

と書くとコンパイラは、式が表わす数値をあらかじめ計算しますので、 インタプリタで計算する必要がなくなっています。

No-ops no-op nop

(無実行)

Perl は公式には無実行演算子はありませんが、裸の定数 0 と 1 は 特別に無効コンテキストでも警告を出さないことになっているので、 例えば安全に以下のように書けます:

    1 while foo();

Bitwise String Operators operator, bitwise, string

(ビット列演算子)

任意のサイズのビット列はビット単位演算子(~ | & ^)で操作できます。

二項ビット単位演算子のオペランドが異なった長さの文字列だった場合、 | と ^ の演算子は短い側のオペランドの右側に追加のゼロが ついているとみなします。 一方 & 演算子は長い方のオペランドが短い方に切り詰められます。 この拡張や短縮の粒度はバイト単位です。

    # 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

ビットベクタの個々のビットをどのように操作するかの情報については perlfunc/vec を参照して下さい。

Integer Arithmetic integer

(整数演算)

デフォルトでは、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 になります。

Floating-point Arithmetic floating-point floating point float real

(浮動小数点演算)

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 が使用するシステム丸めを信用せず、 代わりに自分自身で丸め関数を実装するべきです。

Bigger Numbers number, arbitrary precision

(より大きな数)

標準の 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 ライブラリを使う

うまく選んでください。