名前¶

perlvar - Perl で定義済みの変数

説明¶

変数名の文法¶

Perl の変数名は様々な形があります。 通常、変数名は英文字か下線で始まらなければならず、 任意の長さ(内部制限の 251 文字まで)を取ることができ、 英文字、数字、下線、特別な文字列である :: と ' を含むことができます。 この場合、最後の :: または ' の前は パッケージ限定子 として 扱われます; perlmod を参照して下さい。 ASCII ではない Unicode 文字は、"use utf8" が有効でない限り 文字として扱われません; そしていくらかより複雑な規則が適用されます; 詳しくは "Identifier parsing" in perldata を参照してください。

Perl の変数は、数字の列または一文字の句読点文字、2 文字並び( ^ (キャレット、CIRCUMFLEX ACCENT) に引き続いて [][A-Z^_?\] の文字の一つ) の場合もあります。 これらの名前は全て Perl によって特別な用途のために予約されています; 例えば、全て数字の名前は正規表現マッチの後の後方参照のデータを 保持するために用いられます。

Perl v5.6.0 から、キャレットが前置された、英数字からなる文字列の変数名も 使えます。 これらは ${^Foo} のような中かっこを使った 区切り付き変数形式で書かれなければなりません; 括弧はオプション ではありません。 ${^Foo} はコントロール-F の後に二つ o が続く名前を持つ スカラ変数と考えられます。 (変数名をこの形式で書くことや配列やハッシュの要素へのアクセスを指定する さらなる情報については "Demarcated variable names using braces" in perldata を参照してください。) これらの変数は Perl によって特別な用途のために予約されていますが、 ^_ (キャレット-下線)で始まるものは例外です。 ^_ で始まる名前は Perl の将来のバージョンで特別な意味を 持つことはありません; 従ってこれらの名前はプログラム中で安全に使用できます。 但し、$^_ そのものは 予約されます。

この種類の変数の添え字にアクセスするためにも境界を定める形式を 使わなければならない ことに注意してください; 例えば、ダブルクォート文字列の中で @{^CAPTURE} 変数の最初の要素にアクセスするには、 "${^CAPTURE}[0]" ではなく "${^CAPTURE[0]}" と書きます; 前者は ${^CAPTURE} という名前のスカラ変数へのリファレンスで、 正規表現エンジンによって設定された @{^CAPTURE} マジック配列の インデックス 0 ではありません。

数字、句読点で始まる Perl の識別子は package 宣言の 効果から逃れて、常に main パッケージにあるものとして扱われます。 さらに以下のものも逃れます:

    ENV      STDIN
    INC      STDOUT
    ARGV     STDERR
    ARGVOUT
    SIG

特に、新しい特別な ${^_XYZ} 変数はスコープ内の package 宣言に関わらず 常に main パッケージとして扱われます。

特殊変数¶

以下の名前は Perl では特別な意味を持ちます。 記号的な名前の多くは記憶法があるか、シェルでの類推が可能です。 それでも長い名前を使用したい場合には

    use English;

とプログラムの最初に書いてください。 これは、すべての短い名前の別名として、 カレントパッケージで長い名前を付けるものです。 awk から持ってきた中間的な名前を持っているものもあります。 さらなる情報については、どうか English を参照してください。

先に進む前に、変数のソート順に注意してください。 一般的に、変数を大文字小文字を無視して、ほとんど辞書順に並んでいます (${^UNICODE} や $^T のように、先頭についている { や ^ は 無視します)が、$_ と @_ は先頭に来ます。 同じ識別子を持つ変数については、スカラ、配列、ハッシュ、裸の単語の順に 並べています。

一般変数¶

$ARG

$_

The default input and pattern-searching space. The following pairs are equivalent:

デフォルトの入力とパターン検索のスペース。 以下の 2つは同値です:

    while (<>) {...}    # equivalent only in while!
    while (defined($_ = <>)) {...}

    while (<>) {...}    # while の中でのみ等価!
    while (defined($_ = <>)) {...}

    /^Subject:/
    $_ =~ /^Subject:/

    tr/a-z/A-Z/
    $_ =~ tr/a-z/A-Z/

    chomp
    chomp($_)

Here are the places where Perl will assume $_ even if you don't use it:

あなたが使いたくなくても Perl が $_ を仮定する場合がいくつかあります:

• The following functions use $_ as a default argument:

  以下の関数は $_ をデフォルト引数として使います:

  abs, alarm, chomp, chop, chr, chroot, cos, defined, eval, evalbytes, exp, fc, glob, hex, int, lc, lcfirst, length, log, lstat, mkdir, oct, ord, pos, print, printf, quotemeta, readlink, readpipe, ref, require, reverse (in scalar context only), rmdir, say, sin, split (for its second argument), sqrt, stat, study, uc, ucfirst, unlink, unpack.

  abs, alarm, chomp, chop, chr, chroot, cos, defined, eval, evalbytes, exp, fc, glob, hex, int, lc, lcfirst, length, log, lstat, mkdir, oct, ord, pos, print, printf, quotemeta, readlink, readpipe, ref, require, reverse (スカラコンテキストのみ), rmdir, say, sin, split (の 2 番目の引数), sqrt, stat, study, uc, ucfirst, unlink, unpack

• All file tests (-f, -d) except for -t, which defaults to STDIN. See "-X" in perlfunc

  デフォルトが STDIN である -t を除く全てのファイルテスト(-f, -d)。 "-X" in perlfunc を参照してください。

• The pattern matching operations m//, s/// and tr/// (aka y///) when used without an =~ operator.

  =~ 演算子なしで用いられたパターンマッチ演算 m//, s///, tr/// (またの名を y///)。

• The default iterator variable in a foreach loop if no other variable is supplied.

  foreach ループでの他の変数が補われなかった場合のデフォルトの繰り返し変数。

• The implicit iterator variable in the grep() and map() functions.

  grep() 関数と map() 関数の暗黙の繰り返し変数。

• The implicit variable of given().

  given() の暗黙の変数。

• The default place to put the next value or input record when a <FH>, readline, readdir or each operation's result is tested by itself as the sole criterion of a while test. Outside a while test, this will not happen.

  <FH>, readline, readdir, each が単独で while テストで テストされた場合の、次の値や入力レコードを入れるデフォルトの場所。 while テスト以外ではこれは起こりません。

$_ is a global variable.

$_ はグローバル変数です。

However, between perl v5.10.0 and v5.24.0, it could be used lexically by writing my $_. Making $_ refer to the global $_ in the same scope was then possible with our $_. This experimental feature was removed and is now a fatal error, but you may encounter it in older code.

しかし、perl v5.10.0 から v5.24.0 の間、 my $_ と書くことでこれをレキシカルに使うことが出来ました。 同じスコープで $_ がグローバルな $_ を参照するのは our $_ で可能になっていました。 この実験的機能は削除されて今では致命的エラーですが、 古いコードで見かけるかも知れません。

Mnemonic: underline is understood in certain operations.

記憶法: 下線はある操作を覚えるためのもの。

@ARG

@_

Within a subroutine the array @_ contains the parameters passed to that subroutine. Inside a subroutine, @_ is the default array for the array operators pop and shift.

サブルーチンに入るときには、配列 @_ はサブルーチンに渡された パラメータです。 サブルーチンの内部では、@_ は配列演算子 push, shift の デフォルト配列です。

See perlsub.

perlsub を参照して下さい。

$LIST_SEPARATOR

$"

When an array or an array slice is interpolated into a double-quoted string or a similar context such as /.../, its elements are separated by this value. Default is a space. For example, this:

配列や配列スライスがダブルクォートされた文字列あるいは /.../ のような 同様のコンテキスト展開されたとき、その要素はこの値で分割されます。 デフォルトは空白です。 例えば、以下のものは:

    print "The array is: @array\n";

is equivalent to this:

以下と等価です:

    print "The array is: " . join($", @array) . "\n";

Mnemonic: works in double-quoted context.

記憶法: ダブルクォートされた内容に対して動作します。

$PROCESS_ID

$PID

$$

The process number of the Perl running this script. Though you can set this variable, doing so is generally discouraged, although it can be invaluable for some testing purposes. It will be reset automatically across fork() calls.

このスクリプトを実行している Perl のプロセス番号です。 この変数に値を設定することは 可能 ですが、そうすることは一般的に 非推奨です; しかしこれは一部のテストの目的には計り知れない価値があります。 fork() 呼び出しがあると自動的にリセットされます。

Note for Linux and Debian GNU/kFreeBSD users: Before Perl v5.16.0 perl would emulate POSIX semantics on Linux systems using LinuxThreads, a partial implementation of POSIX Threads that has since been superseded by the Native POSIX Thread Library (NPTL).

Linux および Debian GNU/kFreeBSD ユーザーに対する注意: Perl v5.16.0 より 前では perl は LinuxThreads を使って Linux システムで POSIX の意味論を エミュレートしていました; これは POSIX Threads の部分的な実装で、 Native POSIX Thread Library (NPTL) で置き換えられました。

LinuxThreads is now obsolete on Linux, and caching getpid() like this made embedding perl unnecessarily complex (since you'd have to manually update the value of $$), so now $$ and getppid() will always return the same values as the underlying C library.

LinuxThreads は Linux では古いもので、このように getpid() を キャッシュすると組み込み perl が不必要に複雑になります ($$ の値を手動で 更新する必要があるからです); それで今では $$ と getppid() は常に 基礎となる C ライブラリと同じ値を返します。

Debian GNU/kFreeBSD systems also used LinuxThreads up until and including the 6.0 release, but after that moved to FreeBSD thread semantics, which are POSIX-like.

Debian GNU/kFreeBSD システムは 6.0 リリースまで LinuxThreads を 使っていましたが、その後は POSIX 風の FreeBSD スレッドの意味論に 移行しました。

To see if your system is affected by this discrepancy check if getconf GNU_LIBPTHREAD_VERSION | grep -q NPTL returns a false value. NTPL threads preserve the POSIX semantics.

あなたのシステムがこの非一貫性の影響を受けるかどうかを調べるには、 getconf GNU_LIBPTHREAD_VERSION | grep -q NPTL が偽を返すかどうかを チェックしてください。 NTPL スレッドは POSIX の意味論を保存します。

Mnemonic: same as shells.

記憶法: シェルと同じ。

$PROGRAM_NAME

$0

Contains the name of the program being executed.

実行されているプログラムの名前を示します。

On some (but not all) operating systems assigning to $0 modifies the argument area that the ps program sees. On some platforms you may have to use special ps options or a different ps to see the changes. Modifying the $0 is more useful as a way of indicating the current program state than it is for hiding the program you're running.

一部の(しかし全てではありません)オペレーティングシステムでは $0 に代入を行なうことで ps プログラムが見る引数エリアを修正します。 プラットフォームによっては、この変更を見るために 特殊な ps オプションや、 他の ps を使う必要があるものもあります。 $0 の修正は、実行しているプログラムを隠すよりは、 実行中のプログラムの状態を表示するときに、使うとよいでしょう。

Note that there are platform-specific limitations on the maximum length of $0. In the most extreme case it may be limited to the space occupied by the original $0.

$0 の最大長にはプラットフォーム固有の制限があることに注意してください。 最も極端な場合では、元の $0 で占められているサイズに制限されます。

In some platforms there may be arbitrary amount of padding, for example space characters, after the modified name as shown by ps. In some platforms this padding may extend all the way to the original length of the argument area, no matter what you do (this is the case for example with Linux 2.2).

プラットフォームによっては、任意の量のパッディングがある場合があります; 例えば、ps で見られる修正された名前の後の空白文字です。 プラットフォームによっては、このパッディングは、あなたが何をしたかに 関わらず、元の引数のエリア全体に拡張されるものもあります (例えば、これは Linux 2.2 の場合です)。

Note for BSD users: setting $0 does not completely remove "perl" from the ps(1) output. For example, setting $0 to "foobar" may result in "perl: foobar (perl)" (whether both the "perl: " prefix and the " (perl)" suffix are shown depends on your exact BSD variant and version). This is an operating system feature, Perl cannot help it.

BSD ユーザーへの注意: $0 に値をセットしても、ps(1) の出力から 完全に "perl" の文字列は取り除かれません。 例えば、$0 に "foobar" と設定すると、"perl: foobar (perl)" という 結果になります ("perl: " 接頭辞と" (perl)" 接尾辞が表示されるかどうかは 、正確な BSD の種類とバージョンに依存します)。 これはオペレーティングシステムの機能で、Perl は何もできません。

In multithreaded scripts Perl coordinates the threads so that any thread may modify its copy of the $0 and the change becomes visible to ps(1) (assuming the operating system plays along). Note that the view of $0 the other threads have will not change since they have their own copies of it.

マルチスレッドスクリプトでは、どのスレッドも自身の $0 のコピーを 変更できて、その変更が(OS が対応しているとして) ps(1) で見えるように、 Perl がスレッドを調整します。 他のスレッドが持っている $0 の見え方は(各自が自身のコピーを 持っているので)変わらないことに注意してください。

If the program has been given to perl via the switches -e or -E, $0 will contain the string "-e".

プログラムが perl に -e または -E オプション経由で与えられた場合、 $0 には文字列 "-e" を含みます。

On Linux as of perl v5.14.0 the legacy process name will be set with prctl(2), in addition to altering the POSIX name via argv[0] as perl has done since version 4.000. Now system utilities that read the legacy process name such as ps, top and killall will recognize the name you set when assigning to $0. The string you supply will be cut off at 16 bytes, this is a limitation imposed by Linux.

Linux では perl v5.14.0 以降、perl がバージョン 4.000 以降行っていた argv[0] 経由での POSIX 名の置き換えに加えて、 レガシープロセス名は prctl(2) で設定されます。 今では ps, top, killall のようにレガシープロセス名を読むユーティリティは $0 に代入することに設定される名前を認識します。 指定した文字列は 16 バイトに切り詰められます; これは Linux による 制限です。

Wide characters are invalid in $0 values. For historical reasons, though, Perl accepts them and encodes them to UTF-8. When this happens a wide-character warning is triggered.

ワイド文字は $0 の値としては不正です。 しかし、歴史的な理由により、Perl はこれを受け入れて、UTF-8 に エンコードします。 これが起きると、wide-character 警告が引き起こされます。

Mnemonic: same as sh and ksh.

記憶法: sh や ksh と同じ。

$REAL_GROUP_ID

$GID

$(

The real gid of this process. If you are on a machine that supports membership in multiple groups simultaneously, gives a space separated list of groups you are in. The first number is the one returned by getgid(), and the subsequent ones by getgroups(), one of which may be the same as the first number.

本プロセスの実 gid を示します。 同時に複数のグループに所属できるマシンでは、所属するグループをスペースで 区切ったリストが得られます。 最初の数値は、getgid() で返されるものです; その後に getgroups() が 返す値が続き、その中の 1 つは、最初の値と同じかもしれません。

However, a value assigned to $( must be a single number used to set the real gid. So the value given by $( should not be assigned back to $( without being forced numeric, such as by adding zero. Note that this is different to the effective gid ($)) which does take a list.

しかし、$( に代入された値は実際の gid に設定された値の 一つでなければなりません。 従って、 $( で与えられた値はゼロを足すことによって 数値化することなく $( に書き戻すべきではありません。 これはリストが得られる実行 GID ($)) とは違うことに注意してください。

You can change both the real gid and the effective gid at the same time by using POSIX::setgid(). Changes to $( require a check to $! to detect any possible errors after an attempted change.

POSIX::setgid() を使って、実 GID と実効 GID の両方を同時に変更できます。 $( を変更した場合は、変更しようとしたときに起こりうるエラーを検出するために $! をチェックする必要があります。

Mnemonic: parentheses are used to group things. The real gid is the group you left, if you're running setgid.

記憶法: 括弧は、グループ化に使われます。 setgid で実行中であれば、実 gid は left した、つまり離れたグループです。

$EFFECTIVE_GROUP_ID

$EGID

$)

The effective gid of this process. If you are on a machine that supports membership in multiple groups simultaneously, gives a space separated list of groups you are in. The first number is the one returned by getegid(), and the subsequent ones by getgroups(), one of which may be the same as the first number.

本プロセスの実効 gid を示します。 同時に複数のグループに所属できるマシンでは、所属するグループをスペースで 区切ったリストが得られます。 最初の数値は、getegid() で返されるものです; その後に getgroups() が 返す値が続き、その中の 1 つは、最初の値と同じかもしれません。

Similarly, a value assigned to $) must also be a space-separated list of numbers. The first number sets the effective gid, and the rest (if any) are passed to setgroups(). To get the effect of an empty list for setgroups(), just repeat the new effective gid; that is, to force an effective gid of 5 and an effectively empty setgroups() list, say $) = "5 5" .

同様に、$) へ代入する値はスペースで区切られた数値の リストでなければなりません。 最初の数値は実効 gid を設定し、残りの数値は(もしあれば) setgroups() に 渡されます。 setgroups() に空リストを渡したい場合は、単に新しい実効 gid を 繰り返してください; つまり、実効 gid を 5 にして、setgroups() に空リストを 渡したい場合は、 $) = "5 5" としてください。

You can change both the effective gid and the real gid at the same time by using POSIX::setgid() (use only a single numeric argument). Changes to $) require a check to $! to detect any possible errors after an attempted change.

POSIX::setgid() を使って、実効 GID と実 GID を同時に変更できます (1 つの数値引数だけが使えます)。 $) を変更した場合は、変更時に起こりうるエラーを検出するために $! の チェックが必要です。

$<, $>, $( and $) can be set only on machines that support the corresponding set[re][ug]id() routine. $( and $) can be swapped only on machines supporting setregid().

$<, $>, $(, $) は、実行するマシンで、 対応する set[re][ug]id() ルーティンがサポートされているときにのみ 設定可能です。 $( と $) の交換は、 setregid() がサポートされているマシンでのみ可能です。

Mnemonic: parentheses are used to group things. The effective gid is the group that's right for you, if you're running setgid.

記憶法: 括弧は、グループ化に使われます。 setgid で実行中であれば、実効 gid は right な、つまり正しいグループです。

$REAL_USER_ID

$UID

$<

The real uid of this process. You can change both the real uid and the effective uid at the same time by using POSIX::setuid(). Since changes to $< require a system call, check $! after a change attempt to detect any possible errors.

本プロセスの実 uid を示します。 POSIX::setuid() を使って、実効 UID と実 UID を同時に変更できます。 $< の変更にはシステムコールが必要なので、起こりうるエラーを 検出するために $! のチェックが必要です。

Mnemonic: it's the uid you came from, if you're running setuid.

記憶法: setuid で実行中であれば、そこ「から」来た uid です。

$EFFECTIVE_USER_ID

$EUID

$>

The effective uid of this process. For example:

本プロセスの実効 uid を示します。 例えば:

    $< = $>;            # set real to effective uid
    ($<,$>) = ($>,$<);  # swap real and effective uids

    $< = $>;            # 実 uid に実効 uid を設定
    ($<,$>) = ($>,$<);  # 実 uid と実効 uid を交換

You can change both the effective uid and the real uid at the same time by using POSIX::setuid(). Changes to $> require a check to $! to detect any possible errors after an attempted change.

POSIX::setuid() を使って、実効 UID と実 UID を同時に変更できます。 $> を変更した場合は、変更時に起こりうるエラーを検出するために $! のチェックが必要です。

$< and $> can be swapped only on machines supporting setreuid().

$< と $> の交換は、setreuid() をサポートしている マシンでのみ可能です。

Mnemonic: it's the uid you went to, if you're running setuid.

記憶法: setuid で実行中であれば、そこ へ 行く uid です。

$SUBSCRIPT_SEPARATOR

$SUBSEP

$;

The subscript separator for multidimensional array emulation. If you refer to a hash element as

多次元配列のエミュレートのための添え字の区切文字。 ハッシュの要素を

    $foo{$x,$y,$z}

it really means

のようにして参照すると、実際には以下のようになります

    $foo{join($;, $x, $y, $z)}

But don't put

しかし、以下のようにしてはいけません

    @foo{$x,$y,$z}     # a slice--note the @

    @foo{$x,$y,$z}     # スライス -- @ に注意

which means

これは以下の意味になります

    ($foo{$x},$foo{$y},$foo{$z})

Default is "\034", the same as SUBSEP in awk. If your keys contain binary data there might not be any safe value for $;.

デフォルトは "\034" で、awk の SUBSEP と同じです。 使おうとしている key の値がバイナリのデータを含むならば、 $; に設定する安全な値などはないことになります。

Consider using "real" multidimensional arrays as described in perllol.

perllol で記述している「本物の」多次元配列を使うようにしてください。

Mnemonic: comma (the syntactic subscript separator) is a semi-semicolon.

記憶法: コンマ (構文上の添え字区切り文字) はセミ－セミコロンなのです。

$a

$b

Special package variables when using sort(), see "sort" in perlfunc. Because of this specialness $a and $b don't need to be declared (using use vars, or our()) even when using the strict 'vars' pragma. Don't lexicalize them with my $a or my $b if you want to be able to use them in the sort() comparison block or function.

sort() を使うときの特殊パッケージ変数です; "sort" in perlfunc を 参照してください。 この特殊性により、$a と $b は、たとえ strict 'vars' プラグマを 使っているときでも (use vars や our() を使って) 宣言する必要が ありません。 これを sort() 比較ブロックや関数で使えるようにしたい場合は、 my $a や my $b としてレキシカル化しないでください。

%ENV

The hash %ENV contains your current environment. Setting a value in ENV changes the environment for any child processes you subsequently fork() off.

ハッシュ %ENV には、その時点の環境変数が設定されています。 ENV に値を設定することで、 以後に fork() した子プロセスの環境変数を変更します。

As of v5.18.0, both keys and values stored in %ENV are stringified.

v5.18.0 から、%ENV に補完されたキーと値の両方は文字列化されます。

    my $foo = 1;
    $ENV{'bar'} = \$foo;
    if( ref $ENV{'bar'} ) {
        say "Pre 5.18.0 Behaviour";
    } else {
        say "Post 5.18.0 Behaviour";
    }

Previously, only child processes received stringified values:

以前は、子プロセスのみが文字列化された値を受け取っていました:

    my $foo = 1;
    $ENV{'bar'} = \$foo;

    # Always printed 'non ref'
    system($^X, '-e',
           q/print ( ref $ENV{'bar'}  ? 'ref' : 'non ref' ) /);

This happens because you can't really share arbitrary data structures with foreign processes.

これは、外部プロセスと本当に任意のデータ構造を共有することができないために 起きます。

$OLD_PERL_VERSION

$]

The revision, version, and subversion of the Perl interpreter, represented as a decimal of the form 5.XXXYYY, where XXX is the version / 1e3 and YYY is the subversion / 1e6. For example, Perl v5.10.1 would be "5.010001".

5.XXXYYY 型式の小数で表現される Perl インタプリタの revision, version, subversion (XXX は version / 1e3、 YYY は subversion / 1e6)。 例えば、、Perl v5.10.1 は "5.010001" です。

This variable can be used to determine whether the Perl interpreter executing a script is in the right range of versions:

スクリプトの最初で、そのスクリプトを実行しているインタプリタのバージョンが 適切な範囲内にあるかを調べる、といったことができます:

    warn "No PerlIO!\n" if "$]" < 5.008;

When comparing $], numeric comparison operators should be used, but the variable should be stringified first to avoid issues where its original numeric value is inaccurate.

$] を比較するとき、数値比較演算子が使われるべきですが、 元の数値が不正確な場合の問題を避けるために、まず文字列化するべきです。

