NAME

perlref - Perlのリファレンスとネストしたデータ構造

注意

本ドキュメントはリファレンスに関するものです。チュートリアルに関しては perlreftut を参照してください。

DESCRIPTION

リリース 5 以前の Perl ではすべてのリファレンスはシンボリックでなければならなかったために、複雑なデータ構造を表現することが困難でした-- そしてシンボルテーブルのエントリーではなく変数を参照したいと望んだときも困難であったのです。 Perl はシンボリックリファレンスを変数として使うことを簡単にしただけでなく、任意のデータについて「ハード」リファレンスを持つことを可能としたのです。任意のスカラはハードリファレンスを保持することができます。配列とハッシュはスカラから構成されているので、あなたはいまや配列の配列、ハッシュの配列、配列のハッシュ、関数のハッシュの配列等々を簡単に組み立てることができるのです。

ハードリファレンスは賢く実際に参照されている数を管理していて、その数が 0 になれば自動的に解放を行ないます。 (自己参照や循環データ(cyclic data)にある値に対する参照カウントは、ちょっとした手助けなしにはゼロにはなりません; 詳しくは "Circular References" を参照してください。) そのものがオブジェクトであるときには、デストラクタが動作します。オブジェクトについてより詳しくは、perlobj を参照してください。 (ある意味では、Perl のすべてがオブジェクトですが、通常、クラスパッケージ内で公に "bless" されているものへのリファレンスに対して、この用語を用います。)

UNIX ファイルシステム上でのシンボリックリンクが単にファイルの名前を持っているだけであるのと同様に、シンボリックリファレンスは変数の名前を保持します。 *glob の記法は、シンボリックリファレンスの一種です (シンボリックリファレンスは時折“ソフトリファレンス”と呼ばれますが、そういう呼びかたをしないでください。リファレンスは同義語を使わないでいてさえ混乱を招くのですから)。

対照的に、ハードリファレンスはUNIXのファイルシステム上のハードリンクに似ています: ハードリンクはそれがなんの名前であるのかを気にせずに基礎をなすオブジェクトにアクセスするために使われます。以下の節にあるように“リファレンス”と言う言葉を形容なしに使った場合、通常はハードリファレンスのことを指します。

Perl でリファレンスを使うのは簡単です。原則のオーバーライドが一つあるだけです: Perl はリファレンス(referencing)やデリファレンス(defreferencing)を暗黙に行うことはありません。スカラがリファレンスを保持しているとき、それは常に単純なスカラとして振る舞います。勝手に配列や、ハッシュ、サブルーチンとして振る舞うようなことはありません; デリファレンスをすることによって、自分で明示的に Perl に教える必要があります。

とは言うものの、文法的な便利さのために、Perl バージョン 5.14 にはこの規則の例外が導入されたことに注意してください。実験的な配列とハッシュコンテナ関数の振る舞いは、配列とハッシュのリファレンスを、明示的に文法的にデリファレンスされたかのように Perl に扱わせます。詳しくは "Syntactical Enhancements" in perl5140delta と perlfunc を参照してください。

リファレンスを作る

リファレンスは幾つかのやり方で構築することができます。

1.

変数、サブルーチン、値にバックスラッシュ演算子を使うことによる。 (これは C での & (アドレス) 演算子に似た働きをします)。既にシンボルテーブルには変数へのリファレンスが存在していますから、この方法は別のリファレンスを作るものです。しかし、シンボルテーブルのリファレンスがなくなったとしても、バックスラッシュが返したリファレンスが存在することになります。例をいくつかあげます:

    $scalarref = \$foo;
    $arrayref  = \@ARGV;
    $hashref   = \%ENV;
    $coderef   = \&handler;
    $globref   = \*foo;

バックスラッシュ演算子を使って IO ハンドル(ファイルハンドルまたはディレクトリハンドル)へのリファレンスを生成することはできません。もっとも良く扱うリファレンスは型グロブに対するリファレンス(実際にはシンボルテーブルのエントリである)でしょう。後述する *foo{THING} 構文の説明を参照してください。しかしながら、IO ハンドルであったものとして型グロブや型グロブのリファレンス(grobref)を使うこともできます。

2.