See also the documentation of use VERSION and require VERSION for a convenient way to fail if the running Perl interpreter is too old.

実行する Perl インタプリタが古すぎる場合に終了する便利な方法に ついては use VERSION と require VERSION のドキュメントも 参照して下さい。

See "$^V" for a representation of the Perl version as a version object, which allows more flexible string comparisons.

より柔軟な文字列比較が可能な version オブジェクトとしての Perl バージョン表現については "$^V" を参照してください。

The main advantage of $] over $^V is that it works the same on any version of Perl. The disadvantages are that it can't easily be compared to versions in other formats (e.g. literal v-strings, "v1.2.3" or version objects) and numeric comparisons are subject to the binary floating point representation; it's good for numeric literal version checks and bad for comparing to a variable that hasn't been sanity-checked.

$^V に対する $] の主な利点は、どのバージョンの Perl でも同様に 動作することです。 欠点は、他の型式のバージョン (例えばリテラルな v-文字列、"v1.2.3"、 バージョンオブジェクト) と簡単に比較できず、数値比較はバイナリ 浮動小数点表現になりがちです; 数値リテラルバージョンチェックとしては 良いですが、正気チェックをされていない変数と比較するには良くないです。

The $OLD_PERL_VERSION form was added in Perl v5.20.0 for historical reasons but its use is discouraged. (If your reason to use $] is to run code on old perls then referring to it as $OLD_PERL_VERSION would be self-defeating.)

$OLD_PERL_VERSION 型式は歴史的理由により Perl v5.20.0 に追加されましたが、 この使用は非推奨です。 ($] を使う理由が古い perl でコードを実行することなら、これを $OLD_PERL_VERSION して参照すると自滅することになります。)

Mnemonic: Is this version of perl in the right bracket?

記憶法: Perl のバージョンは、正しい範囲 (right bracket) にあるか。

$SYSTEM_FD_MAX

$^F

The maximum system file descriptor, ordinarily 2. System file descriptors are passed to exec()ed processes, while higher file descriptors are not. Also, during an open(), system file descriptors are preserved even if the open() fails (ordinary file descriptors are closed before the open() is attempted). The close-on-exec status of a file descriptor will be decided according to the value of $^F when the corresponding file, pipe, or socket was opened, not the time of the exec().

システムが使用するファイル記述子の最大値を示し、通常は 2 です。 システムファイル記述子は、exec() されたプロセスに渡されますが、 それ以降のファイル記述子は渡されません。 また、open() の実行中は、システムファイル記述子は、 たとえ open() が失敗しても、保存されます (通常のファイル記述子は、open() が実行される前にクローズされます)。 ファイル記述子の close-on-exec のステータスは、exec() 時ではなく、 対応するファイル、パイプソケットの open 時の $^F の値によって 決められます。

@F

The array @F contains the fields of each line read in when autosplit mode is turned on. See perlrun for the -a switch. This array is package-specific, and must be declared or given a full package name if not in package main when running under strict 'vars'.

自動 split モードが有効の場合、配列 @F には読み込んだ行のフィールドを 含みます。 -a オプションについては perlrun を参照してください。 この配列はパッケージ固有であり、もし strict 'vars' で実行していて パッケージ main 以外の場合は完全なパッケージ名で定義したり与えたり しなければなりません。

@INC

The array @INC contains the list of places that the do EXPR, require, or use constructs look for their library files. It initially consists of the arguments to any -I command-line switches, followed by the default Perl library, probably /usr/local/lib/perl. Prior to Perl 5.26, . -which represents the current directory, was included in @INC; it has been removed. This change in behavior is documented in PERL_USE_UNSAFE_INC and it is not recommended that . be re-added to @INC. If you need to modify @INC at runtime, you should use the use lib pragma to get the machine-dependent library properly loaded as well:

配列 @INC には、do EXPR, require, use によってライブラリファイルを 探すときに評価する場所のリストが納められています。 初期状態では、コマンドラインスイッチ -I の引数とデフォルトの Perl ライブラリディレクトリ (おそらく /usr/local/lib/perl5) を 順につなげたものです。 Perl 5.26 より前では、カレントディレクトリを表す . が @INC に含まれていました; これは削除されました。 この振る舞いの変更は PERL_USE_UNSAFE_INC に文書化されていて、 @INC に . を再追加するのは推奨されません。 実行時に @INC 変更する必要がある場合は、マシン依存のライブラリも正しく 読み込むために use lib を使うべきです:

    use lib '/mypath/libdir/';
    use SomeMod;

You can also insert hooks into the file inclusion system by putting Perl code directly into @INC. Those hooks may be subroutine references, array references or blessed objects. See "require" in perlfunc for details.

Perl のコードを直接 @INC に入れることで、ファイルインクルード機構に フックを挿入できます。 このフックはサブルーチンリファレンス、配列リファレンス、bless された オブジェクトが可能です。 詳細については "require" in perlfunc を参照してください。

%INC

The hash %INC contains entries for each filename included via the do, require, or use operators. The key is the filename you specified (with module names converted to pathnames), and the value is the location of the file found. The require operator uses this hash to determine whether a particular file has already been included.

ハッシュ %INC は、do, require, use 演算子によって インクルードされた、個々のファイル名をエントリとして持っています。 key は指定したファイル名(モジュール名はパス名に変換されます)で、 value は見つかった場所となっています。 require 演算子は、指定されたファイル名が既に インクルードされているかを、このハッシュを使って調べます。

If the file was loaded via a hook (e.g. a subroutine reference, see "require" in perlfunc for a description of these hooks), this hook is by default inserted into %INC in place of a filename. Note, however, that the hook may have set the %INC entry by itself to provide some more specific info.

ファイルがフック(つまりサブルーチンリファレンス; フックに関する 説明については "require" in perlfunc を参照してください)経由で読み込まれた 場合、このフックはデフォルトではファイル名の代わりに %INC に挿入されます。 しかし、フックはさらなる特定の情報を提供するために、自身で %INC エントリを セットするかもしれないことに注意してください。

$INC

As of 5.37.7 when an @INC hook is executed the index of the @INC array that holds the hook will be localized into the $INC variable. When the hook returns the integer successor of its value will be used to determine the next index in @INC that will be checked, thus if it is set to -1 (or undef) the traversal over the @INC array will be restarted from its beginning.

5.37.7 から、@INC フックが実行されるとき、フックを保持する @INC 配列のインデックスは $INC 変数にローカル化されます。 フックが整数を返すとき、その値の継承はチェックされる @INC の 次のインデックスを決定するために使われます; 従って、もしそれが -1 (または undef)に設定されるなら、 @INC 配列上の走査は最初から再開されます。

Normally traversal through the @INC array is from beginning to end (0 .. $#INC), and if the @INC array is modified by the hook the iterator may be left in a state where newly added entries are skipped. Changing this value allows an @INC hook to rewrite the @INC array and tell Perl where to continue afterwards. See "require" in perlfunc for details on @INC hooks.

通常、@INC 配列のトラバースは最初から最後まで (0 .. $#INC) であり、@INC 配列がフックによって変更された場合、 反復子は新しく追加されたエントリが読み飛ばされる状態のままになる 可能性があります。 この値を変更すると、@INC フックが @INC 配列を書き換え、 後でどこに進むかを Perl に指示できます。 @INC フックの詳細については "require" in perlfunc を参照してください。

$INPLACE_EDIT

$^I

The current value of the inplace-edit extension. Use undef to disable inplace editing.

置き換え編集の拡張子の値を示します。 置き換え編集を禁止するためには、undef を設定します。

Mnemonic: value of -i switch.

記憶法: -i スイッチの値。

@ISA

Each package contains a special array called @ISA which contains a list of that class's parent classes, if any. This array is simply a list of scalars, each of which is a string that corresponds to a package name. The array is examined when Perl does method resolution, which is covered in perlobj.

それぞれのパッケージには @ISA という名前の特殊配列があります; これは (もしあれば) そのクラスの親クラスのリストです。 この変数は単なるスカラのリストで、それぞれはパッケージ名に対応する 文字列です。 この配列は Perl がメソッド解決を行うときにチェックされます; これは perlobj に記述しています。

To load packages while adding them to @ISA, see the parent pragma. The discouraged base pragma does this as well, but should not be used except when compatibility with the discouraged fields pragma is required.

パッケージを読み込むために @ISA に追加するには、parent プラグマを 参照してください。 非推奨の base プラグマは同じことをしますが、 非推奨の fields プラグマとの互換性が必要な場合を除いて、 使うべきではありません。

$^M

By default, running out of memory is an untrappable, fatal error. However, if suitably built, Perl can use the contents of $^M as an emergency memory pool after die()ing. Suppose that your Perl were compiled with -DPERL_EMERGENCY_SBRK and used Perl's malloc. Then

デフォルトでは、メモリ不足はトラップできない致命的エラーとなります。 しかし、もし適切に構築されていれば、Perl は $^M の中身を die() した後の緊急用メモリとして使えます。 Perl が -DPERL_EMERGENCY_SBRK 付きでコンパイルされ、 Perl の malloc を使うと仮定します。そして、

    $^M = 'a' x (1 << 16);

would allocate a 64K buffer for use in an emergency. See the INSTALL file in the Perl distribution for information on how to add custom C compilation flags when compiling perl. To discourage casual use of this advanced feature, there is no English long name for this variable.

とすると緊急用の 64K のバッファを割り当てます。 perl をコンパイルするときに独自の C コンパイルフラグを追加する 方法についての情報は、Perl 配布パッケージに含まれている INSTALL ファイルを参照して下さい。 この拡張機能を気軽に使えないようにするために、 この変数には English の長い名前はありません。

This variable was added in Perl 5.004.

この変数は Perl 5.004 で追加されました。

${^MAX_NESTED_EVAL_BEGIN_BLOCKS}

This variable determines the maximum number eval EXPR/BEGIN or require/BEGIN block nesting that is allowed. This means it also controls the maximum nesting of use statements as well.

この変数は、eval EXPR/BEGIN や require/BEGIN ブロックのネストの許される最大数を決定します。 つまり、use 文のネストの最大数も制御します。

The default of 1000 should be sufficiently large for normal working purposes, and if you must raise it then you should be conservative with your choice or you may encounter segfaults from exhaustion of the C stack. It seems unlikely that real code has a use depth above 1000, but we have left this configurable just in case.

デフォルトの 1000 は、通常の作業目的に十分な大きさであるはずです; 値を大きくする必要がある場合は、慎重に選択する必要があります; そうしないと、C スタックの枯渇によって segfault が発生する可能性があります。 実際のコードが 1000 を超える使用深度を持つ可能性は低いと思われますが、 念のためこれを設定できるようにしてあります。

When set to 0 then BEGIN blocks inside of eval EXPR or require EXPR are forbidden entirely and will trigger an exception which will terminate the compilation and in the case of require will throw an exception, or in the case of eval return the error in $@ as usual.

0 に設定すると、eval EXPR や require EXPR 内の BEGIN ブロックは完全に禁止され、コンパイルを終了する 例外を引き起こします; require の場合は例外を投げ、eval の場合は通常どおり $@ にエラーを返します。

Consider the code

次のコードを考えます:

 perl -le'sub f { eval "BEGIN { f() }"; } f()'

each invocation of f() will consume considerable C stack, and this variable is used to cause code like this to die instead of exhausting the C stack and triggering a segfault. Needless to say code like this is unusual, it is unlikely you will actually need to raise the setting. However it may be useful to set it to 0 for a limited time period to prevent BEGIN{} blocks from being executed during an eval EXPR.

f() の各呼び出しはかなりの C スタックを消費し、この変数は、 このようなコードが C スタックを使い果たして segfault を 引き起こすのではなく、die させるために使われます。 このようなコードが普通ではないことは言うまでもありませんが、実際に 設定を上げる必要があることはあまりありません。 ただし、eval EXPR 中に BEGIN{} ブロックが実行されないようにするために、 限られた時間だけ 0 に設定すると便利な場合があります。

Note that setting this to 1 would NOT affect code like this:

これの 1 への設定は、次のようなコードには影響しません:

    BEGIN { $n += 1; BEGIN { $n += 2; BEGIN { $n += 4 } } }

The reason is that BEGIN blocks are executed immediately after they are completed, thus the innermost will execute before the ones which contain it have even finished compiling, and the depth will not go above 1. In fact the above code is equivalent to

その理由は、BEGIN ブロックは完了した直後に実行されるためです; したがって、最も内側のブロックは、それを含むブロックがコンパイルを 完了する前に実行され、深さは 1 を超えません。 実際、前述のコードは次と等価です:

    BEGIN { $n+=4 }
    BEGIN { $n+=2 }
    BEGIN { $n+=1 }

which makes it obvious why a ${^MAX_EVAL_BEGIN_DEPTH} of 1 would not block this code.

これは、なぜ ${^MAX_EVAL_BEGIN_DEPTH} を 1 にすることが このコードをブロックしないかを分かりやすくします。

Only BEGIN's executed inside of an eval or require (possibly via use) are affected.

eval または (use 経由を含む) require の内側で実行された BEGIN のみが影響を受けます。

$OSNAME

$^O

The name of the operating system under which this copy of Perl was built, as determined during the configuration process. For examples see "PLATFORMS" in perlport.

この Perl が構築されたオペレーティングシステムの名前です; これは設定プロセス中に決定されます。 例えば "PLATFORMS" in perlport を参照してください。

The value is identical to $Config{'osname'}. See also Config and the -V command-line switch documented in perlrun.

この値は $Config{'osname'} と同じです。 Config と、perlrun で文書化されている -V コマンドラインスイッチも参照して下さい。

In Windows platforms, $^O is not very helpful: since it is always MSWin32, it doesn't tell the difference between 95/98/ME/NT/2000/XP/CE/.NET. Use Win32::GetOSName() or Win32::GetOSVersion() (see Win32 and perlport) to distinguish between the variants.

Windows プラットフォームでは、$^O はあまり役に立ちません: これは常に MSWin32 となり、95/98/ME/NT/2000/XP/CE/.NET の違いを示していないからです。 これらを区別するためには、Win32::GetOSName() や Win32::GetOSVersion() を 使ってください (Win32 と perlport を参照してください)。

This variable was added in Perl 5.003.

この変数は Perl 5.003 で追加されました。

%SIG

The hash %SIG contains signal handlers for signals. For example:

ハッシュ %SIG にはシグナルのためのシグナルハンドラが含まれています。 例えば:

    sub handler {   # 1st argument is signal name
        my($sig) = @_;
        print "Caught a SIG$sig--shutting down\n";
        close(LOG);
        exit(0);
    }

    sub handler {   # 最初の引数はシグナル名
        my($sig) = @_;
        print "Caught a SIG$sig--shutting down\n";
        close(LOG);
        exit(0);
    }

    $SIG{'INT'}  = \&handler;
    $SIG{'QUIT'} = \&handler;
    ...
    $SIG{'INT'}  = 'DEFAULT';   # restore default action
    $SIG{'QUIT'} = 'IGNORE';    # ignore SIGQUIT

    $SIG{'INT'}  = \&handler;
    $SIG{'QUIT'} = \&handler;
    ...
    $SIG{'INT'}  = 'DEFAULT';   # デフォルトの動作を復元
    $SIG{'QUIT'} = 'IGNORE';    # SIGQUIT を無視

Using a value of 'IGNORE' usually has the effect of ignoring the signal, except for the CHLD signal. See perlipc for more about this special case. Using an empty string or undef as the value has the same effect as 'DEFAULT'.

'IGNORE' という値は通常はシグナルの効果を無視するために使いますが、 CHLD シグナルは例外です。 この特別な場合に関する詳細は perlipc を参照して下さい。 値として空文字列や undef を使うのは 'DEFAULT' と同じ効果です。

Here are some other examples:

以下にその他の例を示します:

    $SIG{"PIPE"} = "Plumber";   # assumes main::Plumber (not
                                # recommended)
    $SIG{"PIPE"} = \&Plumber;   # just fine; assume current
                                # Plumber
    $SIG{"PIPE"} = *Plumber;    # somewhat esoteric
    $SIG{"PIPE"} = Plumber();   # oops, what did Plumber()
                                # return??

    $SIG{"PIPE"} = "Plumber";   # main::Plumber を仮定します(非推奨)
    $SIG{"PIPE"} = \&Plumber;   # 問題なし; カレントの Plumber を仮定します
    $SIG{"PIPE"} = *Plumber;    # 少々難解
    $SIG{"PIPE"} = Plumber();   # げげ、Plumber() は何を返すの??

Be sure not to use a bareword as the name of a signal handler, lest you inadvertently call it.

裸の単語をシグナルハンドラの名前として使わないようにしてください; 不注意で呼び出すのを避けるためです。

Using a string that doesn't correspond to any existing function or a glob that doesn't contain a code slot is equivalent to 'IGNORE', but a warning is emitted when the handler is being called (the warning is not emitted for the internal hooks described below).

既存の関数に対応しない文字列や、コードスロットを含んでいないグロブを 使うのは、'IGNORE' と等価ですが、ハンドラが呼び出されると警告が 発生します(後述する内部フックでは警告は発生しません)。

If your system has the sigaction() function then signal handlers are installed using it. This means you get reliable signal handling.

システムに sigaction() 関数がある場合は、シグナルハンドラはそれを使って インストールされます。 これにより、信頼性のあるシグナルハンドリングが可能になります。

The default delivery policy of signals changed in Perl v5.8.0 from immediate (also known as "unsafe") to deferred, also known as "safe signals". See perlipc for more information.

デフォルトのシグナル配送ポリシーは Perl v5.8.0 に即時("unsafe"としても 知られます)から保留(「安全なシグナル」としても知られます)に変更されました。 さらなる情報については perlipc を参照してください。

Certain internal hooks can be also set using the %SIG hash. The routine indicated by $SIG{__WARN__} is called when a warning message is about to be printed. The warning message is passed as the first argument. The presence of a __WARN__ hook causes the ordinary printing of warnings to STDERR to be suppressed. You can use this to save warnings in a variable, or turn warnings into fatal errors, like this:

ある種の内部フックも %SIG ハッシュを使ってセットされます。 警告メッセージを表示しようとするときに $SIG{__WARN__} で 示されたルーチンが呼び出されます。 警告メッセージは最初の引数として渡されます。 __WARN__ フックがあると、通常の STDERR への警告の出力は行われません。 これを使って、警告メッセージを変数にいれたり、 あるいは以下のようにして警告を致命的エラーに変えたり出来ます:

    local $SIG{__WARN__} = sub { die $_[0] };
    eval $proggie;

As the 'IGNORE' hook is not supported by __WARN__, its effect is the same as using 'DEFAULT'. You can disable warnings using the empty subroutine:

__WARN__ では 'IGNORE' フックには対応していないので、 この効果は 'DEFAULT' を使うのと同じです。 空サブルーチンを使って警告を無効に出来ます:

    local $SIG{__WARN__} = sub {};

The routine indicated by $SIG{__DIE__} is called when a fatal exception is about to be thrown. The error message is passed as the first argument. When a __DIE__ hook routine returns, the exception processing continues as it would have in the absence of the hook, unless the hook routine itself exits via a goto &sub, a loop exit, or a die(). The __DIE__ handler is explicitly disabled during the call, so that you can die from a __DIE__ handler. Similarly for __WARN__.

$SIG{__DIE__} で示されるルーチンは 致命的な例外がまさに投げられようとするときに呼び出されます。 エラーメッセージは最初の引数として渡されます。 __DIE__ フックから戻ると、例外処理はフックがなかったかのように 再開されますが、フックルーチン自体が goto &sub、ループ終了、 die() によって終了した場合を除きます。 __DIE__ ハンドラは呼び出し中は明示的に無効になりますので、 __DIE__ ハンドラから die できます。 __WARN__ も同様です。

The $SIG{__DIE__} hook is called even inside an eval(). It was never intended to happen this way, but an implementation glitch made this possible. This used to be deprecated, as it allowed strange action at a distance like rewriting a pending exception in $@. Plans to rectify this have been scrapped, as users found that rewriting a pending exception is actually a useful feature, and not a bug.

$SIG{__DIE__} は eval() の中でも呼び出されます。 これは決してこのようになることを意図したものではありませんでしたが、 実装上のミスでこれが可能になっていました。 これは以前廃止予定でした; $@ で保留されている例外を書き換えるといった 変わった行動を離れた場所でできるようにしていたからです。 これを修正する計画は破棄されました; 保留されている例外を書き換えるというのは実際有用な機能であることがわかり、 またバグではないからです。

The $SIG{__DIE__} doesn't support 'IGNORE'; it has the same effect as 'DEFAULT'.

$SIG{__DIE__} は 'IGNORE' に対応していません; これは 'DEFAULT' と同じ効果です。

__DIE__/__WARN__ handlers are very special in one respect: they may be called to report (probable) errors found by the parser. In such a case the parser may be in inconsistent state, so any attempt to evaluate Perl code from such a handler will probably result in a segfault. This means that warnings or errors that result from parsing Perl should be used with extreme caution, like this:

__DIE__ と __WARN__ のハンドラは一つの点で非常に特別です: パーサによってエラー(であろうもの)を報告するために呼び出されることがある ことです。 このような場合、パーサは不安定な状態になっているかもしれないので、 ハンドラから Perl コードを評価しようとするとセグメンテーションフォールトが 発生するかもしれません。 Perl のパース中の警告やエラーは、以下のように非常に注意して扱うべきです;

    require Carp if defined $^S;
    Carp::confess("Something wrong") if defined &Carp::confess;
    die "Something wrong, but could not load Carp to give "
      . "backtrace...\n\t"
      . "To see backtrace try starting Perl with -MCarp switch";

Here the first line will load Carp unless it is the parser who called the handler. The second line will print backtrace and die if Carp was available. The third line will be executed only if Carp was not available.

一行目は、パーサが ハンドラ を 呼び出したのでなければ Carp を 読み込みます。 二行目 は、Carp が使えるならバックとレースを表示して die します。 三行目は Carp が使えないときにのみ実行されます。

Having to even think about the $^S variable in your exception handlers is simply wrong. $SIG{__DIE__} as currently implemented invites grievous and difficult to track down errors. Avoid it and use an END{} or CORE::GLOBAL::die override instead.

例外ハンドラの中で $^S を使おうなどとは考えてもいけません。 現在の実装の $SIG{__DIE__} は面倒を引き寄せ、エラーの追跡を困難にします。 これの代わりに END{} を使うか、CORE::GLOBAL::die を オーバーライドしてください。

See "die" in perlfunc, "warn" in perlfunc, "eval" in perlfunc, and warnings for additional information.

追加の情報については "die" in perlfunc, "warn" in perlfunc, "eval" in perlfunc, warnings を参照して下さい。

%{^HOOK}

This hash contains coderefs which are called when various perl keywords which are hard or impossible to wrap are called. The keys of this hash are named after the keyword that is being hooked, followed by two underbars and then a phase term; either "before" or "after".

このハッシュには、ラップが困難または不可能なさまざまな perl キーワードが呼び出されたときに呼び出される コードリファレンスが含まれています。 このハッシュのキーは、フックされているキーワードにちなんで 名前が付けられ、その後に二つのアンダーバーとフェーズ用語 ("before" または "after")が続きます。

Perl will throw an error if you attempt modify a key which is not documented to exist, or if you attempt to store anything other than a code reference or undef in the hash. If you wish to use an object to implement a hook you can use currying to embed the object into an anonymous code reference.

存在することが文書化されていないキーを変更しようとしたり、 コードリファレンスや undef 以外のものをハッシュに 保存しようとしたりすると、Perl はエラーを投げます。 フックを実装するためにオブジェクトを使用したい場合は、カリー化を 使って、オブジェクトに匿名コードリファレンスを埋め込むことができます。

Currently there is only one keyword which can be hooked, require, but it is expected that in future releases there will be additional keywords with hook support.

現在、フック可能なキーワードは require のみですが、将来のリリースでは フックに対応するキーワードが追加される予定です。

require__before

The routine indicated by ${^HOOK}{require__before} is called by require before it checks %INC, looks up @INC, calls INC hooks, or compiles any code. It is called with a single argument, the filename for the item being required (package names are converted to paths). It may alter this filename to change what file is loaded. If the hook dies during execution then it will block the require from executing.

${^HOOK}{require__before} で示されるルーチンは、 %INC をチェックしたり、@INC を検索したり、 INC フックを呼び出したり、任意のコードをコンパイルしたりする 前 に require によって呼び出されます。 このルーチンは単一の引数で呼び出されます; require されるアイテムのファイル名です (パッケージ名はパスに変換されます)。 このファイル名を変更して、ロードされるファイルを変更できます。 実行中にフックが die すると、require の実行がブロックされます。

In order to make it easy to perform an action with shared state both before and after the require keyword was executed the require__before hook may return a "post-action" coderef which will in turn be executed when the require completes. This coderef will be executed regardless as to whether the require completed succesfully or threw an exception. It will be called with the filename that was required. You can check %INC to determine if the require was successful. Any other return from the require__before hook will be silently ignored.

require キーワードが実行される前と後の両方で共有状態のアクションを 簡単に実行できるようにするために、require__before フックは、 require が完了したときに順番に実行される「アクション後」の コードリファレンスを返すことができます。 このコードリファレンスは、require が正常に完了したか、 例外が投げられたかにかかわらず実行されます。 これは、require されたファイル名と共に呼び出されます。 %INC をチェックして、require が成功したかどうかを判断できます。 require__before フックからのその他の戻り値は、暗黙に無視されます。

require__before hooks are called in FIFO order, and if the hook returns a code reference those code references will be called in FILO order. In other words if A requires B requires C, then require__before will be called first for A, then B and then C, and the post-action code reference will executed first for C, then B and then finally A.

require__before フックは FIFO 順に呼び出され、フックが コードリファレンスを返す場合、それらのコードリファレンスは FILO 順に呼び出されます。 つまり、A が B を require し、B が C を require する場合、 require__before が最初に A に対して呼び出され、次に B, C の順に 呼び出され、アクション後のコードリファレンスが最初に C に対して実行され、 次に B、最後に A の順に実行されます。

Well behaved code should ensure that when setting up a require__before hook that any prior installed hook will be called, and that their return value, if a code reference, will be called as well. See "require" in perlfunc for an example implementation.

適切に動作するコードでは、require__before フックを設定するときに、 以前にインストールされたフックが呼び出され、コードリファレンスの場合は その戻り値も呼び出されるようにする必要があります。 実装例については、"require" in perlfunc を参照してください。

require__after

The routine indicated by ${^HOOK}{require__after} is called by require after the require completes. It is called with a single argument, the filename for the item being required (package names are converted to paths). It is executed when the require completes, either via exception or via completion of the require statement, and you can check %INC to determine if the require was successful.

${^HOOK}{require__after} で示されるルーチンは、require が完了した 後 に require によって呼び出されます。 このルーチンは単一の引数で呼び出されます; require されるアイテムのファイル名です (パッケージ名はパスに変換されます)。 このルーチンは、例外または require 文の完了によって require が完了したときに実行されます; %INC をチェックして、require が成功したかどうかを判断できます。

The require__after hook is called for each required file in FILO order. In other words if A requires B requires C, then require__after will be called first for C, then B and then A.

require__after フックは、require されたファイルごとに FILO 順で 呼び出されます。 つまり、A が B を require し、B が C を require する場合、 require__after が最初に C に対して呼び出され、次に B、次に A に対して 呼び出されます。

$BASETIME

$^T

The time at which the program began running, in seconds since the epoch (beginning of 1970). The values returned by the -M, -A, and -C filetests are based on this value.

プログラムを実行開始した時刻を、紀元 (1970年の始め) からの秒数で 示したものです。 ファイルテスト -M、-A、-C で返される値は、この値に基づいています。

$PERL_VERSION

$^V

The revision, version, and subversion of the Perl interpreter, represented as a version object.

version オブジェクトとして表現される Perl インタプリタの revision, version, subversion。

This variable first appeared in perl v5.6.0; earlier versions of perl will see an undefined value. Before perl v5.10.0 $^V was represented as a v-string rather than a version object.

この変数は perl v5.6.0 で最初に現れました; それより前のバージョンでは 未定義値となります。 perl v5.10.0 以前では $^V は version オブジェクトではなく v-string 形式で表現されます。

$^V can be used to determine whether the Perl interpreter executing a script is in the right range of versions. For example:

$^V はスクリプトを実行している Perl インタプリタのバージョンが 正しい範囲に入っているかを調べるのに使えます。 例えば:

    warn "Hashes not randomized!\n" if !$^V or $^V lt v5.8.1

While version objects overload stringification, to portably convert $^V into its string representation, use sprintf()'s "%vd" conversion, which works for both v-strings or version objects:

移植性がある形で $^V を文字列表現に変換するために、 バージョンオブジェクトは文字列化をオーバーロードしますが、 v-文字列とバージョンオブジェクトの療養で動作する sprintf() の "%vd" 変換を使ってください。

    printf "version is v%vd\n", $^V;  # Perl's version

    printf "version is v%vd\n", $^V;  # Perl のバージョン

See the documentation of use VERSION and require VERSION for a convenient way to fail if the running Perl interpreter is too old.

実行する Perl インタプリタが古すぎる場合に終了する便利な方法については use VERSION と require VERSION のドキュメントを参照して下さい。

See also "$]" for a decimal representation of the Perl version.

Perl バージョンの 10 進表現については "$]" も参照して下さい。

The main advantage of $^V over $] is that, for Perl v5.10.0 or later, it overloads operators, allowing easy comparison against other version representations (e.g. decimal, literal v-string, "v1.2.3", or objects). The disadvantage is that prior to v5.10.0, it was only a literal v-string, which can't be easily printed or compared, whereas the behavior of $] is unchanged on all versions of Perl.

Perl 5.10.0 以降での、$] に対する $^V の主な利点は、これは演算子を オーバーロードするので、他のバージョン表現 (例えば 10 進数、 リテラルな v-文字列、"v1.2.3"、オブジェクト)との比較が簡単であることです。 v5.10.0 より前での欠点は、これは単なるリテラルな v-文字列であるため、 簡単に表示したり比較したり出来ないことです; 一方、 $] の振る舞いは全てのバージョンの Perl で変化しません。

Mnemonic: use ^V for a version object.

記憶法: ^V をバージョンオブジェクトに使います。

$EXECUTABLE_NAME

$^X

The name used to execute the current copy of Perl, from C's argv[0] or (where supported) /proc/self/exe.

Perl バイナリ自身が実行された時の名前を C の argv[0] または (対応していれば) /proc/self/exe から持ってきたものです。

Depending on the host operating system, the value of $^X may be a relative or absolute pathname of the perl program file, or may be the string used to invoke perl but not the pathname of the perl program file. Also, most operating systems permit invoking programs that are not in the PATH environment variable, so there is no guarantee that the value of $^X is in PATH. For VMS, the value may or may not include a version number.