名前の無い配列へのリファレンスは、大かっこを使って作ることができます:

    $arrayref = [1, 2, ['a', 'b', 'c']];

ここでは、『「名前の無い 3 個の要素を持つ配列」を最後の要素として持つ 3 個要素の名前の無い配列』へのリファレンスを作っています。 (あとで述べる多次元構文を使って、これをアクセスすることができます。たとえば、上記のようにした後では、 $arrayref->[2][1] が "b" となります。)

列挙リストに対するリファレンスを取るということは、大かっこを使うことと同じではありません--これはリファレンスのリストを生成することと同じなのです!

    @list = (\$a, \@b, \%c);
    @list = \($a, @b, %c);      # same thing!

特殊な場合として、\(@foo) は @foo 自身へのリファレンスではなく、 @foo の内容のそれぞれへのリファレンスのリストを返します。 %foo も同様ですが、キーのコピーに対するリファレンスである点が異なります(これはキーが完全なスカラではなく単なる文字列であるためです)。

3.

名前の無いハッシュへのリファレンスは、中かっこを使って作ることができます:

    $hashref = {
        'Adam'  => 'Eve',
        'Clyde' => 'Bonnie',
    };

無名ハッシュと配列のコンストラクタは、複雑な構造を作るために自由に組み合わせることができます。後述する多次元構文は、そのようなものに対しても使うことができます。上記の値はリテラルですが、変数や式であってもかまいません; Perl での代入演算は、(たとえ、local() や my() の中でも) コンパイル時の宣言文ではなく、実行文だからです。

中かっこは、BLOCK を始めとして他のことにも使われますから、開きの中かっこが BLOCK の開始でないことを Perl に教えるために文の最初の中かっこの前に + や return をつけて、曖昧さをなくすようにする必要がある場合があります。このちょっとした余分な作業は、中かっこの使用に関連して実際に使ってみる価値や覚えておくだけの価値があるでしょう。

たとえば、新しいハッシュを作って、それへのリファレンスを返す関数が欲しければ、以下のような選択肢があります:

    sub hashem {        { @_ } }   # silently wrong
    sub hashem {       +{ @_ } }   # ok
    sub hashem { return { @_ } }   # ok

その一方で、以下のようにすることもできます:

    sub showem {        { @_ } }   # ambiguous (currently ok, but may change)
    sub showem {       {; @_ } }   # ok
    sub showem { { return @_ } }   # ok