ホスト OS に依存して、$^X の値は perl プログラムファイルの絶対パスかも しれませんし、相対パスかもしれませんし、perl を起動するために使われる 文字列ではありますが perl プログラムファイルのパス名ではないかもしれません。 また、ほとんどの OS は PATH 環境変数にない位置のプログラムを起動することを 許しているので、$^X の値が PATH にある保証はありません。 VMS では、この値はバージョン番号を含む場合も含まない場合もあります。

You usually can use the value of $^X to re-invoke an independent copy of the same perl that is currently running, e.g.,

通常は、現在実行中のものと同じ perl の独立したコピーを再起動するために $^X の値を使えます; つまり:

    @first_run = `$^X -le "print int rand 100 for 1..100"`;

But recall that not all operating systems support forking or capturing of the output of commands, so this complex statement may not be portable.

しかし、全ての OS が fork やコマンドの出力の捕捉に対応しているわけでは ないので、この複雑な文は移植性がないかもしれないことを忘れないでください。

It is not safe to use the value of $^X as a path name of a file, as some operating systems that have a mandatory suffix on executable files do not require use of the suffix when invoking a command. To convert the value of $^X to a path name, use the following statements:

$^X の値をファイルのパス名として使うのは安全ではありません; 実行ファイルに 固定の接尾辞があり、コマンドの起動時には接尾辞が不要な OS もあるからです。 $^X の値をパス名に変換するには、以下のコードを使ってください:

    # Build up a set of file names (not command names).
    use Config;
    my $this_perl = $^X;
    if ($^O ne 'VMS') {
        $this_perl .= $Config{_exe}
        unless $this_perl =~ m/$Config{_exe}$/i;
    }

    # (コマンド名ではなく)ファイル名を構築する。
    use Config;
    my $this_perl = $^X;
    if ($^O ne 'VMS') {
        $this_perl .= $Config{_exe}
        unless $this_perl =~ m/$Config{_exe}$/i;
    }

Because many operating systems permit anyone with read access to the Perl program file to make a copy of it, patch the copy, and then execute the copy, the security-conscious Perl programmer should take care to invoke the installed copy of perl, not the copy referenced by $^X. The following statements accomplish this goal, and produce a pathname that can be invoked as a command or referenced as a file.

多くの OS が Perl のプログラムファイルのコピーを作って、コピーにパッチを当て、 それを実行するための読み込み権限を全員に与えているので、セキュリティ 意識のある Perl プログラマは $^X で参照されているコピーではなく、 インストールされている perl を起動するように気をつけるべきです。 以下のコードはこの目的を達成し、コマンドとして起動したりファイルとして 参照するためのパス名を作成します。

    use Config;
    my $secure_perl_path = $Config{perlpath};
    if ($^O ne 'VMS') {
        $secure_perl_path .= $Config{_exe}
        unless $secure_perl_path =~ m/$Config{_exe}$/i;
    }

正規表現に関する変数¶

正規表現に関連する特殊変数のほとんどは副作用です。 Perl はマッチングに成功したときにこれらの変数を設定するので、変数を 使う前にマッチングの結果をチェックするべきです。 例えば:

    if( /P(A)TT(ER)N/ ) {
        print "I found $1 and $2\n";
    }

これらの変数は、異なる振る舞いを明示的に記しているいくつかの例外を除いて、 読み込み専用で動的スコープを持つ変数と同様に振る舞います。

正規表現変数のスコープ規則¶

正規表現変数を使うと、プログラマは現在の動的スコープ内で最後に 成功した 正規表現マッチングの状態にアクセスできます。

変数自体はグローバルでスコープはありませんが、変数がアクセスする データは動的スコープ変数と同様にスコープがあります; つまり、マッチングが成功するたびに、グローバル状態オブジェクトが 現在のブロックまたはファイルスコープにローカル化されたかのように 動作します。 (動的スコープと local キーワードの詳細については、 "Compound Statements" in perlsyn を参照してください。)

成功したマッチング には、m// 演算子によって実行されたものに加えて、 検索および置換演算子 s/// によって実行されたすべての成功した マッチングが含まれます。

次のコードを考えます:

    my @state;
    sub matchit {
        push @state, $1;            # pushes "baz"
        my $str = shift;
        $str =~ /(zat)/;            # matches "zat"
        push @state, $1;            # pushes "zat"
    }

    {
        $str = "foo bar baz blorp zat";
        $str =~ /(foo)/;            # matches "foo"
        push @state, $1;            # pushes "foo"
        {
            $str =~ /(pizza)/;      # does NOT match
            push @state, $1;        # pushes "foo"
            $str =~ /(bar)/;        # matches "bar"
            push @state, $1;        # pushes "bar"
            $str =~ /(baz)/;        # matches "baz"
            matchit($str);          # see above
            push @state, $1;        # pushes "baz"
        }
        $str =~ s/noodles/rice/;    # does NOT match
        push @state, $1;            # pushes "foo"
        $str =~ s/(blorp)/zwoop/;   # matches "blorp"
        push @state, $1;            # pushes "blorp"
    }
    # the following prints "foo, foo, bar, baz, zat, baz, foo, blorp"
    print join ",", @state;

まったく同じスコープ内でマッチングが成功するたびに、以前の成功した マッチングのマッチングコンテキストは上書きされますが、失敗したマッチングは 上書きされないことに注意してください。 また、内側のネストされたスコープでは、外側の動的スコープからの 以前の状態は、別の成功したマッチングによって上書きされるまで持続しますが、 内側のネストされたスコープが終了すると、内側の成功したマッチングが終了する 前に有効であったマッチングコンテキストが復元されます。

goto LABEL が動的スコープマッチングコンテキストとうまく 相互作用しない可能性があることは既知の問題です。 これは修正できない可能性があり、goto LABEL を避ける多くの正当な 理由の一つと考えられています。

性能問題¶

Perl では伝統的に、$`, $&, $' (または use English での 等価物) をコードのどこかで使うと、コードが引き続いてこれらの変数に アクセスするかもしれないので、引き続くすべての成功したパターンマッチングで マッチングした文字列のコピーを作ります。 これはプログラム全体に対してかなりの性能上の負荷を掛けるので、一般的に これらの変数の使用は非推奨です。

Perl 5.6.0 では、マッチングに成功したインデックスを提供する @- と @+ 動的配列が導入されました。 それで、たとえばこのようにできます:

    $str =~ /pattern/;

    print $`, $&, $'; # bad: performance hit

    print             # good: no performance hit
    substr($str, 0,     $-[0]),
    substr($str, $-[0], $+[0]-$-[0]),
    substr($str, $+[0]);

Perl 5.10.0 で /p マッチング演算子フラグと ${^PREMATCH}, ${^MATCH}, ${^POSTMATCH} 変数が導入され、/p でマークされた パターンのみが負荷を被るようにできるようになりました。

Perl 5.18.0 以降では、perl は三つの変数の存在を別々に注意するようになり、 必要な部分文字列のみをコピーするようになりました; 従って、次の場合は

    $`; $&; "abcdefgh" =~ /d/

perl は文字列のうち "abcd" の部分のみをコピーします。 これは次のようなものとは大きな違いになります

    $str = 'x' x 1_000_000;
    $&; # whoops
    $str =~ /x/g # one char copied a million times, not a million chars

Perl 5.20.0 では新しいコピーオンライトシステムがデフォルトで有効になり、 これらの変数に関するほとんどの性能問題は最終的に修正され、 これらをどこで使っても安全になりました。

Devel::NYTProf と Devel::FindAmpersand のモジュールは、コード中に これらの問題のあるマッチング変数の使用を探す助けになります。

$<digits> ($1, $2, ...)

Contains the subpattern from the corresponding set of capturing parentheses from the last successful pattern match in the current dynamic scope. (See "Scoping Rules of Regex Variables".)

現在の動的スコープで、最後に成功したパターンマッチングで対応する括弧の サブパターンにマッチングした文字列が入っています。 ("Scoping Rules of Regex Variables" を参照してください。)

Note there is a distinction between a capture buffer which matches the empty string a capture buffer which is optional. Eg, (x?) and (x)? The latter may be undef, the former not.

空文字列にマッチングする捕捉バッファと、オプションの捕捉バッファの 違いに注意してください。 例えば、(x?) と (x)? では、後者は undef かもしれませんが、 前者は違います。

These variables are read-only.

これらの変数はすべて読み込み専用です。

Mnemonic: like \digits.

記憶法: \(数字) のようなもの。

@{^CAPTURE}

An array which exposes the contents of the capture buffers, if any, of the last successful pattern match, not counting patterns matched in nested blocks that have been exited already.

最後に成功したパターンマッチングの (もしあれば) 捕捉バッファの内容を 露出させた配列; 既に終了したネストしたブロックの中でマッチングしたパターンは 考慮しません。

Note that the 0 index of @{^CAPTURE} is equivalent to $1, the 1 index is equivalent to $2, etc.

@{^CAPTURE} の添え字 0 は $1 と等価、 添え字 1 は $2 と等価、などであることに注意してください。

    if ("foal"=~/(.)(.)(.)(.)/) {
        print join "-", @{^CAPTURE};
    }

should output "f-o-a-l".

これは "f-o-a-l" を出力します。

See also "$<digits> ($1, $2, ...)", "%{^CAPTURE}" and "%{^CAPTURE_ALL}".

"$<数字> ($1, $2, ...)", "%{^CAPTURE}", "%{^CAPTURE_ALL}" も参照してください。

Note that unlike most other regex magic variables there is no single letter equivalent to @{^CAPTURE}. Also be aware that when interpolating subscripts of this array you must use the demarcated variable form, for instance

その他のほとんどの正規表現マジカル変数と異なり、 @{^CAPTURE} と等価な単一文字変数はないことに注意してください。 また、この配列の添え字を変数展開するときは、境界を定める変数形式を 使わなければならない ことにも注意してください; 例えば:

    print "${^CAPTURE[0]}"

see "Demarcated variable names using braces" in perldata for more information on this form and its uses.

この形式とその使用法に関するさらなる情報については "Demarcated variable names using braces" in perldata を参照してください。

This variable was added in 5.25.7

これは 5.25.7 で追加されました。

If you need access to this functionality in older Perls you can use this function immediately after your regexp.

古い Perl でこの機能にアクセスする必要がある場合は、 正規表現の直後にこの関数を使えます。

    sub get_captures {
        no strict 'refs';

        my $last_idx = scalar(@-) - 1;
        my @arr      = 1 .. $last_idx;
        my @ret      = map { $$_; } @arr;

        return @ret;
    }

$MATCH

$&

The string matched by the last successful pattern match. (See "Scoping Rules of Regex Variables".)

最後に成功したパターンマッチでマッチした文字列。 ("Scoping Rules of Regex Variables" を参照してください。)

See "Performance issues" above for the serious performance implications of using this variable (even once) in your code.

この変数を(一度でも)使うことによる重大な性能の問題については前述した "Performance issues" を参照してください。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

Mnemonic: like & in some editors.

記憶法: あるエディタの & ようなもの。

${^MATCH}

It is only guaranteed to return a defined value when the pattern was compiled or executed with the /p modifier.

パターンが /p 修飾子付きでコンパイルまたは実行された場合、 定義された値が返ることだけが保証されます。

This is similar to $& ($MATCH) except that to use it you must use the /p modifier when executing the pattern, and it does not incur the performance penalty associated with that variable.

これは $& ($MATCH) と同様ですが、 パターンを実行するときに /p 修飾子を使わなければならず、 この変数と関連付けられた性能上のペナルティを被りません。

See "Performance issues" above.

前述した "Performance issues" を参照してください。

This variable was added in Perl v5.10.0.

この変数は Perl v5.10.0 で追加されました。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

$PREMATCH

$`

The string preceding whatever was matched by the last successful pattern match. (See "Scoping Rules of Regex Variables").

最後の成功したパターンマッチでマッチした部分の前の文字列。 ("Scoping Rules of Regex Variables" を参照してください)。

See "Performance issues" above for the serious performance implications of using this variable (even once) in your code.

この変数を(一度でも)使うことによる重大な性能の問題については前述した "Performance issues" を参照してください。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

Mnemonic: ` often precedes a quoted string.

記憶法: ` は多くの場合クォートされた文字列の前にある。

${^PREMATCH}

It is only guaranteed to return a defined value when the pattern was executed with the /p modifier.

パターンが /p 修飾子付きでコンパイルまたは実行された場合、 定義された値が返ることだけが保証されます。

This is similar to $` ($PREMATCH) except that to use it you must use the /p modifier when executing the pattern, and it does not incur the performance penalty associated with that variable.

これは $` ($PREMATCH) と同様ですが、 パターンを実行するときに /p 修飾子を使わなければならず、 この変数と関連付けられた性能上のペナルティを被りません。

See "Performance issues" above.

前述した "Performance issues" を参照してください。

This variable was added in Perl v5.10.0.

この変数は Perl v5.10.0 で追加されました。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

$POSTMATCH

$'

The string following whatever was matched by the last successful pattern match. (See "Scoping Rules of Regex Variables"). Example:

最後の成功したパターンマッチでマッチした部分に続く文字列。 ("Scoping Rules of Regex Variables" を参照してください)。 例:

    local $_ = 'abcdefghi';
    /def/;
    print "$`:$&:$'\n";       # prints abc:def:ghi

    local $_ = 'abcdefghi';
    /def/;
    print "$`:$&:$'\n";       # abc:def:ghi を表示

See "Performance issues" above for the serious performance implications of using this variable (even once) in your code.

この変数を(一度でも)使うことによる重大な性能の問題については前述した "Performance issues" を参照してください。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

Mnemonic: ' often follows a quoted string.

記憶法: ' は多くの場合クォートされた文字列の後にある。

${^POSTMATCH}

It is only guaranteed to return a defined value when the pattern was compiled or executed with the /p modifier.

パターンが /p 修飾子付きでコンパイルまたは実行された場合、 定義された値が返ることだけが保証されます。

This is similar to $' ($POSTMATCH) except that to use it you must use the /p modifier when executing the pattern, and it does not incur the performance penalty associated with that variable.

これは $' ($POSTMATCH) と同様ですが、 パターンを実行するときに /p 修飾子を使わなければならず、 この変数と関連付けられた性能上のペナルティを被りません。

See "Performance issues" above.

前述した "Performance issues" を参照してください。

This variable was added in Perl v5.10.0.

この変数は Perl v5.10.0 で追加されました。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

$LAST_PAREN_MATCH

$+

The text matched by the highest used capture group of the last successful search pattern. (See "Scoping Rules of Regex Variables"). It is logically equivalent to the highest numbered capture variable ($1, $2, ...) which has a defined value.

最後に検索されたパターンの最大の使われたの捕捉グループにマッチした文字列。 ("Scoping Rules of Regex Variables" を参照してください)。 これは、定義されている最大の番号の捕捉変数 ($1, $2, ...) と論理的に等価です。

This is useful if you don't know which one of a set of alternative patterns matched. For example:

わからないような場合に使うと便利です。 例えば:

    /Version: (.*)|Revision: (.*)/ && ($rev = $+);

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

Mnemonic: be positive and forward looking.

記憶法: ポジティブで前向き。

$LAST_SUBMATCH_RESULT

$^N

The text matched by the used group most-recently closed (i.e. the group with the rightmost closing parenthesis) of the last successful match. (See "Scoping Rules of Regex Variables").

最近のマッチングに成功した検索パターンのうち、一番最近に閉じられた使われた グループ(つまり、一番右の閉じかっこのグループ)にマッチングしたテキスト。 ("Scoping Rules of Regex Variables" を参照してください)。

This is subtly different from $+. For example in

これは $+ とわずかに異なります。 例えば次のものは

    "ab" =~ /^((.)(.))$/

we have

次の結果になります

    $1,$^N   have the value "ab"
    $2       has  the value "a"
    $3,$+    have the value "b"

This is primarily used inside (?{...}) blocks for examining text recently matched. For example, to effectively capture text to a variable (in addition to $1, $2, etc.), replace (...) with

これは主として最近マッチしたテキストを調べるために (?{...}) ブロックの 中で使われます。 例えば、($1, $2 などに加えて) テキストを変数に効率的に捕捉するには、 (...) を以下で置き換えます:

    (?:(...)(?{ $var = $^N }))

By setting and then using $var in this way relieves you from having to worry about exactly which numbered set of parentheses they are.

$var をこの方法で設定してから使うことで、かっこの組の番号について 気にしなくてすむようになります。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

This variable was added in Perl v5.8.0.

この変数は Perl v5.8.0 で追加されました。

Mnemonic: the (possibly) Nested parenthesis that most recently closed.

記憶法: もっとも最近閉じられた、(おそらく) ネストした (Nested) かっこ。

@LAST_MATCH_END

@+

This array holds the offsets of the ends of the last successful match and any matching capture buffers that the pattern contains. (See "Scoping Rules of Regex Variables")

この配列は、最後に成功したマッチングの末尾へのオフセットと、 パターンが含むすべてのマッチング捕捉バッファを保持します。 ("Scoping Rules of Regex Variables" を参照してください。)

The number of elements it contains will be one more than the number of capture buffers in the pattern, regardless of which capture buffers actually matched. You can use this to determine how many capture buffers there are in the pattern. (As opposed to @- which may have fewer elements.)

含まれる要素の数は、どの捕捉バッファが実際にマッチングしたかに関係なく、 パターン内の捕捉バッファの数よりも一つ多くなります。 これを使って、パターン内に捕捉バッファがいくつあるかを決定できます。 (要素の数が少なくなる @- とは対照的です)。

$+[0] is the offset into the string of the end of the entire match. This is the same value as what the pos function returns when called on the variable that was matched against. The nth element of this array holds the offset of the nth submatch, so $+[1] is the offset past where $1 ends, $+[2] the offset past where $2 ends, and so on. You can use $#+ to determine how many subgroups were in the last successful match. See the examples given for the @- variable.

$+[0] はマッチ全体の文字列の最後へのオフセットです。 これはマッチした変数に対して pos 関数を呼び出したときの返り値と同じです。 この配列の n 番目の要素は n 番目のサブマッチのオフセットを 保持しているので、$+[1] は過去の $1 の終わりのオフセット、$+[2] は $2 のオフセット、という形になります。 $#+ は最後に成功したマッチでいくつサブグループがあるかを決定するのに 使えます。 @- 変数の例を参照して下さい。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

This variable was added in Perl v5.6.0.

この変数は Perl v5.6.0 で追加されました。

%{^CAPTURE}

%LAST_PAREN_MATCH

%+

Similar to @+, the %+ hash allows access to the named capture buffers, should they exist, in the last successful match in the currently active dynamic scope. (See "Scoping Rules of Regex Variables").

@+ と同様、%+ ハッシュは、現在アクティブな動的スコープで最後に成功した マッチングの名前付き捕捉バッファ(存在すれば)へのアクセスを可能にします。 ("Scoping Rules of Regex Variables" を参照してください)。

For example, $+{foo} is equivalent to $1 after the following match:

例えば、$+{foo} は以下のマッチングの後の $1 と等価です:

    'foo' =~ /(?<foo>foo)/;

The keys of the %+ hash list only the names of buffers that have captured (and that are thus associated to defined values).

%+ ハッシュのキーは捕捉された(従って定義された値と結びついている) バッファの名前のみの一覧です。

If multiple distinct capture groups have the same name, then $+{NAME} will refer to the leftmost defined group in the match.

同じ名前の複数の異なる補足グループがある場合、 $+{NAME} はマッチングの中で一番左側に定義されているグループを 参照します。

The underlying behaviour of %+ is provided by the Tie::Hash::NamedCapture module.

%+ の基礎となる振る舞いは Tie::Hash::NamedCapture モジュールで 提供されています。

Note: %- and %+ are tied views into a common internal hash associated with the last successful regular expression. Therefore mixing iterative access to them via each may have unpredictable results. Likewise, if the last successful match changes, then the results may be surprising.

注意: %- and %+ は最後に成功した正規表現と関連付けられた共通の 内部ハッシュと tie されたビューです。 従って、each 経由で混ざった反復アクセスを行うと、予測不能の結果となります。 同様に、最後に成功したマッチングを変更すると、結果は驚くべきものとなります。

This variable was added in Perl v5.10.0. The %{^CAPTURE} alias was added in 5.25.7.

この変数は Perl v5.10.0 で追加されました。 %{^CAPTURE} の別名は 5.25.7 で追加されました。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

@LAST_MATCH_START

@-

This array holds the offsets of the beginnings of the last successful match and any capture buffers it contains. (See "Scoping Rules of Regex Variables").

この配列は、最後に成功したマッチングの先頭へのオフセットと、 パターンが含むすべてのマッチング捕捉バッファを保持します。 ("Scoping Rules of Regex Variables" を参照してください。)

The number of elements it contains will be one more than the number of the highest capture buffers (also called a subgroup) that actually matched something. (As opposed to @+ which may have more elements.)

含まれる要素の数は、実際に何かにマッチングした最も高い捕捉バッファ (サブグループとも呼ばれる)の数よりも一つ多くなります (要素の数が多くなる @+ とは対照的です)。

$-[0] is the offset of the start of the last successful match. $-[n] is the offset of the start of the substring matched by n-th subpattern, or undef if the subpattern did not match.

$-[0] は最後に成功したマッチの先頭のオフセットです。 $-[n] は n 番目のサブパターンにマッチした部分文字列の先頭の オフセットです; サブパターンがマッチしなかった場合は undef です。

Thus, after a match against $_, $& coincides with substr $_, $-[0], $+[0] - $-[0]. Similarly, $n coincides with substr $_, $-[n], $+[n] - $-[n] if $-[n] is defined, and $+ coincides with substr $_, $-[$#-], $+[$#-] - $-[$#-]. One can use $#- to find the last matched subgroup in the last successful match. Contrast with $#+, the number of subgroups in the regular expression.

従って $_ のマッチの後、$n は substr $_, $-[0], $+[0] - $-[0] と一致します。 同様に、$n は、$-[n] が定義されていれば substr $_, $-[n], $+[n] - $-[n] と一致し、 $+ は substr $_, $-[$#-], $+[$#-] - $-[$#-] と一致します。 $#- は直前に成功したマッチで最後のマッチしたサブグループを 探すのに使えます。 正規表現でのサブグループの数である $#+ と対照的です。

$-[0] is the offset into the string of the beginning of the entire match. The nth element of this array holds the offset of the nth submatch, so $-[1] is the offset where $1 begins, $-[2] the offset where $2 begins, and so on.

$-[0] はマッチ全体の先頭の文字列へのオフセットです。 この配列の n 番目の要素は n 番目のサブマッチへの オフセットを保持しますので、$-[1] は $1 の先頭への オフセット、$-[2] は $2 の先頭へのオフセット、などとなります。

After a match against some variable $var:

ある変数 $var でマッチした後、以下のようになります。

$` is the same as substr($var, 0, $-[0])

($` は substr($var, 0, $-[0]) と同じです)

$& is the same as substr($var, $-[0], $+[0] - $-[0])

($& は substr($var, $-[0], $+[0] - $-[0]) と同じです)

$' is the same as substr($var, $+[0])

($' は substr($var, $+[0]) と同じです)

$1 is the same as substr($var, $-[1], $+[1] - $-[1])

($1 は substr($var, $-[1], $+[1] - $-[1]) と同じです)

$2 is the same as substr($var, $-[2], $+[2] - $-[2])

($2 は substr($var, $-[2], $+[2] - $-[2]) と同じです)

$3 is the same as substr($var, $-[3], $+[3] - $-[3])

($3 は substr $var, $-[3], $+[3] - $-[3]) と同じです)

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

This variable was added in Perl v5.6.0.

この変数は Perl v5.6.0 で追加されました。

%{^CAPTURE_ALL}

%-

Similar to %+, this variable allows access to the named capture groups in the last successful match in the currently active dynamic scope. (See "Scoping Rules of Regex Variables"). To each capture group name found in the regular expression, it associates a reference to an array containing the list of values captured by all buffers with that name (should there be several of them), in the order where they appear.

%+ と同様、この変数は現在アクティブな動的スコープで最後に成功した マッチングの名前付き捕捉グループへのアクセスを可能にします。 ("Scoping Rules of Regex Variables" を参照してください)。 正規表現中に捕捉グループ名が現れるごとに、その名前のグループ全てで (複数あるでしょう)捕捉されている値のリストを出現順で含む配列への リファレンスと関連付けられます。

Here's an example:

以下は例です:

    if ('1234' =~ /(?<A>1)(?<B>2)(?<A>3)(?<B>4)/) {
        foreach my $bufname (sort keys %-) {
            my $ary = $-{$bufname};
            foreach my $idx (0..$#$ary) {
                print "\$-{$bufname}[$idx] : ",
                      (defined($ary->[$idx])
                          ? "'$ary->[$idx]'"
                          : "undef"),
                      "\n";
            }
        }
    }

would print out:

とすると、以下のものが表示されます:

    $-{A}[0] : '1'
    $-{A}[1] : '3'
    $-{B}[0] : '2'
    $-{B}[1] : '4'

The keys of the %- hash correspond to all buffer names found in the regular expression.

%- ハッシュのキーは正規表現で見つかった全てのバッファ名に対応します。

The behaviour of %- is implemented via the Tie::Hash::NamedCapture module.

%- の振る舞いは Tie::Hash::NamedCapture モジュールを使って 実装されています。

Note: %- and %+ are tied views into a common internal hash associated with the last successful regular expression. Therefore mixing iterative access to them via each may have unpredictable results. Likewise, if the last successful match changes, then the results may be surprising. See "Scoping Rules of Regex Variables".

注意: %- and %+ は最後に成功した正規表現と関連付けられた共通の 内部ハッシュと tie されたビューです。 従って、each 経由で混ざった反復アクセスを行うと、予測不能の結果となります。 同様に、最後に成功したマッチングを変更すると、結果は驚くべきものとなります。 "Scoping Rules of Regex Variables" を参照してください。

This variable was added in Perl v5.10.0. The %{^CAPTURE_ALL} alias was added in 5.25.7.

この変数は Perl v5.10.0 で追加されました。 %{^CAPTURE_ALL} の別名は 5.25.7 で追加されました。

This variable is read-only, and its value is dynamically scoped.

この変数は読み込み専用で、その値は動的スコープを持ちます。

${^LAST_SUCCESSFUL_PATTERN}

The last successful pattern that matched in the current scope. The empty pattern defaults to matching to this. For instance:

現在のスコープでマッチングした、最後に成功したパターン。 からパターンはこれにマッチングします。 例えば:

    if (m/foo/ || m/bar/) {
        s//BLAH/;
    }

and

および

    if (m/foo/ || m/bar/) {
        s/${^LAST_SUCCESSFUL_PATTERN}/BLAH/;
    }

are equivalent.

は等価です。

You can use this to debug which pattern matched last, or to match with it again.

どのパターンが最後にマッチングしたかをデバッグしたり、 再び同じものでマッチングするためにこれを使えます。

Added in Perl 5.37.10.

Perl 5.37.10 で追加されました。

$LAST_REGEXP_CODE_RESULT

$^R

The result of evaluation of the last successful (?{ code }) regular expression assertion (see perlre).

最後に成功した (?{ code }) 正規表現アサートの評価の結果です (perlre を参照して下さい)。

This variable may be written to, and its value is scoped normally, unlike most other regex variables.

この変数は、その他のほとんどの正規表現変数と異なり、 書き込み可能で、その値は通常のスコープを持ちます。

This variable was added in Perl 5.005.

この変数は Perl 5.005 で追加されました。

${^RE_COMPILE_RECURSION_LIMIT}

The current value giving the maximum number of open but unclosed parenthetical groups there may be at any point during a regular expression compilation. The default is currently 1000 nested groups. You may adjust it depending on your needs and the amount of memory available.

正規表現コンパイル中の任意の時点での開いているけれども閉じていない かっこグループの最大値として与えられている現在の値。 デフォルトは現在の所 1000 ネストグループです。 これは必要性と利用可能なメモリ量に合わせて調整できます。

This variable was added in Perl v5.30.0.

この変数は Perl v5.30.0 で追加されました。

${^RE_DEBUG_FLAGS}

The current value of the regex debugging flags. Set to 0 for no debug output even when the re 'debug' module is loaded. See re for details.

正規表現デバッグフラグの現在の値です。 0 をセットすると、re 'debug' モジュールが読み込まれていてもデバッグ出力を 行いません。 詳細については re を参照してください。

This variable was added in Perl v5.10.0.

この変数は Perl v5.10.0 で追加されました。

${^RE_TRIE_MAXBUF}

Controls how certain regex optimisations are applied and how much memory they utilize. This value by default is 65536 which corresponds to a 512kB temporary cache. Set this to a higher value to trade memory for speed when matching large alternations. Set it to a lower value if you want the optimisations to be as conservative of memory as possible but still occur, and set it to a negative value to prevent the optimisation and conserve the most memory. Under normal situations this variable should be of no interest to you.

どれくらい正規表現の最適化を行い、どれくらいのメモリを利用するかを制御します。 デフォルトではこの値は 65536 で、512kB の一時キャッシュに相当します。 この値を大きくすると、大きなものとマッチングするときに速度を重視して多くの メモリを使います。 もしできるだけ保守的なメモリ消費をするけれども使うこともある、というように 最適化したい場合は小さい値を設定します; 負の値を設定すると最適化は行わず、 最大限メモリを節約します。 通常の状況では、この変数はあなたの興味を引くものではないでしょう。

This variable was added in Perl v5.10.0.

この変数は Perl v5.10.0 で追加されました。

ファイルハンドル関連の変数¶

現在選択されているファイルハンドルに依存する変数の場合には、代わりに IO::Handle オブジェクトに関するオブジェクトメソッドを呼び出して 設定できますが、通常の組み込み変数よりは効率が落ちます。 (以下の要約では HANDLE という語を含んでいます。) まず最初に必ず、

    use IO::Handle;

と書き、その後で以下のように書くか、

    method HANDLE EXPR

もしくはより安全に以下のように書きます:

    HANDLE->method(EXPR)

それぞれのメソッドは、IO::Handle 属性の昔の値を返します。 メソッドはそれぞれ EXPR をとることができ、指定した場合には、問題の IO::Handle 属性の新しい値を指定することになります。 指定しない場合には、多くのメソッドでは現在の値に対して何もしませんが、 autoflush() では 1 を指定されたものとします。

IO::Handle クラスを読み込むのはコストの高い操作なので、 通常の組み込み変数の使い方を覚えるべきです。

これらの変数のいくつかは「読み込み専用」と考えられます。 つまり、もしこの変数に対して直接またはリファレンスを通して間接に 代入しようとすると、、実行時エラーが発生します。

この文書に記述されているほとんどの特殊変数のデフォルト値を変更するときには とても慎重になるべきです。 ほとんどの場合、これらの変数を変更する前にこれらをローカル化したいでしょう; さもなければ、あなたが変更した特殊変数のデフォルト値に依存している その他のモジュールにも影響を与えるかもしれないからです。 これはファイル全体を一度に読み込む正しい方法の一つです:

    open my $fh, "<", "foo" or die $!;
    local $/; # enable localized slurp mode
    my $content = <$fh>;
    close $fh;

    open my $fh, "<", "foo" or die $!;
    local $/; # ローカル化された吸い込みモードを有効にする
    my $content = <$fh>;
    close $fh;

しかし以下のコードは完全に悪いものです:

    open my $fh, "<", "foo" or die $!;
    undef $/; # enable slurp mode
    my $content = <$fh>;
    close $fh;

    open my $fh, "<", "foo" or die $!;
    undef $/; # 吸い込みモードを有効にする
    my $content = <$fh>;
    close $fh;

なぜなら、その他のモジュールでは、デフォルトの「行モード」でファイルを 読もうとするかも知れませんが、もし単に前述のコードを実行すると、 $/ のグローバルな値が、同じ Perl インタプリタ内で実行される その他のコードに対しても変更されるからです。

通常、変数をローカル化するとき、この変更ができるだけ最短のスコープに 影響を与えることを確実にしたいでしょう。 従って、既に小さい {} ブロックの内側であるのでない限り、それを 自身で作るべきです。 例えば:

    my $content = '';
    open my $fh, "<", "foo" or die $!;
    {
        local $/;
        $content = <$fh>;
    }
    close $fh;

以下はどのように自分のコードが壊れるかの例です:

    for ( 1..3 ){
        $\ = "\r\n";
        nasty_break();
        print "$_";
    }

    sub nasty_break {
        $\ = "\f";
        # do something with $_
    }

    sub nasty_break {
        $\ = "\f";
        # $_ で何かする
    }

おそらくこのコードは以下のように表示されることを期待しています:

    "1\r\n2\r\n3\r\n"

しかし、以下のようになります:

    "1\f2\f3\f"

なぜでしょう? nasty_break() は $_ をローカル化する前に変更するからです。 nasty_break() で設定した値は戻ったときにまだそこにあります。 修正するには、local() を追加して、値が nasty_break() の外に 漏れないようにします:

    local $\ = "\f";

このような短い例では問題に気付くのは簡単ですが、より複雑なコードでは、 もし特殊変数の変更をローカル化していないと問題を探すことになります。

$ARGV

Contains the name of the current file when reading from <>.

<> から読込みを行なっているとき、その時点のファイル名を示します。

@ARGV

The array @ARGV contains the command-line arguments intended for the script. $#ARGV is generally the number of arguments minus one, because $ARGV[0] is the first argument, not the program's command name itself. See "$0" for the command name.

配列 @ARGV は、コマンドラインからスクリプトに渡す引数が入れられます。 $ARGV[0] がプログラムのコマンド名自身ではなく、 最初の引数ですから、$#ARGV は一般には、引数の個数 - 1 となります。 コマンド名については、"$0" を参照してください。

ARGV

The special filehandle that iterates over command-line filenames in @ARGV. Usually written as the null filehandle in the angle operator <>. Note that currently ARGV only has its magical effect within the <> operator; elsewhere it is just a plain filehandle corresponding to the last file opened by <>. In particular, passing \*ARGV as a parameter to a function that expects a filehandle may not cause your function to automatically read the contents of all the files in @ARGV.

@ARGV にあるコマンドラインで指定されたファイル名に対して反復する 特殊ファイルハンドルです。 通常角かっこ <> の中で空ファイルハンドルとして書かれます。 現在のところ、ARGV は <> 演算子の中でのみ特別な効果があることに 注意してください; その他の場所では、<> で開かれた最後のファイルに 対応する普通のファイルハンドルです。 特に、ファイルハンドルを想定している関数に \*ARGV を引数として渡しても、 関数内で @ARGV にある全てのファイルの内容を自動的に読み込むことには なりません。

ARGVOUT

The special filehandle that points to the currently open output file when doing edit-in-place processing with -i. Useful when you have to do a lot of inserting and don't want to keep modifying $_. See perlrun for the -i switch.

-i を使ってその場修正を行っているときに、現在開いている出力ファイルを 示す特殊ファイルハンドルです。 たくさんの挿入をする必要があるときに $_ を修正し続けたくない場合に有用です。 -i オプションについては perlrun を 参照してください。

IO::Handle->output_field_separator( EXPR )

$OUTPUT_FIELD_SEPARATOR

$OFS

$,

The output field separator for the print operator. If defined, this value is printed between each of print's arguments. Default is undef.

print 演算子のための出力フィールドセパレータ。 定義されると、この値がそれぞれの print の引数の間に表示されます。 デフォルトは undef です。

You cannot call output_field_separator() on a handle, only as a static method. See IO::Handle.

ハンドルに対して output_field_separator() を呼び出すことはできません; 静的メソッドしてのみです。 IO::Handle を参照してください。

Mnemonic: what is printed when there is a "," in your print statement.

記憶法: print 文で "," を書いた場所に印字されるもの。

HANDLE->input_line_number( EXPR )

$INPUT_LINE_NUMBER

$NR

$.

Current line number for the last filehandle accessed.

最後にアクセスされたファイルハンドルの現在の行番号。

Each filehandle in Perl counts the number of lines that have been read from it. (Depending on the value of $/, Perl's idea of what constitutes a line may not match yours.) When a line is read from a filehandle (via readline() or <>), or when tell() or seek() is called on it, $. becomes an alias to the line counter for that filehandle.

Perl の各ファイルハンドルは、そこから読み込んだ行数を数えています。 ($/ の値に依存して、何が行を構成するかに関する Perl の考えはあなたの 考えと一致しないかもしれません。) 行が(readline() や <> を使って)ファイルハンドルから読み込まれたか、 tell() や seek() がファイルハンドルに対して呼び出された場合、 $. はそのファイルハンドルの行カウンタへのエイリアスとなります。

You can adjust the counter by assigning to $., but this will not actually move the seek pointer. Localizing $. will not localize the filehandle's line count. Instead, it will localize perl's notion of which filehandle $. is currently aliased to.

$. へ代入することでカウンタの値を修正できますが、これは実際にシーク ポインタを動かすことはありません。 $. をローカル化してもファイルハンドルの行カウンタはローカル化されません。 代わりに、現在 $. がどのファイルハンドルへのエイリアスかという情報が ローカル化されます。

$. is reset when the filehandle is closed, but not when an open filehandle is reopened without an intervening close(). For more details, see "I/O Operators" in perlop. Because <> never does an explicit close, line numbers increase across ARGV files (but see examples in "eof" in perlfunc).

$. はファイルハンドルがクローズされるとリセットされますが、 オープンしているファイルハンドルが close() されることなく再オープンされた 場合にはリセット されません。 さらなる詳細については、"I/O Operators" in perlop を参照してください。 なぜなら、 <> は決して明示的なクローズは行わず、行番号は ARGV の ファイル間で通算してカウントされるからです(但し "eof" in perlfunc の例を 参照してください)。

You can also use HANDLE->input_line_number(EXPR) to access the line counter for a given filehandle without having to worry about which handle you last accessed.

また、HANDLE->input_line_number(EXPR) とすることで、どのハンドルに 最後にアクセスしたかを気にすることなく行カウンタにアクセスできます。

Mnemonic: many programs use "." to mean the current line number.

記憶法: 多くのプログラムで "." が現在行番号を示すように使われています。

IO::Handle->input_record_separator( EXPR )

$INPUT_RECORD_SEPARATOR

$RS

$/

The input record separator, newline by default. This influences Perl's idea of what a "line" is. Works like awk's RS variable, including treating empty lines as a terminator if set to the null string (an empty line cannot contain any spaces or tabs). You may set it to a multi-character string to match a multi-character terminator, or to undef to read through the end of file. Setting it to "\n\n" means something slightly different than setting to "", if the file contains consecutive empty lines. Setting to "" will treat two or more consecutive empty lines as a single empty line. Setting to "\n\n" will blindly assume that the next input character belongs to the next paragraph, even if it's a newline.

入力レコードセパレータで、デフォルトでは改行文字。 これは Perl での「行」とは何か、ということに影響を与えます。 空文字列に設定されると、空行をセパレータとして扱うことを含めて、awk の 変数 RS のように働きます(空行はスペースやタブを含んでいてはいけません)。 複数文字の区切文字を示すために、文字列を設定することもできます; また、 ファイルの最後まで読み込むために undef を指定することもできます。 この変数に "\n\n" を設定すると、空行が続く場合において、 "" を設定した場合とわずかに違う動作をするようになります。 "" を設定した場合には、複数の空行も 1 つの空行であるかのように扱います。 "\n\n" を設定した場合には、単純に次の文字が (たとえ改行文字であっても) 次の段落に含まれるものとして扱います。

    local $/;           # enable "slurp" mode
    local $_ = <FH>;    # whole file now here
    s/\n[ \t]+/ /g;

    local $/;           # 「吸い込み」モードを有効にする
    local $_ = <FH>;    # ファイル全体が入る
    s/\n[ \t]+/ /g;

Remember: the value of $/ is a string, not a regex. awk has to be better for something. :-)

注意: $/ は文字列であり、正規表現ではありません。 awk は何かもっとうまくやらなくてはいけません。:-)