先頭にある +{ や {; が、その式が実際にはハッシュのリファレンスなのかブロックなのかの曖昧さを除去するためにあります。

4.

無名サブルーチンのへのリファレンスは、サブルーチン名の無い sub を使って作ることができます:

    $coderef = sub { print "Boink!\n" };

セミコロンに注意してください。内部のコードが即座に実行されるのではないということを除けば、sub{} は、宣言というよりもむしろ、do{} や eval{} のような演算子です。 (しかし、eval("...") の中でなければ、何回その行を実行しようとも $coderef は、同一の 無名サブルーチンをリファレンスすることになります)。

無名サブルーチンは my() 変数に関連するクロージャのように振る舞います; つまり、変数はカレントのスコープの中においてレキシカルに見えます。クロージャは、無名関数をある特定のレキシカルコンテキストで定義した場合にたとえそのコンテキストの外側で呼び出されたとしても定義されたときのコンテキストで実行されることを要求するという Lisp の世界の概念です。

わかりやすく言えば、あなたがサブルーチンを呼び出すときと同じように、サブルーチンを定義するときに引数を渡すという奇妙なやり方ということです。あなたはこれでオブジェクト指向的性質を実現することもできます。が、Perl はすでにこれとは異なる仕組みを提供しています -- perlobj を参照してください。

クロージャは eval なしにサブルーチンのテンプレートを記述する方法だという考え方もできます。以下に示すのは、クロージャがどのように動作するのかの例です。

    sub newprint {
        my $x = shift;
        return sub { my $y = shift; print "$x, $y!\n"; };
    }
    $h = newprint("Howdy");
    $g = newprint("Greetings");

    # Time passes...

    &$h("world");
    &$g("earthlings");

出力はこうなります。

    Howdy, world!
    Greetings, earthlings!

ここで特に、無名サブルーチンの実行時には“my $x”がスコープの外にあるにも かかわらず、$x が newprint() に渡された値を参照しつづけていることに注意してください。これがクロージャがクロージャたる由縁です。

これはレキシカル変数にのみ適用されます。動的変数はこれまでと同じように動作します。クロージャは、大部分の Perl プログラマーがそれを使いはじめるためにトラブルをしょいこんでしまうような代物ではありません。

5.

リファレンスはコンストラクタと呼ばれる特別なサブルーチンが返すようにしていることが多くなっています。 Perlのオブジェクトは、自分がどのパッケージと関係を持っているかを知っているものへのリファレンスでしかありません。コンストラクタは、その関係付けをどのように行なうかを知っているという意味で、特別なサブルーチンにすぎません。単なるリファレンスとしてスタートし、オブジェクトといわれている間でも通常のリファレンスであることに変わりはありません。コンストラクタは、慣習的に new() と名前を付けられます。間接的に呼び出すことも 可能です:

    $objref = new Doggie( Tail => 'short', Ears => 'long' );

しかし、これは場合によってはあいまいな文法となる場合があるので、たいていは直接メソッド起動手法を使う方がよいです:

    $objref   = Doggie->new(Tail => 'short', Ears => 'long');

    use Term::Cap;
    $terminal = Term::Cap->Tgetent( { OSPEED => 9600 });

    use Tk;
    $main    = MainWindow->new();
    $menubar = $main->Frame(-relief              => "raised",
                            -borderwidth         => 2)

6.

適切な型のリファレンスは、そういったリファレンスが存在するかのような文脈でデリファレンスを行うと、実際に存在するようになります。デリファレンスについてはまだ話していないので、まだ例を示すことができません。

7.

リファレンスは、*foo{THING} 構文として知られている特殊な構文を使って生成することができます。 *foo{THING} はリファレンスを *foo の THING スロット(これは foo として知られる全てのものを保持するシンボルテーブルのエントリです)に返します。

    $scalarref = *foo{SCALAR};
    $arrayref  = *ARGV{ARRAY};
    $hashref   = *ENV{HASH};
    $coderef   = *handler{CODE};
    $ioref     = *STDIN{IO};
    $globref   = *foo{GLOB};
    $formatref = *foo{FORMAT};

これら全ては、*foo{IO} を除いて自己説明的です。ファイルハンドル("open" in perlfunc)、ソケット("socket" in perlfunc と "socketpair" in perlfunc)、ディレクトリハンドル("opendir" in perlfunc) として使われる IO ハンドルを返します。過去のバージョンの Perl に対する互換性のために、 *foo{FILEHANDLE} は *foo{IO} の同義語ですが、5.8.0 からは非推奨です。非推奨警告が有効になっていれば、使用すると警告が出ます。

*foo{THING} は、スカラの場合を除いた特定の THING がまだ使われていない場合には undef を返します。 *foo{SCALAR} は、$foo がまだ使われていなかった場合には無名スカラへのリファレンスを返します。これは将来のリリースでは変わる可能性があります。

*foo{IO} は、"Typeglobs and Filehandles" in perldata にあるファイルハンドルをサブルーチンに渡したり、あるいは逆にサブルーチンから返すために、あるいは大きなデータ構造を格納するために用いられる *HANDLE 機構の代替です。その不利な点は新しいハンドルをあなたのために作り出すことはしないということです。有利な点は、型グロブの代入を使うよりも気をつかう必要があまりないということです。 (しかし、これはまだファイルハンドルとディレクトリハンドルを融合します。) しかし、もし以下の例で行っているように、値を型グロブではなくスカラに代入すると、起きることに対するリスクはありません。

    splutter(*STDOUT);          # pass the whole glob
    splutter(*STDOUT{IO});      # pass both file and dir handles

    sub splutter {
        my $fh = shift;
        print $fh "her um well a hmmm\n";
    }

    $rec = get_rec(*STDIN);     # pass the whole glob
    $rec = get_rec(*STDIN{IO}); # pass both file and dir handles

    sub get_rec {
        my $fh = shift;
        return scalar <$fh>;
    }

リファレンスを使う

リファレンスの作り方はこれだけです。ここまでくると、どこか参照のかなたへ行ってしまったデータを取り戻すために、どうやってリファレンスを使うかを知りたいことでしょう。基本的な方法がいくつかあります。

変数名やサブルーチン名の一部として識別子を置くところでは、適切な型のリファレンスを持った単純スカラ変数でその識別子を置き換えることができます:
```
    $bar = $$scalarref;
    push(@$arrayref, $filename);
    $$arrayref[0] = "January";
    $$hashref{"KEY"} = "VALUE";
    &$coderef(1,2,3);
    print $globref "output\n";
```
$arrayref[0] や $hashref{"KEY"} という形でしているの ではない ことが大切です。スカラ変数のデリファレンスは、いかなる key の検索よりも前に行なわれます。単純スカラ変数より込み入ったものはすべて、以下の 2 番か 3 番の方法が採られます。しかしながら、「単純スカラ」には、この 1 番目の方法を再帰的に使っている識別子も含まれます。したがって、以下はは、"howdy" と出力します。
```
    $refrefref = \\\"howdy";
    print $$$$refrefref;
```
変数名やサブルーチン名の一部として識別子を置くところでは、適切な型のリファレンスを返す BLOCK を伴う識別子で置き換えることができます。言い換えると、先の例は以下のように書くことができます:
```
    $bar = ${$scalarref};
    push(@{$arrayref}, $filename);
    ${$arrayref}[0] = "January";
    ${$hashref}{"KEY"} = "VALUE";
    &{$coderef}(1,2,3);
    $globref->print("output\n");  # iff IO::Handle is loaded
```
確かにこの場合には中かっこを付けるのはばかげたことかもしれませんが、 BLOCK には任意の式、特に添字を付けた式を入れることができます:
```
    &{ $dispatch{$index} }(1,2,3);      # call correct routine
```
単純な <$$x> の場合には中かっこが省略できるので、シンボルのデリファレンスを適当な演算子のように受け取って、その優先順位はどのくらいかと悩む人があります。しかし、もし演算子であれば、中かっこの代わりに、普通の括弧が使えることでしょう。そうではありません。以下の違いを考えてみてください; CASE 0 は、CASE 1 を短くしたものであり、 CASE 2 を短くしたものでは ありません:
```
    $$hashref{"KEY"}   = "VALUE";       # CASE 0
    ${$hashref}{"KEY"} = "VALUE";       # CASE 1
    ${$hashref{"KEY"}} = "VALUE";       # CASE 2
    ${$hashref->{"KEY"}} = "VALUE";     # CASE 3
```
CASE 2 もまた間違えやすいもので、%hashref という変数をアクセスするものです; $hashref を仲介して、それが指すことになっているハッシュをデリファレンスしているものではありません。それは、CASE 3 です。
配列の個々の要素を使う場合が増えると、2 番の方法を使うのが煩わしくなってきます。構文上の打開策として上記の 2 行は、以下のように書けます:
```
    $arrayref->[0] = "January";   # Array element
    $hashref->{"KEY"} = "VALUE";  # Hash element
    $coderef->(1,2,3);            # Subroutine call
```
矢印の左側には先行するデリファレンスを含めて、リファレンスを返す任意の式が書けます。 $array[$x] は、$array->[$x] と 同じではない ことに注意してください:
```
    $array[$x]->{"foo"}->[0] = "January";
```
これが、先の左辺値コンテキストで用いるとリファレンスが存在するようになるというケースの一つです。この文以前には、$array[$x] は未定義かもしれません。その場合自動的にハッシュリファレンスと定義されて、{"foo"} が検索できるようになります。同じように $array[$x]->{"foo"} が配列リファレンスで定義されるので、 [0] をそこで探すことができます。このプロセスは 自動有効化 (autovivification) と呼ばれます。

もう一つ。矢印は、括弧付きの添字の間では、省略することができるので、上の例は、以下のように書けます:
```
    $array[$x]{"foo"}[0] = "January";
```
通常の配列だけを使うように限定すれば、ちょうど C の多次元配列のように使うことができます:
```
    $score[$x][$y][$z] += 42;
```
ああ、そうだ、実際には全く C の配列と同じという訳ではありません。 C では、必要に応じて配列を大きくするなどということはできません。 Perl では、それができます。
リファレンスが、オブジェクトに対するものである場合には、参照されるものをアクセスするためのメソッドがあるはずで、オブジェクトのメソッドを定義するクラスパッケージ内でなければ、そのメソッドを使うようにした方が良いでしょう。言い換えると、良識をもって、特別正当な理由がない限り、オブジェクトのカプセル化を反古にしてはいけないということです。 Perl は、カプセル化を強要したりはしません。私達は、全体主義者ではありません。ただ、なにがしかの基本的な節度を期待しています。

文字列や数値をリファレンスとして使うと、上述したようにシンボリックリファレンスを生成します。リファレンスを数値として使うと、メモリ内のストレージの位置の整数表現を生成します。これを利用して便利な唯一の状況は、二つのリファレンスを数値として比較することで、同じ場所を参照しているかどうかを調べる場合です。

    if ($ref1 == $ref2) {  # cheap numeric compare of references
        print "refs 1 and 2 refer to the same thing\n";
    }

リファレンスを文字列として使うと、参照しているものの型 (perlobj で記述しているように、bless しているパッケージを含みます)と、 16 進数で表現された数値アドレスの両方を生成します。 ref() 演算子は、アドレス抜きで、リファレンスが示しているものの型だけを返します。この使い方の詳細と例については "ref" in perlfunc を参照してください。

bless() 演算子は、オブジェクトをオブジェクトクラスとして機能するパッケージと結び付けるために使うことができます。 perlobj を参照してください。

デリファレンスの構文では常に目的とするリファレンスの型を示すことができるので、型グロブをリファレンスと同じようにデリファレンスすることができます。つまり、${*foo} と ${\$foo} は、どちらも同じスカラ変数を示すことになります。

次の例に示すのは、文字列にサブルーチン呼び出しを埋め込む仕掛けです:

    print "My sub returned @{[mysub(1,2,3)]} that time.\n";

ダブルクォートで囲まれた文字列中に @{...} が見つかると、その文字列はブロックとして評価されます。ブロックでは、mysub(1,2,3) の呼び出しを実行し、その結果に対する無名配列へのリファレンスが作られます。つまり、ブロック全体では、配列へのリファレンスを返すこととなり、 @{...} でデリファレンスされた後、ダブルクォートで囲まれた文字列の中に、埋め込まれることになります。このごまかしは任意の式にも有用です:

    print "That yields @{[$n + 5]} widgets\n";

同様に、スカラへのリファレンスを返す式は ${...} でデリファレンスできます。従って、上述の式は以下のように書けます:

    print "That yields ${\($n + 5)} widgets\n";

循環参照

Perl では「循環参照」を作ることが可能で、これはメモリリークを引き起こします。循環参照は次のように、二つのリファレンスが対外へのリファレンスを含んでいるときに起こります:

    my $foo = {};
    my $bar = { foo => $foo };
    $foo->{bar} = $bar;

また、単一の変数でも循環参照を作ることができます:

    my $foo;
    $foo = \$foo;

この場合、この変数の参照カウントは決して 0 になることはなく、リファレンスはガベージコレクションされることはありません。これはメモリリークを引き起こします。

Perl のオブジェクトはリファレンスとして実装されているので、オブジェクトでも循環参照を作ることが可能です。それぞれのノードが親ノードと子ノードを参照している TreeNode クラスを考えてみます。親のあるノードは循環参照の一部となります。

「弱い参照」を作ることで循環参照を壊すことができます。弱い参照はは変数に対する参照カウントを増やさないので、オブジェクトはスコープ外に出て破壊できるようになります。 Scalar::Util モジュールでエクスポートされる weaken 関数でリファレンスを弱い参照にすることができます。

以下は最初の例をより安全にする方法です:

    use Scalar::Util 'weaken';

    my $foo = {};
    my $bar = { foo => $foo };
    $foo->{bar} = $bar;

    weaken $foo->{bar};

$foo から $bar へのリファレンスは弱い参照になります。 $bar 変数がスコープ外になると、ガベージコレクションされます。次回 $foo->{bar}キーの値を見ると、undef になります。

この行動は離れたところから見ると混乱するかも知れないので、弱い山椒の使用は慎重に行うべきです。 最初に スコープ外に出る変数のリファレンスを弱い参照にする必要があります。そのように、長生きする変数は、スコープ外に出るまで想定されるリファレンスを含んでいます。

シンボリックリファレンス

リファレンスはもし未定義であれば必要に応じて存在するようになると言いましたが、もしリファレンスとして使われた値が既に定義されていたときにはどのようになるのか示していませんでした。これはハードリファレンスでは ありません。リファレンスとして使ったならそれはシンボリックリファレンスとして扱われます。つまり、スカラの値は(おそらく)無名の値への直接のリンクではなく、変数の名前として扱われます。

そのように働くと思われていることが多いものです。ですからそう動作するのです。

    $name = "foo";
    $$name = 1;                 # Sets $foo
    ${$name} = 2;               # Sets $foo
    ${$name x 2} = 3;           # Sets $foofoo
    $name->[0] = 4;             # Sets $foo[0]
    @$name = ();                # Clears @foo
    &$name();                   # Calls &foo() (as in Perl 4)
    $pack = "THAT";
    ${"${pack}::$name"} = 5;    # Sets $THAT::foo without eval

これは強力で、かつ多少危険でもあります; (最大限の注意をはらって) ハードリファレンスを使おうとした場合にも、誤ってシンボリックリファレンスを使ってしまうような場合があるからです。これを防止するには、以下のように書いて

    use strict 'refs';

囲っているブロック内の残りの部分ではハードリファレンスのみが許されるようにすることができます。内側のブロックでは、以下のように書いて打ち消すこともできます:

    no strict 'refs';

シンボリックリファレンスでは、パッケージ変数(ローカル化されていたとしてもグローバル)だけを見ることができます。 (my() で宣言した) レキシカル変数は、シンボルテーブルに存在しないのでシンボリックリファレンスでは参照することができません。たとえば:

    local $value = 10;
    $ref = "value";
    {
        my $value = 20;
        print $$ref;
    }

これは、20 ではなく、10 と出力します。 local() は、パッケージで「グローバルな」、パッケージ変数に影響するものです。

あまりシンボリックではないリファレンス

perl のバージョン 5.001 から、中かっこに囲まれたシンボリックリファレンスはちょうどそれが文字列の中にあるかのように、識別子や変数名を式の残りから単純に分離するという働きができました。例えば、

    $push = "pop on ";
    print "${push}over";

とすると push が予約語であるにも関らず常に“pop on over”となります。 5.001 では、囲まれるダブルクォートがなくても同じように動作するように一般化されたので

    print ${push} . "over";

や

    print ${ push } . "over";

でさえも同じ効果となります。 (これは Perl 4 が空白無しの形式を許しているにも関らず、 Perl 5.000 では構文エラーとなります)。この構造はあなたが strict refs を使っているときに、シンボリックリファレンスであることを考慮 していません。

    use strict 'refs';
    ${ bareword };      # Okay, means $bareword.
    ${ "bareword" };    # Error, symbolic reference.

同様に、添え字付けのすべてが単一の語で行われているので、同じルールをハッシュに対する添え字付けに使われる任意の裸の単語に適用します。ですから、

    $array{ "aaa" }{ "bbb" }{ "ccc" }

の代わりに以下のように書けて:

    $array{ aaa }{ bbb }{ ccc }

そして添え字が予約語であるかどうかを心配することはありません。以下のようなことがしたいという珍しい場合には:

    $array{ shift }

裸の単語でないようにさせる何かを追加することで、予約語であるように強制的に解釈させることができます:

    $array{ shift() }
    $array{ +shift }
    $array{ shift @_ }

use warnings プラグマや -w スイッチは文字列が予約語として解釈されたときには警告を発します。しかし、あなたが小文字だけからなる単語を使った場合にはもはや警告されません; なぜなら文字列は事実上クォートされているからです。

擬似ハッシュ: 配列をハッシュとして使う

疑似ハッシュは Perl から削除されました。 'fields' プラグマはまだ利用可能です。

関数テンプレート

先に説明したように、関数がコンパイルされたときに可視なレキシカル変数にアクセスする無名関数はクロージャを作ります。そういった変数に対するアクセスは、シグナルハンドラや Tk のコールバックのように、あとで実行されるときまで保持されてきた値を取り出します。

関数テンプレートとしてクロージャを使うことによって、同じような関数をたくさん作ることが可能になります。ここで、あなたが様々な色のためにフォントを変更する HTML を生成するような色の名前のついた関数を必要としているとしましょう:

    print "Be ", red("careful"), "with that ", green("light");

red() と green() といった関数は似通ったものになります。これらを作り出すために、作ろうとしている関数の名前の型グロブにクロージャを代入します。

    @colors = qw(red blue green yellow orange purple violet);
    for my $name (@colors) {
        no strict 'refs';       # allow symbol table manipulation
        *$name = *{uc $name} = sub { "<FONT COLOR='$name'>@_</FONT>" };
    }

これで、それぞれの関数が別個に作成されます。 red(), RED(), blue(), BLUE(), green() のように呼び出すことが可能です。このテクニックはコンパイル時間とメモリーの使用量を抑え、またエラーを少なくします; なぜなら、構文チェックはコンパイル時に行われるからです。適切なクロージャを作成するために、無名サブルーチンにある変数はすべてレキシカルであることが重要です。これはループの繰り返し変数に対する my の理由と同じです。

これはクロージャにプロトタイプを与えるための場所の一つでもあります。生成する関数の引数にスカラコンテキストを与えようとするなら (おそらくはこの例に関してはあまり賢いやり方ではないでしょう)、代わりに以下のように記述できます:

    *$name = sub ($) { "<FONT COLOR='$name'>$_[0]</FONT>" };

しかしながら、プロトタイプの検査はコンパイル時に行われるので、この代入文はプロトタイプを使うには遅すぎるのです。代入文のループ全体を BEGIN ブロックに置いてすべてをコンパイル時に行うようにすることでこれに対処することができます。

時間によって変わるようなレキシカル変数に対するアクセス -- 例えば先の例の for ループのように、基本的に取り囲むレキシカルスコープからの要素への別名 -- は無名サブルーチンにおいてのみ動作し、名前付きサブルーチンでは動作しません。一般的に言うと、名前付きサブルーチンは適切にネストすることはなく、 main パッケージスコープ内でのみ宣言されるべきです。

これは、名前つきのサブルーチンはコンパイル時に一度だけ作成されるので、そのレキシカル変数は、親ブロックの最初の実行時から親レキシカルに代入されるからです。親スコープに 2 回目に入ると、レキシカルは再作成される一方、ネストしたサブルーチンは古いものを参照したままです。

無名サブルーチンは、'sub' 演算子が実行され、その場で作成される毎に捕捉されます。他のプログラミング言語にあるような、固有のプライベート変数を持ったネストしたサブルーチンを使いたいのであれば、Perl ではちょっと手間がかかります。直感的にこうだと思うようなコーディングは、上述の理由により不可思議な警告 "will not stay shared" となるでしょう。例を挙げると、以下の例はうまく動作しません:

    sub outer {
        my $x = $_[0] + 35;
        sub inner { return $x * 19 }   # WRONG
        return $x + inner();
    }

以下のようにするとうまくいきます:

    sub outer {
        my $x = $_[0] + 35;
        local *inner = sub { return $x * 19 };
        return $x + inner();
    }

これで、inner() は outer() の中からのみ呼び出せるようになります; なぜなら、無名サブルーチンの一時変数に対する代入があるからです。しかしこれを行ったとき、outer() が起動するときの outer() のスコープからレキシカル変数 $x のアクセスは通常通りです。

これは、通常 Perl ではサポートされていないような、ある関数にローカルな関数を生成するときの興味深い効果です。

警告

リファレンスをハッシュに対するキーとして使うことは(普通は)できません。それは文字列へ変換されてしまいます:

    $x{ \$a } = $a;

キーをデリファレンスしようとするのであれば、それはハードリファレンスには働かず、そして、あなたがしようとしたことはできないでしょう。次のような書き方をしたいと思うかもしれません

    $r = \@a;
    $x{ $r } = $r;

動作しない keys() の代わりに、少なくとも本当のリファレンスとなる values() を使うことができます。

標準モジュール Tie::RefHash はこれを扱いやすくするための手段を提供しています。