Setting $/ to an empty string -- the so-called paragraph mode -- merits special attention. When $/ is set to "" and the entire file is read in with that setting, any sequence of one or more consecutive newlines at the beginning of the file is discarded. With the exception of the final record in the file, each sequence of characters ending in two or more newlines is treated as one record and is read in to end in exactly two newlines. If the last record in the file ends in zero or one consecutive newlines, that record is read in with that number of newlines. If the last record ends in two or more consecutive newlines, it is read in with two newlines like all preceding records.

$/ に空文字列を設定すること -- 段落モード と呼ばれます -- には、 特に注意する価値があります。 $/ が "" に設定されて、ファイル全体がこの設定で読み込まれた場合、 ファイル先頭の一つ以上の連続する改行の並びは捨てられます。 ファイルの最後のレコードを例外として、 二つ以上の改行で終わるそれぞれの文字並びは一つのレコードとして扱われ、 正確に二つの改行で終わるように読み込まれます。 ファイルの最後のレコードが 0 または 1 の連続する改行で終わっている場合、 そのレコードはその数の改行と共に読み込まれます。 最後のレコードが二つ以上の連続する改行で終わっている場合、 全ての先行するレコードと同様、二つの改行と共に読み込まれます。

Suppose we wrote the following string to a file:

次の文字列をファイルに書いたとします:

    my $string = "\n\n\n";
    $string .= "alpha beta\ngamma delta\n\n\n";
    $string .= "epsilon zeta eta\n\n";
    $string .= "theta\n";

    my $file = 'simple_file.txt';
    open my $OUT, '>', $file or die;
    print $OUT $string;
    close $OUT or die;

Now we read that file in paragraph mode:

このファイルを段落モードで読み込みます:

    local $/ = ""; # paragraph mode
    open my $IN, '<', $file or die;
    my @records = <$IN>;
    close $IN or die;

@records will consist of these 3 strings:

@records は三つの文字列からなります:

    (
      "alpha beta\ngamma delta\n\n",
      "epsilon zeta eta\n\n",
      "theta\n",
    )

Setting $/ to a reference to an integer, scalar containing an integer, or scalar that's convertible to an integer will attempt to read records instead of lines, with the maximum record size being the referenced integer number of characters. So this:

$/ に整数、整数を含むスカラ、整数に変換できるスカラのいずれかへの リファレンスをセットすると、行を読む代わりにレコードを読もうとします; この場合、最大レコードサイズはリファレンス先の整数値の文字数となります。 つまり:

    local $/ = \32768; # or \"32768", or \$var_containing_32768
    open my $fh, "<", $myfile or die $!;
    local $_ = <$fh>;

will read a record of no more than 32768 characters from $fh. If you're not reading from a record-oriented file (or your OS doesn't have record-oriented files), then you'll likely get a full chunk of data with every read. If a record is larger than the record size you've set, you'll get the record back in pieces. Trying to set the record size to zero or less is deprecated and will cause $/ to have the value of "undef", which will cause reading in the (rest of the) whole file.

これは $fh から 32768 文字を超えないようにレコードを読み込みます。 もしレコード指向のファイルを読み込まない場合(あるいは OS がレコード指向 ファイルを持たない場合)、読み込み毎にデータのチャンク全部を取り込みます。 もしレコードがセットしたレコードサイズより大きい場合、 レコードの部分を取り込みます。 レコードサイズを 0 以下にセットしようとするのは廃止予定で、 $/ に値 "undef" が設定され、(残りの)ファイル全体を読み込むことになります。

As of 5.19.9 setting $/ to any other form of reference will throw a fatal exception. This is in preparation for supporting new ways to set $/ in the future.

5.19.9 から、$/ にその他の形式のリファレンスを設定すると致命的エラーが 投げられます。 これは将来 $/ を設定する新しい方法に対応する準備です。

On VMS only, record reads bypass PerlIO layers and any associated buffering, so you must not mix record and non-record reads on the same filehandle. Record mode mixes with line mode only when the same buffering layer is in use for both modes.

VMS だけでは、レコードは PerlIO 層とそれに関連するバッファリングを迂回して 読み込まれるので、同じファイルハンドルでレコード読み込みと 非レコード読み込みを混ぜてはいけません。 レコードモードは、同じバッファリング層を両方のモードで使う場合にのみ ラインモードと混ざります。

You cannot call input_record_separator() on a handle, only as a static method. See IO::Handle.

ハンドルに対して input_record_separator() を呼び出すことはできません; 静的メソッドしてのみです。 IO::Handle を参照してください。

See also "Newlines" in perlport. Also see "$.".

"Newlines" in perlport を参照してください。 "$." も参照してください。

Mnemonic: / delimits line boundaries when quoting poetry.

記憶法: /は、詩を引用するときに、行の区切りを示します。

IO::Handle->output_record_separator( EXPR )

$OUTPUT_RECORD_SEPARATOR

$ORS

$\

The output record separator for the print operator. If defined, this value is printed after the last of print's arguments. Default is undef.

print 演算子のための出力レコードセパレータ。 もし定義されていると、print の最後の引数の最後にこの値が表示されます。 デフォルトは undef です。

You cannot call output_record_separator() on a handle, only as a static method. See IO::Handle.

ハンドルに対して output_record_separator() を呼び出すことはできません; 静的メソッドしてのみです。 IO::Handle を参照してください。

Mnemonic: you set $\ instead of adding "\n" at the end of the print. Also, it's just like $/, but it's what you get "back" from Perl.

記憶法: print の最後に "\n" を付け加える代わりに $\ を設定する。 また、$/ に似通っているが、Perl から「バック」されるものです。

HANDLE->autoflush( EXPR )

$OUTPUT_AUTOFLUSH

$|

If set to nonzero, forces a flush right away and after every write or print on the currently selected output channel. Default is 0 (regardless of whether the channel is really buffered by the system or not; $| tells you only whether you've asked Perl explicitly to flush after each write). STDOUT will typically be line buffered if output is to the terminal and block buffered otherwise. Setting this variable is useful primarily when you are outputting to a pipe or socket, such as when you are running a Perl program under rsh and want to see the output as it's happening. This has no effect on input buffering. See "getc" in perlfunc for that. See "select" in perlfunc on how to select the output channel. See also IO::Handle.

0 以外に設定されると、その時点で選択されている出力チャネルを直ちにその場で フラッシュし、さらに write や print を行なうごとに、強制的にフラッシュします。 デフォルトでは 0 となっています(チャンネルが実際にシステムによって バッファリングされているかどうかは関知しません。 $| は Perl が明示的に毎回書き込みの後にフラッシュするかどうかのみを 示します)。 STDOUT は通常では、端末への出力時には行バッファリング、 それ以外ではブロックバッファリングであることに注意してください。 これは、Perl のスクリプトを rsh 配下で実行して、実行状況を確認したい 場合のように、パイプやソケットに出力するときに特に便利でしょう。 これは入力バッファリングには何の影響も与えません。 出力チャネルの選択方法については "select" in perlfunc を参照してください。 IO::Handle も参照してください。

Mnemonic: when you want your pipes to be piping hot.

記憶法: パイプをホットな状態にしておくために使う。

${^LAST_FH}

This read-only variable contains a reference to the last-read filehandle. This is set by <HANDLE>, readline, tell, eof and seek. This is the same handle that $. and tell and eof without arguments use. It is also the handle used when Perl appends ", <STDIN> line 1" to an error or warning message.

この読み込み専用変数は最後に読み込んだファイルハンドルへのリファレンスを 含んでいます。 これは <HANDLE>, readline, tell, eof, seek で 設定されます。 これは $. および、tell と eof が引数なしで使われたときと同じ ハンドルです。 これはまた、Perl がエラーまたは警告メッセージに ", <STDIN> line 1" を追加する ハンドルでもあります。

This variable was added in Perl v5.18.0.

この変数は Perl v5.18.0 で追加されました。

フォーマット関連の変数¶

フォーマットのための特殊変数はファイルハンドルのための物のサブセットです。 Perl のフォーマットに関するさらなる情報については perlform を 参照してください。

$ACCUMULATOR

$^A

The current value of the write() accumulator for format() lines. A format contains formline() calls that put their result into $^A. After calling its format, write() prints out the contents of $^A and empties. So you never really see the contents of $^A unless you call formline() yourself and then look at it. See perlform and "formline PICTURE,LIST" in perlfunc.

format() 行のための、その時点での write() アキュムレータの値。 format には、$^A に結果を残す、formline() 呼び出しが含まれます。 自分のフォーマットを呼び出した後で、 write() は $^A の内容を出力してから消去します。 したがって、自分で formline() を呼び出すのでなければ、 $^A の値が見えることはありません。 perlform と "formline PICTURE,LIST" in perlfunc を参照してください。

IO::Handle->format_formfeed(EXPR)

$FORMAT_FORMFEED

$^L

What formats output as a form feed. The default is \f.

フォーマット出力で、改ページのために出力されるもの。 デフォルトは \f。

You cannot call format_formfeed() on a handle, only as a static method. See IO::Handle.

ハンドルに対して format_formfeed() を呼び出すことはできません; 静的メソッドしてのみです。 IO::Handle を参照してください。

HANDLE->format_page_number(EXPR)

$FORMAT_PAGE_NUMBER

$%

The current page number of the currently selected output channel.

その時点で選択されている出力チャネルの、その時点でのページ番号。

Mnemonic: % is page number in nroff.

記憶法: % は、nroff でのページ番号です。

HANDLE->format_lines_left(EXPR)

$FORMAT_LINES_LEFT

$-

The number of lines left on the page of the currently selected output channel.

その時点で選択されている出力チャネルの、ページに残っている行数。

Mnemonic: lines_on_page - lines_printed.

記憶法: "ページ行数" - "印字済み行数"

IO::Handle->format_line_break_characters EXPR

$FORMAT_LINE_BREAK_CHARACTERS

$:

The current set of characters after which a string may be broken to fill continuation fields (starting with ^) in a format. The default is " \n-", to break on a space, newline, or a hyphen.

フォーマットの充填継続フィールド (^ で始まるもの) への文字列で行分割を許す 文字集合。 デフォルトは " \n-" で空白、改行、ハイフンの後で行分割が可能です。

You cannot call format_line_break_characters() on a handle, only as a static method. See IO::Handle.

ハンドルに対して format_line_break_characters() を呼び出すことはできません; 静的メソッドしてのみです。 IO::Handle を参照してください。

Mnemonic: a "colon" in poetry is a part of a line.

記憶法: 詩では「コロン」は、行の一部。

HANDLE->format_lines_per_page(EXPR)

$FORMAT_LINES_PER_PAGE

$=

The current page length (printable lines) of the currently selected output channel. The default is 60.

その時点で選択されている出力チャネルの、その時点でのページ長(印字可能行数)。 デフォルトは 60 です。

Mnemonic: = has horizontal lines.

記憶法: = には複数の水平線 (行) が含まれます。

HANDLE->format_top_name(EXPR)

$FORMAT_TOP_NAME

$^

The name of the current top-of-page format for the currently selected output channel. The default is the name of the filehandle with _TOP appended. For example, the default format top name for the STDOUT filehandle is STDOUT_TOP.

その時点で選択されている出力チャネルの、その時点でのページ先頭フォーマット名。 デフォルトは、ファイルハンドル名に _TOP を続けたものです。 例えば、STDOUT ファイルハンドルのデフォルトのページ先頭フォーマット名は STDOUT_TOP です。

Mnemonic: points to top of page.

記憶法: ページの先頭へのポインタ。

HANDLE->format_name(EXPR)

$FORMAT_NAME

$~

The name of the current report format for the currently selected output channel. The default format name is the same as the filehandle name. For example, the default format name for the STDOUT filehandle is just STDOUT.

その時点で選択されている出力チャネルの、その時点でのフォーマット名。 デフォルトは、ファイルハンドル名です。 例えば、STDOUT ファイルハンドルのデフォルトフォーマット名は 単に STDOUT です。

Mnemonic: brother to $^.

記憶法: $^ の兄弟。

エラー変数¶

変数 $@, $!, $^E, $? は Perl プログラムの実行中に 発生した、異なる種類のエラー情報を保持します。 変数はエラーを報告した副システムと Perl プロセスとの「距離」の順番に 並んでいます。 これらはそれぞれ、Perl インタプリタ、C ライブラリ、 オペレーティングシステム、外部プログラムによって検出された エラーに対応しています。

これらの変数の違いを示すために、 以下のようなシングルクォートを用いた Perl 式を考えます。 この文の実行後、perl は四つ全ての特殊エラー変数をセットします:

    eval q{
        open my $pipe, "/cdrom/install |" or die $!;
        my @res = <$pipe>;
        close $pipe or die "bad pipe: $?, $!";
    };

eval() 式が実行されたとき、open(), <PIPE>, close は C ランタイムライブラリの呼び出しに変換され、それからオペレーティング システムコールに変換されます。 $! はこれらの呼び出しのどれかが失敗したとき、 C ライブラリの errno の値がセットされます。

$@ は eval された文字列がコンパイルされなかったとき(これは open か close が正しくないプロトタイプでインポートされたときに起こり得ます)、 または評価中に実行している Perl コードが die() したときにセットされます。 これらの場合には $@ の値はコンパイルエラー、または die への引数(これには $! と $? が差し挟まれます)です。 (しかし、Fatal も参照して下さい。)

いくつかのオペレーティングシステムでは、$^E により詳細なエラー指示子が 入っているかもしれません; 今回の場合で言えば、 "CDROM tray not closed." などです。 追加のエラーメッセージに対応していないシステムでは、$^E は $! と同じ 値です。

最後に、$? は外部プログラム /cdrom/install が失敗したときに 非 0 にセットされるかもしれません。 上位の 8 ビットはプログラムが遭遇した特定のエラー状況 (プログラムの exit() の値)を反映します。 下位の 8 ビットは、シグナルの死亡やコアダンプ情報と言った失敗のモードを 反映します。 詳細については wait(2) を参照して下さい。 $! と $^E はエラー状況が検出されたときにのみ設定されますが、 変数 $? は wait やパイプの close の度に、前の値を上書きします。 これは、$@ が eval() の実行毎に、エラーならセットされ、 成功ならクリアされるという動作と似ています。

より詳細については、$@, $!, $^E, $? それぞれの説明を 参照して下さい。

${^CHILD_ERROR_NATIVE}

The native status returned by the last pipe close, backtick (``) command, successful call to wait() or waitpid(), or from the system() operator. On POSIX-like systems this value can be decoded with the WIFEXITED, WEXITSTATUS, WIFSIGNALED, WTERMSIG, WIFSTOPPED, and WSTOPSIG functions provided by the POSIX module.

最後のパイプクローズ、逆クォート (``) コマンド、wait() と waitpid() の成功した呼び出し、system() 演算子から返された、 ネイティブなステータスです。 POSIX 風システムでは、この値は POSIX モジュールで提供される WIFEXITED, WEXITSTATUS, WIFSIGNALED, WTERMSIG, WIFSTOPPED, WSTOPSIG 関数で デコードできます。

Under VMS this reflects the actual VMS exit status; i.e. it is the same as $? when the pragma use vmsish 'status' is in effect.

VMS ではこれは実際の VMS の終了ステータスを反映します; 言い換えると、これは use vmsish 'status' プラグマが有効なときの $? と 同じです。

This variable was added in Perl v5.10.0.

この変数は Perl v5.10.0 で追加されました。

$EXTENDED_OS_ERROR

$^E

Error information specific to the current operating system. At the moment, this differs from "$!" under only VMS, OS/2, and Win32 (and for MacPerl). On all other platforms, $^E is always just the same as $!.

現在のオペレーティングシステムに特化したエラー情報です。 現在のところ、VMS, OS/2, Win32 (と MacPerl) のみで "$!" と異なる値をもちます。 その他のプラットフォームでは、$^E はいつも $! と同じです。

Under VMS, $^E provides the VMS status value from the last system error. This is more specific information about the last system error than that provided by $!. This is particularly important when $! is set to EVMSERR.

VMS では、$^E は最後のシステムエラーの VMS ステータス値です。 これは、最後のシステムエラーについて $! で提供されるものより 具体的な情報を示します。 これは特に $! が EVMSERR にセットされた場合に重要です。

Under OS/2, $^E is set to the error code of the last call to OS/2 API either via CRT, or directly from perl.

OS/2 では、$^E は CRT 経由、または Perl から直接呼び出された 最後の OS/2 API のエラーコードがセットされます。

Under Win32, $^E always returns the last error information reported by the Win32 call GetLastError() which describes the last error from within the Win32 API. Most Win32-specific code will report errors via $^E. ANSI C and Unix-like calls set errno and so most portable Perl code will report errors via $!.

Win32 では、$^E は Win32 API での最後のエラーの内容を返す GetLastError() Win32 呼び出しで報告される最新のエラー情報を 返します。 ほとんどの Win32 固有のコードはエラーを $^E 経由で返します。 ANSI C と Unix 風の呼び出しは errno をセットするので、 ほとんどの移植性のある Perl コードは $! 経由で エラーを報告します。

Caveats mentioned in the description of "$!" generally apply to $^E, also.

"$!" の説明で触れた問題点は一般的に $^E にも適用されます。

This variable was added in Perl 5.003.

この変数は Perl 5.003 で追加されました。

Mnemonic: Extra error explanation.

記憶法: 追加の(Extra)エラーの説明。

$EXCEPTIONS_BEING_CAUGHT

$^S

Current state of the interpreter.

現在のインタプリタの状態を示します。

    $^S         State
    ---------   -------------------------------------
    undef       Parsing module, eval, or main program
    true (1)    Executing an eval or try block
    false (0)   Otherwise

    $^S         状態
    ---------   -------------------
    undef       モジュール、eval、メインプログラムのパース中
    真 (1)      eval または try ブロックの実行中
    偽 (0)      その他

The first state may happen in $SIG{__DIE__} and $SIG{__WARN__} handlers.

最初の状態は $SIG{__DIE__} と $SIG{__WARN__} のハンドラで起きる 可能性があります。

The English name $EXCEPTIONS_BEING_CAUGHT is slightly misleading, because the undef value does not indicate whether exceptions are being caught, since compilation of the main program does not catch exceptions.

英語名 $EXCEPTIONS_BEING_CAUGHT は少し誤解を招きます; undef は例外が 捕捉されたかどうかを示しているわけではないからです; メインプログラムの コンパイルは例外を捕捉しません。

This variable was added in Perl 5.004.

この変数は Perl 5.004 で追加されました。

$WARNING

$^W

The current value of the warning switch, initially true if -w was used, false otherwise, but directly modifiable.

警告スイッチの値で、-w スイッチが使われると内部的に真となり、 そうでない場合は直接変更可能です。

See also warnings.

warnings も参照して下さい。

Mnemonic: related to the -w switch.

記憶法: -w スイッチに関係します。

${^WARNING_BITS}

The current set of warning checks enabled by the use warnings pragma. It has the same scoping as the $^H and %^H variables. The exact values are considered internal to the warnings pragma and may change between versions of Perl.

use warnings プラグマで有効にされた、現在の警告チェックの集合です。 $^H および %^H 変数と同じスコープを持ちます。 正確な値は warnings プラグマの内部の値と考えられ、Perl の バージョンによって変更されるかもしれません。

Each time a statement completes being compiled, the current value of ${^WARNING_BITS} is stored with that statement, and can later be retrieved via (caller($level))[9].

文のコンパイルが完了する毎に、${^WARNING_BITS} の現在の値が文と共に 保管され、(caller($level))[9] として後で取得できます。

This variable was added in Perl v5.6.0.

この変数は Perl v5.6.0 で追加されました。

$OS_ERROR

$ERRNO

$!

When referenced, $! retrieves the current value of the C errno integer variable. If $! is assigned a numerical value, that value is stored in errno. When referenced as a string, $! yields the system error string corresponding to errno.

参照されると、$! は C の errno 整数変数の現在の値を取得します。 $! に数値が代入されると、その値は errno に保管されます。 文字列として参照されると、$! は errno に対応するシステムエラー 文字列を返します。

Many system or library calls set errno if they fail, to indicate the cause of failure. They usually do not set errno to zero if they succeed and may set errno to a non-zero value on success. This means errno, hence $!, is meaningful only immediately after a failure:

多くのシステムやライブラリ呼び出しは、失敗したときに、失敗の理由を示すために errno を設定します。 これらは普通は成功したときには errno にゼロを設定 しません; 成功時には errno に非ゼロを設定するかもしれません。 これは、errno、$! は、失敗 の 直後 でのみ意味が あるということです:

    if (open my $fh, "<", $filename) {
        # Here $! is meaningless.
        ...
    }
    else {
        # ONLY here is $! meaningful.
        ...
        # Already here $! might be meaningless.
    }
    # Since here we might have either success or failure,
    # $! is meaningless.

    if (open my $fh, "<", $filename) {
        # ここで $! は無意味。
        ...
    }
    else {
        # ここでだけ $! に意味がある。
        ...
        # ここで既に $! は無意味かもしれません。
    }
    # ここでは成功と失敗の両方の可能性があるので、
    # $! は無意味。

Here, meaningless means that $! may be unrelated to the outcome of the open() operator. Assignment to $! is similarly ephemeral. It can be used immediately before invoking the die() operator, to set the exit value, or to inspect the system error string corresponding to error n, or to restore $! to a meaningful state.

ここで、無意味 というのは $! は open() 演算子の結果に 関係ないということです。 $! への代入も同様に一時的なものです。 これは、終了値を設定したり、エラー n に対応するシステムエラー文字列を 調べたり、$! を意味のある状態に復元するために、die() 演算子を 起動する直前で使えます。

Perl itself may set errno to a non-zero on failure even if no system call is performed.

Perl 自身は、システムコールを実行しなくても失敗時には errno に非ゼロを設定するかもしれません。

Mnemonic: What just went bang?

記憶法: 何が bang(!) したか。

%OS_ERROR

%ERRNO

%!

Each element of %! has a true value only if $! is set to that value. For example, $!{ENOENT} is true if and only if the current value of $! is ENOENT; that is, if the most recent error was "No such file or directory" (or its moral equivalent: not all operating systems give that exact error, and certainly not all languages). The specific true value is not guaranteed, but in the past has generally been the numeric value of $!. To check if a particular key is meaningful on your system, use exists $!{the_key}; for a list of legal keys, use keys %!. See Errno for more information, and also see "$!".

%! の各要素は、$! がその値にセットされている場合にのみ真の値を持ちます。 例えば、$!{ENOENT} は、現在の $! の値が ENOENT の場合にのみ 真となります; これは、最近のエラーが "No such file or directory" (あるいは 倫理的に等価なもの: 全ての OS が正確に同じエラーを出すわけではないですし、 全ての言語で出るわけでもありません) の場合です。 特定の真の値は保証されませんが、以前は一般的には $! の数値でした。 あなたのシステムで特定のキーが意味があるかどうかを調べるには、 exists $!{the_key} を使ってください; 有効なキーのリストを得るには、 keys %! としてください。 さらなる情報に関しては Errno と /$! を参照してください。

This variable was added in Perl 5.005.

この変数は Perl 5.005 で追加されました。

$CHILD_ERROR

$?

The status returned by the last pipe close, backtick (``) command, successful call to wait() or waitpid(), or from the system() operator. This is just the 16-bit status word returned by the traditional Unix wait() system call (or else is made up to look like it). Thus, the exit value of the subprocess is really ($? >> 8), and $? & 127 gives which signal, if any, the process died from, and $? & 128 reports whether there was a core dump.

最後に close したパイプ、バッククォート (``) コマンド、 成功した wait() または waitpid() 呼び出し、system() 演算子が返した ステータス。 このステータスワードは伝統的な Unix の wait() システムコールが返した 16 ビットのステータス(またはそのように見えるもの)です。 従ってサブプロセスの exit 値は、実際には ($? >> 8) で、$? & 127 は、もしあれば、そのプロセスを止めたシグナルで、 $? & 128 はコアダンプがあるかどうかを示します。

Additionally, if the h_errno variable is supported in C, its value is returned via $? if any gethost*() function fails.

さらに、C で h_errno 変数に対応している場合は、 gethost*() が失敗したときに $? を通して返されます。

If you have installed a signal handler for SIGCHLD, the value of $? will usually be wrong outside that handler.

SIGCHLD のシグナルハンドラを設定した場合、 $? の値は通常ハンドラの外側では正しくない値となります。

Inside an END subroutine $? contains the value that is going to be given to exit(). You can modify $? in an END subroutine to change the exit status of your program. For example:

END サブルーチンの内側では $? には exit() に渡されようとしている 値を含みます。 プログラムの終了ステータスを変更するために、END サブルーチン 内で $? を変更できます。 例えば:

    END {
        $? = 1 if $? == 255;  # die would make it 255
    }

    END {
        $? = 1 if $? == 255;  # die は 255
    }

Under VMS, the pragma use vmsish 'status' makes $? reflect the actual VMS exit status, instead of the default emulation of POSIX status; see "$?" in perlvms for details.

VMS では、use vmsish 'status' を指定すると、 $? はPOSIX ステータスをエミュレートしたものではなく、 実際の VMS 終了ステータスを反映します; 詳細は "$?" in perlvms を 参照してください。

Mnemonic: similar to sh and ksh.

記憶法: sh や ksh と同様。

$EVAL_ERROR

$@

The Perl error from the last eval operator, i.e. the last exception that was caught. For eval BLOCK, this is either a runtime error message or the string or reference die was called with. The eval STRING form also catches syntax errors and other compile time exceptions.

最後の eval 操作子による Perl のエラーです; つまり、最後に補足された 例外です。 eval BLOCK の場合は、これは実行時エラーか、die が呼び出されたときの 文字列かリファレンスです。 eval STRING 型式は、文法エラーやその他のコンパイル時例外も捕捉します。

If no error occurs, eval sets $@ to the empty string.

エラーが起きなければ、eval は $@ に空文字列を設定します。

Warning messages are not collected in this variable. You can, however, set up a routine to process warnings by setting $SIG{__WARN__} as described in "%SIG".

警告メッセージはこの変数に入りません。 しかし、"%SIG" に記述されている $SIG{__WARN__} にセットすることで 警告を処理するルーチンを設定できます。

Mnemonic: Where was the error "at"?

記憶法: どこで ("at") エラーが起ったか。

インタプリタの状態に関連する変数¶

これらの変数は現在のインタプリタの状態に関する情報を提供します。

$COMPILING

$^C

The current value of the flag associated with the -c switch. Mainly of use with -MO=... to allow code to alter its behavior when being compiled, such as for example to AUTOLOAD at compile time rather than normal, deferred loading. Setting $^C = 1 is similar to calling B::minus_c.

-c スイッチに関連付けられた現在の値です。 主に -MO=... と共に用いられ、例えば AUTOLOAD を通常の遅延ロードでは なくコンパイル時に実行するといった、コンパイル時の振る舞いを 変えるために用います。 $^C = 1 に設定することは B::minus_c を呼び出すのと似ています。

This variable was added in Perl v5.6.0.

この変数は Perl v5.6.0 で追加されました。

$DEBUGGING

$^D

The current value of the debugging flags. May be read or set. Like its command-line equivalent, you can use numeric or symbolic values, e.g. $^D = 10 or $^D = "st". See "-Dnumber" in perlrun. The contents of this variable also affects the debugger operation. See "Debugger Internals" in perldebguts.

デバッグフラグの現在の値を示します。 読み書き可能です。 コマンドラインによる等価な機能 と同様に、 数値とシンボル値が使えます (例: $^D = 10 または $^D = "st")。 "-Dnumber" in perlrun を参照してください。 この変数の内容はデバッガ操作にも影響されます。 "Debugger Internals" in perldebguts を参照してください。

Mnemonic: value of -D switch.

記憶法: -D スイッチの値。

${^GLOBAL_PHASE}

The current phase of the perl interpreter.

perl インタプリタの現在のフェーズ。

Possible values are:

取り得る値は:

CONSTRUCT

The PerlInterpreter* is being constructed via perl_construct. This value is mostly there for completeness and for use via the underlying C variable PL_phase. It's not really possible for Perl code to be executed unless construction of the interpreter is finished.

PerlInterpreter* は perl_construct で構築されます。 この変数はほとんど完全性のためと、基礎となっている C 変数 PL_phase 経由での使用のために存在しています。 実際にはインタプリタの構築が完了しない限り Perl コードを 実行することはできません。

START

This is the global compile-time. That includes, basically, every BEGIN block executed directly or indirectly from during the compile-time of the top-level program.

これはコンパイル時にグローバルです。 これは基本的に、直接実行されたり、トップレベルプログラムの コンパイル時の間に間接的に実行される全ての BEGIN です。

This phase is not called "BEGIN" to avoid confusion with BEGIN-blocks, as those are executed during compile-time of any compilation unit, not just the top-level program. A new, localised compile-time entered at run-time, for example by constructs as eval "use SomeModule" are not global interpreter phases, and therefore aren't reflected by ${^GLOBAL_PHASE}.

BEGIN ブロックとの混乱を避けるために、このフェーズの名前は "BEGIN" では ありません; これらは単にトップレベルプログラムではなく、任意のコンパイル ユニットのコンパイル中に実行されます。 例えば eval "use SomeModule" のように、実行時に入った 新しいローカル化されたコンパイル時はグローバルなインタプリタフェーズではなく、 従って ${^GLOBAL_PHASE} に反映されません。

CHECK

Execution of any CHECK blocks.

CHECK ブロックの実行。

INIT

Similar to "CHECK", but for INIT-blocks, not CHECK blocks.

"CHECK" と似ていますが、CHECK ブロックではなく INIT ブロック。

RUN

The main run-time, i.e. the execution of PL_main_root.

メインの実行; つまり PL_main_root の実行。

END

Execution of any END blocks.

END ブロックの実行。

DESTRUCT

Global destruction.

グローバルなデストラクタ。

Also note that there's no value for UNITCHECK-blocks. That's because those are run for each compilation unit individually, and therefore is not a global interpreter phase.

また、UNITCHECK ブロックのための値はないことに注意してください。 なぜなら、これらはコンパイルユニット毎に独立に実行され、従って グローバルなインタプリタフェーズではないからです。

Not every program has to go through each of the possible phases, but transition from one phase to another can only happen in the order described in the above list.

全てのプログラムが可能な全てのフェーズを通らなければならないわけでは ありませんが、あるフェーズから他のフェーズへの移行は上述の 順でのみ起こります。

An example of all of the phases Perl code can see:

Perl コードの全てのフェーズを見る例です:

    BEGIN { print "compile-time: ${^GLOBAL_PHASE}\n" }

    INIT  { print "init-time: ${^GLOBAL_PHASE}\n" }

    CHECK { print "check-time: ${^GLOBAL_PHASE}\n" }

    {
        package Print::Phase;

        sub new {
            my ($class, $time) = @_;
            return bless \$time, $class;
        }

        sub DESTROY {
            my $self = shift;
            print "$$self: ${^GLOBAL_PHASE}\n";
        }
    }

    print "run-time: ${^GLOBAL_PHASE}\n";

    my $runtime = Print::Phase->new(
        "lexical variables are garbage collected before END"
    );

    END   { print "end-time: ${^GLOBAL_PHASE}\n" }

    our $destruct = Print::Phase->new(
        "package variables are garbage collected after END"
    );

This will print out

これは以下のものを出力します:

    compile-time: START
    check-time: CHECK
    init-time: INIT
    run-time: RUN
    lexical variables are garbage collected before END: RUN
    end-time: END
    package variables are garbage collected after END: DESTRUCT

This variable was added in Perl 5.14.0.

この変数は Perl 5.14.0 で追加されました。

$^H

WARNING: This variable is strictly for internal use only. Its availability, behavior, and contents are subject to change without notice.

警告: この変数は厳密に内部使用に限定されます。 その可用性、挙動、内容は告知なく変更される可能性があります。

This variable contains compile-time hints for the Perl interpreter. At the end of compilation of a BLOCK the value of this variable is restored to the value when the interpreter started to compile the BLOCK.

この変数には Perl インタプリタのコンパイル時のヒントが入ります。 BLOCK のコンパイル終了時に、この変数の値は インタプリタが BLOCK のコンパイルを開始した時の値に戻されます。

Each time a statement completes being compiled, the current value of $^H is stored with that statement, and can later be retrieved via (caller($level))[8]. See "caller EXPR" in perlfunc.

文のコンパイルが完了する毎に、$^H の現在の値が文と共に 保管され、(caller($level))[8] として後で取得できます。 "caller EXPR" in perlfunc を参照してください。

When perl begins to parse any block construct that provides a lexical scope (e.g., eval body, required file, subroutine body, loop body, or conditional block), the existing value of $^H is saved, but its value is left unchanged. When the compilation of the block is completed, it regains the saved value. Between the points where its value is saved and restored, code that executes within BEGIN blocks is free to change the value of $^H.

Perl がレキシカルスコープを持つブロック構造(eval の中身、required された ファイル、サブルーチンの中身、loop の中身、条件付きブロック)の パースを開始するとき、現在の $^H の値は保存されますが、値は 変更されません。 ブロックのコンパイルが終わると、保存された値が戻されます。 値の保存と回復の間の地点で、BEGIN ブロックの中で実行されるコードは自由に $^H の値を変更できます。

This behavior provides the semantic of lexical scoping, and is used in, for instance, the use strict pragma.

この振る舞いはレキシカルスコープを持ち、その中で使えます; 例としては use strict があります。

The contents should be an integer; different bits of it are used for different pragmatic flags. Here's an example:

内容は整数であるべきです; ビット毎に異なるプラグマフラグとして使われます。 以下は例です:

    sub add_100 { $^H |= 0x100 }

    sub foo {
        BEGIN { add_100() }
        bar->baz($boon);
    }

Consider what happens during execution of the BEGIN block. At this point the BEGIN block has already been compiled, but the body of foo() is still being compiled. The new value of $^H will therefore be visible only while the body of foo() is being compiled.

BEGIN ブロックの実行中に起こることを考えてみます。 この時点で BEGIN ブロックは既にコンパイルされていますが、 foo() の中身はまだコンパイル中です。 従って $^H の新しい値は foo() の中身がコンパイル中にのみ 見ることが出来ます。

Substitution of BEGIN { add_100() } block with:

BEGIN { add_100() } ブロックを以下のように変更すると:

    BEGIN { require strict; strict->import('vars') }

demonstrates how use strict 'vars' is implemented. Here's a conditional version of the same lexical pragma:

どのように use strict 'vars' が実装されているかがわかります。 以下は同じレキシカルプラグマの条件付き版です:

    BEGIN {
        require strict; strict->import('vars') if $condition
    }

This variable was added in Perl 5.003.

この変数は Perl 5.003 で追加されました。

%^H

The %^H hash provides the same scoping semantics as $^H. This makes it useful for implementing lexically scoped pragmas. See perlpragma. All the entries are stringified when accessed at runtime, so only simple values can be accommodated. This means no references to objects, for example.

%^H ハッシュは $^H と同じスコープの意味論を持ちます。 これはレキシカルスコープを持つプラグマを実装するのに便利です。 perlpragma を参照してください。 実行時にアクセスされると全てのエントリは文字列化されるので、 単純な値のみに対応します。 これは、例えばオブジェクトへのリファレンスはないということです。

Each time a statement completes being compiled, the current value of %^H is stored with that statement, and can later be retrieved via (caller($level))[10]. See "caller EXPR" in perlfunc.

文のコンパイルが完了する毎に、%^H の現在の値が文と共に 保管され、(caller($level))[10] として後で取得できます。 "caller EXPR" in perlfunc を参照してください。

When putting items into %^H, in order to avoid conflicting with other users of the hash there is a convention regarding which keys to use. A module should use only keys that begin with the module's name (the name of its main package) and a "/" character. For example, a module Foo::Bar should use keys such as Foo::Bar/baz.

%^H に追加するとき、他のハッシュのユーザーとの衝突を回避するために、 キーの使い方に関する慣習があります。 モジュールはモジュールの名前(主なパッケージの名前)と "/" 文字で始まる キーのみを使うべきです。 例えば、モジュール Foo::Bar は Foo::Bar/baz のようなキーを 使うべきです。

This variable was added in Perl v5.6.0.

この変数は Perl v5.6.0 で追加されました。

${^OPEN}

An internal variable used by PerlIO. A string in two parts, separated by a \0 byte, the first part describes the input layers, the second part describes the output layers.

PerlIO で使われる内部変数です。 文字列は \0 で分割された二つの部分からなり、前半は入力層を、 後半は出力層を示します。

This is the mechanism that applies the lexical effects of the open pragma, and the main program scope effects of the io or D options for the -C command-line switch and PERL_UNICODE environment variable.

これは open プラグマおよび、io や -C コマンドラインオプション と PERL_UNICODE 環境変数 の D オプションの メインプログラムスコープにレキシカルな効果を適用するための機構です。

The functions accept(), open(), pipe(), readpipe() (as well as the related qx and `STRING` operators), socket(), socketpair(), and sysopen() are affected by the lexical value of this variable. The implicit "ARGV" handle opened by readline() (or the related <> and <<>> operators) on passed filenames is also affected (but not if it opens STDIN). If this variable is not set, these functions will set the default layers as described in "Defaults and how to override them" in PerlIO.

accept(), open(), pipe(), readpipe() (および関連する qx と `STRING` 演算子), socket(), socketpair(), sysopen() 関数は、この変数のレキシカルな値に 影響を受けます。 readline() (や関連する <> と <<>> 演算子) に ファイル名を渡すことによって開かれた暗黙の "ARGV" も影響を受けます (しかし STDIN を開いている場合は影響を受けません)。 この変数が設定されていない場合、これらの関数は "Defaults and how to override them" in PerlIO で記述されている デフォルト層が設定されます。

open() ignores this variable (and the default layers) when called with 3 arguments and explicit layers are specified. Indirect calls to these functions via modules like IO::Handle are not affected as they occur in a different lexical scope. Directory handles such as opened by opendir() are not currently affected.

open() は、3 引数で呼び出され、明示的な層が指定された場合は この変数(およびデフォルト層)を無視します。 IO::Handle のようなモジュール経由でのこれらの関数の間接的な呼び出しは 影響を受けません; これらは異なったレキシカルスコープで起きるからです。 opendir() で開かれたようなディレクトリハンドルは現在の所 影響を受けません。

This variable was added in Perl v5.8.0.

この変数は Perl v5.8.0 で追加されました。

$PERLDB

$^P

The internal variable for debugging support. The meanings of the various bits are subject to change, but currently indicate:

デバッグ機能のための内部変数です。 それぞれのビットの意味は変わるかもしれませんが、 現在のところは以下の通りです:

0x01

Debug subroutine enter/exit.

サブルーチンの出入りをデバッグします。

0x02

Line-by-line debugging. Causes DB::DB() subroutine to be called for each statement executed. Also causes saving source code lines (like 0x400).

行毎にデバッグします。 各行を実行する毎に DB::DB() サブルーチンを呼び出します。 さらに、(0x400 のように) ソースコードを保存します。

0x04

Switch off optimizations.

最適化を行いません。

0x08

Preserve more data for future interactive inspections.

将来の対話的な検査のためにより多くのデータを保存します。

0x10

Keep info about source lines on which a subroutine is defined.

サブルーチンが定義されたソース行に関する情報を保持します。

0x20

Start with single-step on.

シングルステップ実行で開始します。

0x40

Use subroutine address instead of name when reporting.

報告時にサブルーチン名でなくサブルーチンのアドレスを使います。

0x80

Report goto &subroutine as well.

goto &subroutine も同様に報告します。

0x100

Provide informative "file" names for evals based on the place they were compiled.

eval に対して、コンパイルされた位置を元にした「ファイル」名を提供します。

0x200

Provide informative names to anonymous subroutines based on the place they were compiled.

無名サブルーチンに対して、 コンパイルされた位置を基にした参考名を提供します。

0x400

Save source code lines into @{"_<$filename"}.

ソースコードの行数を @{"_<$filename"} に保存します。

0x800

When saving source, include evals that generate no subroutines.

ソースを保存するときに、サブルーチンがない eval を含みます。

0x1000

When saving source, include source that did not compile.

ソースを保存するときに、コンパイルしていないソースを含みます。

Some bits may be relevant at compile-time only, some at run-time only. This is a new mechanism and the details may change. See also perldebguts.

一部のビットはコンパイル時にのみまたは実行時にのみ意味があります。 これは新しい機構であり、詳細は変更されるかもしれません。 perldebguts も参照してください。

${^TAINT}

Reflects if taint mode is on or off. 1 for on (the program was run with -T), 0 for off, -1 when only taint warnings are enabled (i.e. with -t or -TU).

汚染検査モードのオン・オフを反映します。 1 はオン(プログラムは -T 付きで実行されている)、0 はオフ、-1 は汚染 警告のみが有効になっている(つまり -t か -TU)ことを意味します。

Note: if your perl was built without taint support (see perlsec), then ${^TAINT} will always be 0, even if the program was run with -T).

注意: perl が汚染チェック対応 (perlsec 参照) なしでビルドされている場合、 たとえプログラムが -T 付きで実行されていても、 ${^TAINT} は常に 0 です。

This variable is read-only.

この変数は読み込み専用です。

This variable was added in Perl v5.8.0.

この変数は Perl v5.8.0 で追加されました。

${^SAFE_LOCALES}

Reflects if safe locale operations are available to this perl (when the value is 1) or not (the value is 0). This variable is always 1 if the perl has been compiled without threads. It is also 1 if this perl is using thread-safe locale operations. Note that an individual thread may choose to use the global locale (generally unsafe) by calling "switch_to_global_locale" in perlapi. This variable currently is still set to 1 in such threads.

この perl で安全なロケール操作が利用可能 (値が 1 の場合) かそうでない (値が 0 の場合) かを反映します。 この変数は、perl がスレッドなしでコンパイルされている場合は常に 1 です。 また、perl がスレッドセーフなロケール操作を使っている場合は 1 です。 個々のスレッドは "switch_to_global_locale" in perlapi を呼び出すことで (一般的にはスレッドセーフでない) グローバルなロケールを使うことを 選ぶかも知れないことに注意してください。 この変数はそのようなスレッドでも 1 のままです。

This variable is read-only.

この変数は読み込み専用です。

This variable was added in Perl v5.28.0.

この変数は Perl v5.28.0 で追加されました。

${^UNICODE}

Reflects certain Unicode settings of Perl. See perlrun documentation for the -C switch for more information about the possible values.

Perl のいくつかの Unicode 設定を反映します。 設定できる値に関するさらなる情報については perlrun の -C オプションを 参照してください。

This variable is set during Perl startup and is thereafter read-only.

この変数は Perl 起動時に設定され、その後は読み込み専用です。

This variable was added in Perl v5.8.2.

この変数は Perl v5.8.2 で追加されました。

${^UTF8CACHE}

This variable controls the state of the internal UTF-8 offset caching code. 1 for on (the default), 0 for off, -1 to debug the caching code by checking all its results against linear scans, and panicking on any discrepancy.

この変数は内部 UTF-8 オフセットキャッシュコードの状態を制御します。 1 はオン(デフォルト)、0 はオフ、-1 は全ての結果を線形走査と比較して、 矛盾があれば異常終了する、という形でキャッシュコードをデバッグします。

This variable was added in Perl v5.8.9. It is subject to change or removal without notice, but is currently used to avoid recalculating the boundaries of multi-byte UTF-8-encoded characters.

この変数は Perl v5.8.9 で追加されました。 これは予告なく変更されたり削除されたりするかもしれませんが、現在のところ 複数バイト UTF-8 エンコード文字の境界の再計算を避けるために使われます。

${^UTF8LOCALE}

This variable indicates whether a UTF-8 locale was detected by perl at startup. This information is used by perl when it's in adjust-utf8ness-to-locale mode (as when run with the -CL command-line switch); see perlrun for more info on this.

この変数は、起動時に perl によって UTF-8 ロケールが検出されたかどうかを 示します。 この情報は(-CL コマンドラインスイッチで起動されることによって) 「utf8 性をロケールに合わせる」モードのときに perl によって使われます; これに関するさらなる情報は perlrun を参照してください。

This variable was added in Perl v5.8.8.

この変数は Perl v5.8.8 で追加されました。

非推奨および削除された変数¶

非推奨となった変数は、perl のメンテナが最終的にこの変数を 削除するということを意図して通知されます。 その状態にも関わらず、まだ利用可能です。 非推奨となった変数を使うと警告が出ます。

変数が削除された後で変数を使うと、この変数が非対応となったことを 知らせるエラーが出ます。

エラーメッセージの詳細については perldiag を参照してください。

$#

$# was a variable that could be used to format printed numbers. After a deprecation cycle, its magic was removed in Perl v5.10.0 and using it now triggers a warning: $# is no longer supported.

$# は、表示番号をフォーマットするために使われていました。 非推奨化の後、このマジックは Perl v5.10.0 で取り除かれ、警告を 引き起こします: $# is no longer supported.

This is not the sigil you use in front of an array name to get the last index, like $#array. That's still how you get the last index of an array in Perl. The two have nothing to do with each other.

これは $#array のように最後のインデックスを得るために配列名の前に付ける 印ではありません。 これは今でも Perl で配列の最後のインデックスを得る方法です。 これら二つには互いに何の関係もありません。

Deprecated in Perl 5.

Perl 5 で非推奨となりました。

Removed in Perl v5.10.0.

Perl v5.10.0 で削除されました。

$*

$* was a variable that you could use to enable multiline matching. After a deprecation cycle, its magic was removed in Perl v5.10.0. Using it now triggers a warning: $* is no longer supported. You should use the /s and /m regexp modifiers instead.

$* は複数行マッチングを有効にするために使われていた変数です。 非推奨化の後、このマジックは Perl v5.10.0 で削除されました。 これを使うと警告を引き起こします: $* is no longer supported。 代わりに /s と /m の正規表現修飾子を使うべきです。

Deprecated in Perl 5.

Perl 5 で非推奨となりました。

Removed in Perl v5.10.0.

Perl v5.10.0 で削除されました。

$[

This variable stores the index of the first element in an array, and of the first character in a substring. The default is 0, but you could theoretically set it to 1 to make Perl behave more like awk (or Fortran) when subscripting and when evaluating the index() and substr() functions.

この変数は配列の最初の要素や、文字列の最初の文字のインデックスを 保管します。 デフォルトは 0 ですが、理論的には、index() 関数や substr() 関数を評価するときに、Perl の動作をより awk (や Fortran) に近づけるため、1 に設定することもできます。

As of release 5 of Perl, assignment to $[ is treated as a compiler directive, and cannot influence the behavior of any other file. (That's why you can only assign compile-time constants to it.) Its use is highly discouraged.

Perl 5 からは $[ への代入は、コンパイラ指示子として扱われ、 他のファイルの動作に影響を与えることがなくなりました。 (これが、コンパイル時定数しか代入できない理由です。) この変数の使用は非推奨です。

Prior to Perl v5.10.0, assignment to $[ could be seen from outer lexical scopes in the same file, unlike other compile-time directives (such as strict). Using local() on it would bind its value strictly to a lexical block. Now it is always lexically scoped.

Perl v5.10.0 より前では、$[ は(strict のような)その他のコンパイル時 指示子と異なり、同じファイルのレキシカルスコープの外側から見ることが 出来ていました。 これに local() を使うとこの値を厳密にレキシカルスコープの内側に限定します。 今では常にレキシカルスコープを持ちます。

As of Perl v5.16.0, it is implemented by the arybase module.

Perl v5.16.0 から、これは arybase モジュールで実装されています。

As of Perl v5.30.0, or under use v5.16, or no feature "array_base", $[ no longer has any effect, and always contains 0. Assigning 0 to it is permitted, but any other value will produce an error.

Perl v5.30.0 以降か、use v5.16 または no feature "array_base" の基では、 $[ はもはや何の効果もなく、常に 0 が入っています。 これに 0 を代入することは許されますが、それ以外の値はエラーを引き起こします。

Mnemonic: [ begins subscripts.

記憶法: [ は添え字付けの始め。

Deprecated in Perl v5.12.0.

Perl v5.12.0 で非推奨となりました。

${^ENCODING}

This variable is no longer supported.

この変数はもはや対応していません。

It used to hold the object reference to the Encode object that was used to convert the source code to Unicode.

これはソースコードを Unicode に変換するために使われる Encode オブジェクトへの オブジェクトリファレンス を保持していました。

Its purpose was to allow your non-ASCII Perl scripts not to have to be written in UTF-8; this was useful before editors that worked on UTF-8 encoded text were common, but that was long ago. It caused problems, such as affecting the operation of other modules that weren't expecting it, causing general mayhem.

この目的は、非 ASCII Perl スクリプトを UTF-8 で書く必要をなくすためでした; これは UTF-8 エンコードされたテキストで動作するエディタが一般的になる前は 有用でしたが、それはずっと前です。 これは、想定してない他のモジュールの操作に影響を与えるような問題を引き起こし、 一般的には破壊的です。

If you need something like this functionality, it is recommended that use you a simple source filter, such as Filter::Encoding.

この機能のような何かが必要な場合は、Filter::Encoding のような 単純なソースフィルタを使うことを勧めます。

If you are coming here because code of yours is being adversely affected by someone's use of this variable, you can usually work around it by doing this:

あなたがここに来た理由が、誰かがこの変数を使うことであなたのコードが 意図せずに影響を受けたためなら、通常は次のようにして回避できます:

 local ${^ENCODING};

near the beginning of the functions that are getting broken. This undefines the variable during the scope of execution of the including function.

これを壊れてしまった関数の先頭付近に書きます。 これにより、この関数を含むスコープを実行する間この変数を未定義にします。

This variable was added in Perl 5.8.2 and removed in 5.26.0. Setting it to anything other than undef was made fatal in Perl 5.28.0.

この変数は Perl 5.8.2 で追加され、5.26.0 で削除されました。 Perl 5.28.0 から、これに undef 以外の値を設定すると致命的エラーになります。

${^WIN32_SLOPPY_STAT}

This variable no longer has any function.

この変数はもはや何の機能もありません。

This variable was added in Perl v5.10.0 and removed in Perl v5.34.0.

この変数は Perl v5.10.0 で追加され、Perl v5.34.0 で削除されました。