perlsub - Perl のサブルーチン
サブルーチンを宣言するには:
sub NAME; # "先行" 宣言。
sub NAME(PROTO); # 同上; ただしプロトタイプ付き
sub NAME : ATTRS; # 属性付き
sub NAME(PROTO) : ATTRS; # 属性とプロトタイプ付き
sub NAME BLOCK # 宣言と定義。
sub NAME(PROTO) BLOCK # 同上; ただしプロトタイプ付き
sub NAME : ATTRS BLOCK # 属性付き
sub NAME(PROTO) : ATTRS BLOCK # プロトタイプと属性付き
use feature 'signatures';
sub NAME(SIG) BLOCK # with signature
sub NAME :ATTRS (SIG) BLOCK # with signature, attributes
sub NAME :prototype(PROTO) (SIG) BLOCK # with signature, prototype実行時に無名サブルーチンを定義するには:
$subref = sub BLOCK; # プロトタイプなし
$subref = sub (PROTO) BLOCK; # プロトタイプ付き
$subref = sub : ATTRS BLOCK; # 属性付き
$subref = sub (PROTO) : ATTRS BLOCK; # プロトタイプと属性付き
use feature 'signatures';
$subref = sub (SIG) BLOCK; # with signature
$subref = sub : ATTRS(SIG) BLOCK; # with signature, attributesサブルーチンをインポートするには:
use MODULE qw(NAME1 NAME2 NAME3);サブルーチンを呼び出すには:
NAME(LIST); # かっこが付いているときは & は省略可能。
NAME LIST; # 予め宣言/インポートされているならかっこは省略可能。
&NAME(LIST); # プロトタイプを回避する。
&NAME; # 呼び出されたサブルーチンから現在の @_ を可視化する。多くの言語と同様、Perl はユーザー定義のサブルーチンを提供しています。 これらのサブルーチンは、メインプログラムのどこにでも置くことができ、 do, require, use といったキーワードを使って他のファイルから ロードすることができ、eval や無名サブルーチンを使って 生成することもできます。 サブルーチンの名前や、コードリファレンスを保持する変数を使って 間接的に関数を呼び出すことも可能です。
Perl での関数呼び出しと戻り値のモデルは単純です。全ての関数は引数を、 平坦で一つのスカラのリストで受け取り、同様に全ての関数は呼び出し元に 対して平坦で一つのスカラのりストで返すというものです。 これらの呼び出しリストと戻り値リストにある全ての配列とハッシュは、 潰されてそのアイデンティティを失います。 しかし、これを避けるために常にリファレンスで渡すことができます。 呼び出しリストと戻り値リストの両方とも好きなだけの数のスカラを 保持することができます(明確な return 文のない関数はしばしばサブルーチンと 呼ばれますが、Perl の定義上はこれらの間に何の違いもありません)。
ルーチンに渡されるすべての引数は配列 @_ に置かれます。 (シグネチャによって導入されたレキシカル変数にも現れることがあります; 後述する "Signatures" を参照してください。) したがって、ある関数を二つの引数を付けて呼び出したならば、 その引数は $_[0] と $_[1] に格納されます。 配列 @_ は local 配列ですが、その要素は実際の スカラパラメータの別名です。 たとえば $_[0] が更新された場合、対応する引数が更新されます (更新できない場合にはエラーとなります)。 引数が、配列やハッシュの(関数が呼び出された時点では存在してない) 要素であった場合、その要素は(対応する別名が)修正されたり リファレンスが取られたときにのみ作成されます。 (以前の一部のバージョンの Perl では、この要素は代入が行われようが行われまいが 作成されていました。) 配列 @_ 全体に対する代入は別名を破棄し、何の引数も更新しません。
サブルーチンから脱出するために使われた return 文が 使われることもありますし、サブルーチン呼び出しのコンテキストによって 適切なコンテキスト(リスト、スカラ、無効)で評価される戻り値の指定を 省略する事が可能です。 もし何の戻り値も指定しなければ、サブルーチンはリストコンテキストにおいては 空リストを返し、スカラコンテキストにおいては未定義値を返し、 無効コンテキストではなにも返しません。 一つまたは複数の集合体 (配列やハッシュ) を返す場合、一つの大きな区別できない リストに平板化されます。
return がなく、最後の文が式だった場合、その値が返されます。 最後の文が foreach や while のようなループ制御構造だった場合、 返される値は不定です。 空のサブルーチンは空リストを返します。
実験的な機能 (後述の "Signatures" 参照) を除いて、Perl は名前付き仮引数を 持っていません。 my() にこれらのリストを代入することで行えます。 プライベートであると宣言されずに使われている変数は全てグローバル変数です。 プライベート変数に関する詳細は"Private Variables via my()" と "Temporary Values via local()" を参照してください。 パッケージで(おそらくはファイルでも)分けられている関数のセットのための 保護された環境を作るには "Packages" in perlmod を参照してください。
例:
sub max {
my $max = shift(@_);
foreach $foo (@_) {
$max = $foo if $max < $foo;
}
return $max;
}
$bestday = max($mon,$tue,$wed,$thu,$fri);例:
# 行を取り、空白で始まる継続行を連結します
sub get_line {
$thisline = $lookahead; # global variables!
LINE: while (defined($lookahead = <STDIN>)) {
if ($lookahead =~ /^[ \t]/) {
$thisline .= $lookahead;
}
else {
last LINE;
}
}
return $thisline;
}
$lookahead = <STDIN>; # get first line
while (defined($line = get_line())) {
...
}引数に名前を付けるためにプライベート変数のリストに代入する:
sub maybeset {
my($key, $value) = @_;
$Foo{$key} = $value unless $Foo{$key};
}これは、参照渡しを値渡しにする効果もあります; なぜなら、値のコピーを 代入しているからです。 このようにしないのであれば、関数は自由に @_ の値をその場で 書き換えることができ、それはそのまま呼び出し側の値を変更します。
upcase_in($v1, $v2); # this changes $v1 and $v2
sub upcase_in {
for (@_) { tr/a-z/A-Z/ }
}もちろん、このやり方で定数を変更することは許されません。 ある引数が実際にはリテラルであった場合にその引数を変更しようとすると、 (おそらくは致命的な)例外が引き起こされることになるでしょう。 例えば次の例はうまく働きません:
upcase_in("frederick");upcase_in() 関数を安全なものにするには、パラメータそのものを 書き換えるのではなくそのコピーを返すように記述するようにします:
($v3, $v4) = upcase($v1, $v2); # this doesn't change $v1 and $v2
sub upcase {
return unless defined wantarray; # void context, do nothing
my @parms = @_;
for (@parms) { tr/a-z/A-Z/ }
return wantarray ? @parms : $parms[0];
}この(プロトタイプがついていない)関数が自分に対して本当のスカラが 渡されたのか配列が渡されたのかを気にしていないということに注意してください。 Perl は一つの巨大な平坦な(リストの中にリストが含まれることはない、 ということ) @_ パラメータリストとして全ての引数を見るのです。 これは Perl の単純な引数渡しの形式のやり方の一つです。 この upcase() 関数は、以下のような呼び出しをした場合でも upcase() の 定義を変更することなく完璧に動作します:
@newlist = upcase(@list1, @list2);
@newlist = upcase( split /:/, $var );ただし、以下のような呼び出しをやろうとしてはいけません:
(@a, @b) = upcase(@list1, @list2);関数に渡される引数リストは平坦なリストであるのと同様、戻り値のリストも また平坦なリストです。 ですから、関数が返した全ての要素は @a に格納され、@b は 空になります。 別のやり方については "Pass by Reference" を参照してください。
サブルーチンは、明示的な & というプリフィックスを付けて呼び出すことが できます。 最近の Perl では & は省略可能であり、サブルーチンがあらかじめ 宣言されている場合には括弧も省略できます。 defined() や undef() の引数として使ったような、単なる名前付き サブルーチンであるときの & は 省略可能ではありません。 &$subref() や &{$subref}() のような、サブルーチンの名前や リファレンスを使った間接的なサブルーン呼び出しを行いたいたいときにも & は省略することはできません; 但し $subref->() の記法が問題を 解決します。 詳しくは perlref を参照してください。
サブルーチンは再帰的に呼び出すこともできます。 あるサブルーチンが & 付きで呼び出されたなら、引数リストは省略可能で、 もし省略されたなら、そのサブルーチンに対して @_ 配列は設定されません: 代わりに呼び出し時の @_ 配列がサブルーチンに対して可視となります。 これは新しいユーザーが避けたいと思う効果的なメカニズムです。
&foo(1,2,3); # 三つの引数を渡す
foo(1,2,3); # 上と同じ
foo(); # 空リストを渡す
&foo(); # 上と同じ
&foo; # foo() は foo(@_) と同様現在の引数を取る!!
use strict 'subs';
foo; # サブルーチン foo が予め定義されている場合に限り
# foo() と同様、それ以外ではコンパイル時エラー
no strict 'subs';
foo; # サブルーチン foo が予め定義されている場合に限り
# foo() と同様、それ以外では文字列リテラル "foo"& 形式は引数リストを省略可能にするばかりでなく、与えられた引数に 対するすべてのプロトタイプチェックも無効にします。 これは一部には歴史的な理由であり、一部にはあなたが自分の行っている動作を わかっているときにうまくごまかしを行う便利な方法を残しておくためです。 後に出てくる "Prototypes" を参照してください。
Perl 5.16.0 から、use feature 'current_sub' または use 5.16.0 が有効の 場合は __SUB__ トークンが利用可能です。 これは現在実行しているサブルーチンへのリファレンスを評価するので、 現在のサブルーチン名を知ることなく再帰呼び出しができるようになります。
use 5.16.0;
my $factorial = sub {
my ($x) = @_;
return 1 if $x == 1;
return($x * __SUB__->( $x - 1 ) );
};(/(?{...})/ のような) 正規表現コードブロック中の __SUB__ の振る舞いは 変更されるかもしれません。
名前が全て大文字であるサブルーチンは、名前が全て小文字のモジュール名が (訳注: pragma 用として) 予約されているのと同じように Perl のコアで予約されています。 実行時にシステム自身によって (通常はイベントをトリガーとして) 間接的に 呼び出されるサブルーチンは、名前を全て大文字で書くのがしきたりです。 特殊で、あらかじめ決められていることをするサブルーチンは、 AUTOLOAD, CLONE, DESTROY に、perltie と PerlIO::via で 説明されている関数全てを加えたものです。 名前が左かっこで始まるようなサブルーチンも同様に予約されています。 以下は現在のところ特殊で事前に定義されていることがあるサブルーチンの一覧です。
AUTOLOAD
CLONE, CLONE_SKIP
DESTROY, DOES
BINMODE, CLEAR, CLOSE, DELETE, DESTROY, EOF, EXISTS, EXTEND, FETCH, FETCHSIZE, FILENO, FIRSTKEY, GETC, NEXTKEY, OPEN, POP, PRINT, PRINTF, PUSH, READ, READLINE, SCALAR, SEEK, SHIFT, SPLICE, STORE, STORESIZE, TELL, TIEARRAY, TIEHANDLE, TIEHASH, TIESCALAR, UNSHIFT, UNTIE, WRITE
BINMODE, CLEARERR, CLOSE, EOF, ERROR, FDOPEN, FILENO, FILL, FLUSH, OPEN, POPPED, PUSHED, READ, SEEK, SETLINEBUF, SYSOPEN, TELL, UNREAD, UTF8, WRITE
VERSION
DB::DB, DB::sub, DB::lsub, DB::goto, DB::postponed
( で始まるもの全て
BEGIN, UNITCHECK, CHECK, INIT, END サブルーチンは サブルーチンというよりは特殊コードブロックで、その中でも一つのパッケージに 複数作ることができ、明示的には 呼び出せません 。 "BEGIN, UNITCHECK, CHECK, INIT and END" in perlmod を参照してください。
警告: サブルーチンシグネチャは実験的です。 この機能は将来のバージョンの Perl で変更されたり削除されたりすることが あります。
Perl は、サブルーチン本体の手続き的コードと分離された特殊な文法を 導入することで、サブルーチンの仮引数を指定できる実験的機能を持ちます。 仮引数リストは シグネチャ (signature) として知られます。 この機能は、use feature 'signatures' というプラグマ宣言で 有効化しなければならず、"experimental::signatures" 警告カテゴリが無効に なっていない限り警告が生成されます。
シグネチャはサブルーチンの本体の一部です。 通常サブルーチンの本体は単に中かっこのブロックのコードですが、 シグネチャを使うとき、シグネチャはブロックの直前、 なんらかの名前や属性の直後に置かれたかっこつきリストです。
例えば、
sub foo :lvalue ($a, $b = 1, @c) { .... }シグネチャはそのブロックのスコープのレキシカル変数を宣言します。 サブルーチンが呼び出されるとき、シグネチャが最初に制御します。 渡された引数リストからシグネチャ変数を作ります。 引数リストがシグネチャの要求に一致しない場合、例外が投げられます。 シグネチャ処理が完了したとき、制御はブロックに移ります。
位置パラメータは単にシグネチャの名前付きスカラ変数で扱われます。 例えば
sub foo ($left, $right) {
return $left + $right;
}これは二つの位置パラメータを持ち、二つの引数によって実行時に 埋められなければなりません。 デフォルトではパラメータは必須で、想定以上の引数を渡すことは許されません。 従って前述のものは以下と等価です
sub foo {
die "Too many arguments for subroutine" unless @_ <= 2;
die "Too few arguments for subroutine" unless @_ >= 2;
my $left = $_[0];
my $right = $_[1];
return $left + $right;
}引数は、パラメータ宣言の名前のメイン部分を省略して裸の $ 印だけに することで無視できます。 例えば、
sub foo ($first, $, $third) {
return "first=$first, third=$third";
}無視された引数は変数には入りませんが、呼び出し元から渡されるときには 必須のままです。
位置パラメータは、パラメータ名と = で分けられたデフォルト値を与えることで オプションにできます:
sub foo ($left, $right = 0) {
return $left + $right;
}前述のサブルーチンは 1 引数か 2 引数で呼び出せます。 デフォルト値式はサブルーチンが呼び出されるときに評価されます; 従って 呼び出し毎に異なったデフォルト値を提供できます。 これは呼び出しで引数が実際に省略されたときにのみ評価されます。 例えば、
my $auto_id = 0;
sub foo ($thing, $id = $auto_id++) {
print "$thing has ID $id";
}これは、呼び出し元から ID が指定されなかった場合、ユニークな連番 ID が 自動的に代入されます。 デフォルト値式はシグネチャ内で前にあるパラメータを参照することもでき、 前のパラメータによって異なったパラメータのデフォルトを作ります。 例えば、
sub foo ($first_name, $surname, $nickname = $first_name) {
print "$first_name $surname is known as \"$nickname\"";
}オプションのパラメータは必須のパラメータと同様に名前なしにできます。 例えば、
sub foo ($thing, $ = 1) {
print $thing;
}パラメータのデフォルト値は対応する引数が指定されなくても評価されますが、 その値はどこにも保管されません。 これは、評価が重要な副作用を持つ場合です。 しかし、これは無効コンテキストで評価されるので、副作用がなくて ありふれていなければ、"void" 警告カテゴリが有効の場合は警告が生成されます。 名前なしオプションパラメータのデフォルト値が重要でないなら、パラメータの名前と 同じように省略できます:
sub foo ($thing, $=) {
print $thing;
}オプション位置パラメータは全ての必須位置パラメータの 後ろでなければなりません。 (必須位置パラメータがない場合は、オプション位置パラメータをシグネチャの 最初の位置に置けます。) 複数のオプション位置パラメータがあって全てのパラメータを設定するのに十分な 引数が供給されなかった場合、左から右に設定されます。
位置パラメータの後、追加の引数は吸い込みパラメータに捕捉されます。 これの最も単純な形式は単なる配列変数です:
sub foo ($filter, @inputs) {
print $filter->($_) foreach @inputs;
}シグネチャで吸い込みパラメータがある場合、渡せる引数の数に上限はありません。 吸い込み配列パラメータは位置パラメータと同様に名前なしにでき、この場合は その他の場合で適用される引数制限をオフにする効果のみがあります:
sub foo ($thing, @) {
print $thing;
}吸い込みパラメータは代わりにハッシュにすることもでき、その場合利用可能な 引数は交互にキーと値として解釈されます。 キーと値の数は同じでなければなりません: 引数が奇数だと例外が投げられます。 キーは文字列化され、重複があると、通常のハッシュの構築と同じように、 後から指定したものが先に指定したものを上書きします。
sub foo ($filter, %inputs) {
print $filter->($_, $inputs{$_}) foreach sort keys %inputs;
}吸い込みハッシュパラメータは他の種類のパラメータと同様に名前なしにできます。 変数に代入されなくても、利用できる引数の数が偶数であるという必要はあります。
sub foo ($thing, %) {
print $thing;
}吸い込みパラメータは、配列でもハッシュでも、シグネチャの 最後でなければなりません。 必須とオプションの位置パラメータに引き続くことができます; シグネチャの唯一の 要素でもかまいません。 吸い込みパラメータはデフォルト値を持つことはできません: 引数が指定されないと 空配列や空ハッシュを得ます。
シグネチャは完全に空にすることもできます; この場合、呼び出し側が引数を 渡していないことだけをチェックします:
sub foo () {
return 123;
}シグネチャを使うときも、シグネチャ引数のレキシカル変数に加えて、 特殊配列変数 @_ にも入ります: @_ は引数の 別名 ですが、 シグネチャ変数は引数の コピー です。 従って、シグネチャ変数に書き込むとその変数だけが変更され、呼び出し元の 変数には影響しませんが、@_ の要素に書き込むと引数を指定した呼び出し元が 使ったものが修正されます。
シグネチャとプロトタイプ("Prototypes" 参照)の間には潜在的に文法的な あいまいさがあります; 両方とも開きかっこで始まり、サブルーチン宣言の名前の 直後といった同じ場所に現れるからです。 歴史的な理由により、シグネチャが有効でない場合、このようなコンテキストでの あらゆる開きかっこはとても寛容なプロトタイプのパースを引き起こします。 ほとんどのシグネチャはこの状態ではプロトタイプとして解釈されますが、 正当なプロトタイプではありません。 (正当なプロトタイプは英数字を含むことができません。) これは少し混乱したエラーメッセージを引き起こします。
曖昧さを避けるために、シグネチャが有効の時はプロトタイプのための特殊文法は 無効になります。 かっこのグループがプロトタイプかシグネチャかを推測しようとはしません。 この状態でサブルーチンにプロトタイプを指定するには、 プロトタイプ属性 を使ってください。 例えば、
sub foo :prototype($) { $_[0] }プロトタイプとシグネチャの両方を持ったサブルーチンは完全に可能です。 これらは異なった仕事をします: プロトタイプはサブルーチン呼び出しのコンパイルに 影響を与え、シグネチャは実行時に引数の値をレキシカル変数に設定します。 従って、このように書けます
sub foo :prototype($$) ($left, $right) {
return $left + $right;
}プロトタイプ属性、およびその他の属性はシグネチャの前に来なければなりません。 シグネチャは常にサブルーチンの本体のブロックの直前です。
概要:
my $foo; # declare $foo lexically local
my (@wid, %get); # declare list of variables local
my $foo = "flurp"; # declare $foo lexical, and init it
my @oof = @bar; # declare @oof lexical, and init it
my $x : Foo = $y; # similar, with an attribute applied警告: my 定義での属性リストの使用はいまだ改良の途中です。 現在の文法とインターフェースは変更される可能性があります。 attributes と Attribute::Handlers を参照してください。
my 演算子は、それを囲んでいるブロック、条件文 (if/unless/elsif/else)、ループ (for/foreach/while/until/continue)、サブルーチン、eval、 あるいは do/require/use されたファイルにレキシカルに閉じ込められる 変数を定義します。二つ以上リストアップされている場合には、そのリストは 括弧でくくられていなければなりません。 すべてのリスト要素は正しい左辺値でなければなりません。 $/ のような組み込み変数が現時点では local で 局所化 されなければならないのに対し、 アルファベットと数字による識別子はレキシカルでマジカルなスコープになります。
local 文によって生成される動的変数とは異なり、my を使って 宣言されたレキシカル変数はそれを呼び出したサブルーチンも含め、外側の 世界からは秘匿されます。 自分自身が同じサブルーチンを呼んだ場合でさえそうです--個々の呼び出しは それぞれのコピーを所有します。
このことは静的に閉じているレキシカルスコープで宣言されている my 変数が見えなくなるということは意味しません。 動的変数だけが切り取られます。 例を挙げると、以下の bumpx() はレキシカル変数 $x にアクセスします; なぜなら、my と sub の両方が同じスコープに現れているからです。
my $x = 10;
sub bumpx { $x++ } しかしながら eval() は、eval() 自身の内側にある宣言によって隠されない 名前の寿命と同じ長さを持つスコープのレキシカル変数を見ることができます。 perlref を参照してください。
my() に対するパラーメータリストには、お望みとあらば変数を初期化するための 代入を行うことができます。 (変数に対して初期値が与えられなければ、その変数は未定義値を使って 生成されます。) 一般的にこの機能はサブルーチンに対する入力パラメータに名前を付けるために 使われています。 例:
$arg = "fred"; # "global" variable
$n = cube_root(27);
print "$arg thinks the root is $n\n";
fred thinks the root is 3
sub cube_root {
my $arg = shift; # name doesn't matter
$arg **= 1/3;
return $arg;
}my は、あなたが代入を行いたいと考えている何かに対する修飾子です。 ですから、引数リストの中にある変数に対して代入を行うときには my は それらの変数がスカラとして見えているのか配列として見えているかという 状態を変えることはありません。ですから、
my ($foo) = <STDIN>; # WRONG?
my @FOO = <STDIN>;これらの両方ともが右辺をリストコンテキストにするのに対して、
my $foo = <STDIN>;これはスカラコンテキストを与えます。しかし、以下のような宣言を 行った場合、一つの変数だけが有効です:
my $foo, $bar = 1; # WRONGこれは以下のように書いたのと同じことになります
my $foo;
$bar = 1;宣言された変数は、その文が終了するまでは導入されません(不可視の 状態です)。 したがって、
my $x = $x;これは古い $x の値を使って新しい $x を初期化するのに使うことができます; そして
my $x = 123 and $x == 123これは古い $x の値がたまたま 123 でない限り、新しい $x には偽が 設定されます。
制御構文のレキシカルスコープは、その制御ブロックを区切る中かっこによって 厳格に束縛されることはありません; 制御式もまた、スコープの一部です。 ですから以下のループでは
while (my $line = <>) {
$line = lc $line;
} continue {
print $line;
}$line のスコープはその宣言から(continueブロックを含む)ループ構造の残りの 部分まで拡張されますが、それを越えることはありません。 同様に、以下の条件文では
if ((my $answer = <STDIN>) =~ /^yes$/i) {
user_agrees();
} elsif ($answer =~ /^no$/i) {
user_disagrees();
} else {
chomp $answer;
die "'$answer' is neither 'yes' nor 'no'";
}$answer のスコープはその宣言から条件文の elsif と else ブロックを含む残りの部分まで拡張されますが、 それを越えることはありません。 修飾子付きの文での変数のスコープに関する情報については "Simple Statements" in perlsyn を参照してください。
foreach はその添え字変数に対するスコープをデフォルトでは local のやり方で動的なものにしています。 しかしながら、添え字変数に my というキーワードが前置されていた場合、 または現在のスコープでその名前がすでにレキシカルである場合には、 新しいレキシカル変数が代わりに作られます。 ですから以下のループでは:
for my $i (1, 2, 3) {
some_function();
}$i のスコープはループの終端まで拡張されますが、それを越えることはないので、 $i の値は some_function() の中では参照することができなくなります。
ユーザーの一部には、レキシカルなスコープの変数の使用を奨励することを 望んでいる人もいるでしょう。 常にグローバルであるパッケージ変数に対する暗黙の使用を捕捉することを 助けるものとして、
use strict 'vars';のようにすると、この文からそれを囲むブロックの終端までの間の変数の参照は、 レキシカル変数に対する参照か、our または use vars による 事前宣言か、さもなければ完全なパッケージ名で修飾した 名前でなければなりません。 それ以外のものがあるとコンパイルエラーが発生します。 これの対象となっているブロックの内側にあるブロックで no strict 'vars' とすると(内側のブロック中では)この制限を 取り消すことができます。
my はコンパイル時の効果と実行時の効果の両方を持っています。 コンパイル時においては、コンパイラはその変数を認識します。 これの基本的な実用性は use strict 'vars' を黙らせるということですが、 perlref で詳細を記述しているクロージャの作成にも有用です。 実際の初期化は実行時まで遅らされ、そのためたとえばループを通る度に 適切に実行されるのです。
my によって宣言された変数はどのパッケージの一部でもなく、 そのためパッケージ名を使って修飾されることは決してありません。 特に、パッケージ変数(もしくはその他のグローバルな変数)を レキシカルにしようとすることは許されていません。
my $pack::var; # ERROR! Illegal syntax実際のところ、動的変数(パッケージ変数やグローバル変数として 知られているもの)は、同じ名前を持ったレキシカルが可視な状態であったとしても、 :: 記法を使った(名前の)完全な修飾を行うことによって まだアクセス可能なのです:
package main;
local $x = 10;
my $x = 20;
print "$x and $::x\n";この例は 20 と 10 を出力します。
このファイルの外側の世界からこのような識別子を隠すために、my 変数を ファイルの最も外側のスコープで宣言することができます。 これは、概念としては C でのファイルレベルの static 変数と似ています。 これをサブルーチンの内側で行うには、 クロージャ(レキシカルアクセスを伴った無名関数)を使います。 ブロックで外側のブロックから呼び出すことのできないようなプライベートな サブルーチンを作りたいなら、無名サブルーチンのリファレンスを 保持するレキシカル変数を宣言することができます:
my $secret_version = '1.001-beta';
my $secret_sub = sub { print $secret_version };
&$secret_sub();このリファレンスが決して、モジュールの内側にあるどんな関数からも 返されることがないのと同様に、外側のモジュールはサブルーチンを 見ることができません; なぜなら、その名前はどのパッケージのシンボル テーブルにも存在していないからです。 $some_pack::secret_version などの手段を使って呼び出すことは できない のだということを思い出してください; これは単なる $secret_version であって、修飾されることはなく修飾することはできません。
しかしこれはオブジェクトメソッドと共に動作させることはできません; 全ての オブジェクトメソッドは、発見可能な何らかのパッケージのシンボルテーブルに 存在している必要があります。 これを回避する方法については "Function Templates" in perlref を 参照してください。
Perl 5.10 で永続的プライベート変数を構築するには二つの方法があります。 一つ目は単に state 機能を使うことです。 あるいは、5.10 よりも古いリリースとの互換性を維持したいなら、クロージャを 使うことです。
perl 5.10.0 から、my の代わりに state キーワードを使って変数を 宣言できます。 しかし、これを働かせるには、feature プラグマを使うか、一行野郎では -E を使うことで予めこの機能を有効にしなければなりません (feature を参照してください)。 Perl 5.16 から、CORE::state 形式は feature プラグマが 不要になりました。
The state キーワードは、あるサブルーチン呼び出しから次の呼び出しまで永続する (my と同じスコープ規則に従う)レキシカル変数を作成します。 state 変数が無名サブルーチンの中にある場合は、サブルーチンのそれぞれのコピーは 独自の state 変数を持ちます。 しかし、state 変数の値は同じ無名サブルーチンの呼び出しの間では永続します。 (sub { ... } は、実行されるごとに新しいサブルーチンを作ることを 忘れないでください。)
例えば、以下のコードはプライベートなカウンタを管理し、gimme_another() 関数が 呼び出されるたびにカウンタを増加させます:
use feature 'state';
sub gimme_another { state $x; return ++$x }そしてこの例は、別々のカウンタを作るために無名サブルーチンを使います:
use feature 'state';
sub create_counter {
return sub { state $x; return ++$x }
}また、$x はレキシカルなので、その外側の Perl コードからアクセスすることは できません。
変数宣言と結び付けられたとき、(state $x = 42 のような)state 変数への 単純な代入は一度目だけ実行されます。 その後再びこの文が評価されても、代入は無視されます。 代入の左側にかっこが着いている場合のstate 宣言へ代入の 振る舞いは現在のところ未定義です。
レキシカル変数はそれを囲むブロック、eval、do FILE に属する レキシカル(もしくは静的)スコープに属します; このことは C の static と同様に 動作するということを意味しません。 通常は C の auto と同じように動作しますが、暗黙のガベージコレクションを 伴っています。
C や C++ におけるローカル変数とは異なり、Perl のレキシカル変数は 単にそのスコープから抜けたからという理由で、必ずしもリサイクルされません。 何かもっと永続的なものがそのレキシカル変数に関してまだ気付いていれば、 それは留まるでしょう。 何か他のものがレキシカル変数を参照していれば、そのレキシカル変数は 解放されません -- そしてそうあるべきです。 あなたはそれを使いおわるまではメモリを解放したいとは思わないでしょうし、 使い終わったものを保持し続けたいとも思わないでしょう。 あなたのために自動ガベージコレクションがこれを行います。
これはつまり、レキシカル変数に対するリファレンスを返したり保存したり することができるということです; 一方 C の auto 変数に対するポインタを 返すことはエラーとなります。 レキシカル変数はまた、C の関数に static な変数のシミュレートも行います。 以下の例はレキシカルスコープを持つと同時に static な寿命を持つ関数に プライベートな変数です。 C の static 変数のようなものを作りたいというのであれば、 関数全体をさらにブロックで囲んでやり、static 変数をブロックの内側で、 かつ関数の外側の場所においてやります。
{
my $secret_val = 0;
sub gimme_another {
return ++$secret_val;
}
}
# $secret_val now becomes unreachable by the outside
# world, but retains its value between calls to gimme_anotherこの関数が require や use を通じて別の独立したファイルから 取り込まれた場合、これはとても役に立つことでしょう。 もしこれがすべてメインプログラムの中にあるのであれば、 ブロック全体をメインプログラムの前に置くか、(こちらか好ましいやり方ですが) プログラムが実行されるよりも前に実行されることが保証されている BEGIN コードブロックの中に置くようにして、my を早めに実行するように 変更する必要があるでしょう:
BEGIN {
my $secret_val = 0;
sub gimme_another {
return ++$secret_val;
}
}特別なトリガーコードブロックである BEGIN, CHECK, INIT, END に ついては "BEGIN, UNITCHECK, CHECK, INIT and END" in perlmod を参照してください。
最も外側のスコープ(ファイルスコープ)で宣言されたのであれば、 レキシカル変数は C のファイルに static なものと同じように振る舞います。 同じファイルの、宣言の後にある全ての関数から参照可能でありますが、 そのファイルの外側から参照することはできません。 この戦略はモジュールの中でモジュール全体から見える プライベートな変数を作るために使われます。
警告: 一般的には、local ではなくmy を使うべきです; なぜなら、そちらの ほうが早く、安全だからです。 この例外には、グローバルな句読点変数(punctuation variable)、グローバル ファイルハンドル、フォーマット、そして Perl のシンボルテーブル自身に対する 直接の操作が含まれます。 local はほとんどの場合、変数の現在の値が呼び出されたサブルーチンに 対して可視にしなければならない場合に使われます。
概要:
# 値のローカル化
local $foo; # $foo を動的にローカルにする
local (@wid, %get); # 変数のリストをローカルにする
local $foo = "flurp"; # $foo を動的にして、初期化する
local @oof = @bar; # @oof を動的にして、初期化する
local $hash{key} = "val"; # このハッシュエントリにローカルな値を入れる
delete local $hash{key}; # 現在のブロックでこのエントリを削除
local ($cond ? $v1 : $v2); # いくつかの種類の左辺値はローカル化に
# 対応している
# シンボルのローカル化
local *FH; # $FH, @FH, %FH, &FH ... をローカル化
local *merlyn = *randal; # ここで $merlyn は実際には $randal、さらに
# @merlyn は実際には @randal、など
local *merlyn = 'randal'; # 「同様」: 'randal' を *randal にする
local *merlyn = \$randal; # 単に $merlyn の別名で @merlyn などではないlocal は、引数に取ったそのリスト中の変数を(local() を囲む)ブロック (あるいは、サブルーチン, eval、do FILE)と、そのブロック中で 呼び出された全てのもの にローカルなものにします。 local は単にグローバル変数(やパッケージ変数)に一時的な値を与えるだけです。 これはローカル変数を 作りません。 これは動的スコープとして知られています。 レキシカルスコープは my を使って行われ、これは C の 自動変数宣言のように 働きます。
いくつかの種類の左辺値もローカル化できます: ハッシュと配列の要素とスライス、 条件文(その結果が常にローカル化可能なもの)、シンボリックリファレンス。 単純変数に関しては、これは新しく、動的スコープを持つ値を作ります。
local に対して二つ以上の変数や表現を与えるのならば、それらの変数は括弧で くくっておかなければなりません。 この演算子は引数リストにある変数のカレントの値を隠れたスタックに保存し、 ブロックやサブルーチン、eval から抜けるときにその値を復帰することによって 動作しています。 これはつまり、呼び出されたサブルーチンからもローカル変数を 参照することができるけれども、グローバルなものを見ることは できないということです。 引数リストには、好みに応じてリスト中のローカル変数を初期化するための 代入を行うことができます。 (ある特定の変数に対して初期値が与えられなかった場合には、その変数は未定義値を 伴って生成されます。)
local は実行時演算子なので、ループで通る度に実行されます。 現在の Perl はメモリの使用に関して改善されていますが、 結果として、ループの外側で変数を宣言したほうがより効率が良いのです。
local は左辺値に対する単なる修飾子です。 局所化された変数に代入を行ったとき、local はそのリストがスカラとして 見えているのか配列として見えているかということを変えることはありません。 ですから、
local($foo) = <STDIN>;
local @FOO = <STDIN>;これらの両方ともが右辺をリストコンテキストにするのに対して、
local $foo = <STDIN>;これはスカラコンテキストを与えます.
特殊変数をローカル化すると、それに新しい値を入れられますが、特殊機能は なくなりません。 これは、その特殊機能に関係する全ての副作用はローカル化された値に対しても 働くということを意味します。
この機能は以下のようなコードが動作するようにします:
# Read the whole contents of FILE in $slurp
{ local $/ = undef; $slurp = <FILE>; }しかし、これはいくつかの値のローカル化を制限することに注意してください; 例えば、以下の文は、perl 5.10.0 からは、 Modification of a read-only value attempted というエラーで die します; なぜなら $1 変数はマジカルで読み込み専用だからです:
local $1 = 2;一つの例外は、デフォルトスカラ変数です: perl 5.14 から、サブルーチン内で 安全に $_ を再利用できるように、local($_) は常に 全てのマジックを取り除きます。
警告: tie された配列とハッシュのローカル化は現在のところ 記述されたとおりに動作しません。 これは Perl の将来のリリースで修正されます; 当面の間は、tie された配列やハッシュのローカル化によるどのような 振る舞いにも依存しないようなコードにしてください (個々の要素のローカル化は問題ありません)。 さらなる詳細については "Localising Tied Arrays and Hashes Is Broken" in perl58delta を 参照してください。
以下のような構造は
local *name;現在のパッケージでグロブ name のための完全に新しいシンボルテーブル エントリを作成します。 これは、このグロブスロットに入る全ての変数 ($name, @name, %name, &name, name ファイルハンドル) は動的にリセットされることを意味します。
これは特に、 最終的にこれらの変数によってもたらされるマジックは局所的には 失われることを意味します。 言い換えると、local */ としても、入力レコードセパレータの内部の 値には何の影響も与えないということです。
合成型のメンバー(たとえば配列やハッシュの要素)の局所化したときに どうなるかを説明しましょう。 この場合、その要素は 名前によって 局所化が行われます。 これはつまり、local のスコープが終わったときに、local で名前が 使われていたキーを持つハッシュの要素と local で名前が使われていた 配列要素に関して保存されていた値を復帰するということです。 local() が効果を持っているところでそういった要素が削除された場合 (例えばハッシュに対して delete() を使うとか配列に対して shift()を使う)に、local() の有効範囲を抜けたところで 削除された要素が復活し、配列の拡張と拡張した分の要素の値を undef にするということを行います。例えば以下のような場合、
%hash = ( 'This' => 'is', 'a' => 'test' );
@ary = ( 0..5 );
{
local($ary[5]) = 6;
local($hash{'a'}) = 'drill';
while (my $e = pop(@ary)) {
print "$e . . .\n";
last unless $e > 3;
}
if (@ary) {
$hash{'only a'} = 'test';
delete $hash{'a'};
}
}
print join(' ', map { "$_ $hash{$_}" } sort keys %hash),".\n";
print "The array has ",scalar(@ary)," elements: ",
join(', ', map { defined $_ ? $_ : 'undef' } @ary),"\n";Perl は以下のような出力をします。
6 . . .
4 . . .
3 . . .
This is a test only a test.
The array has 6 elements: 0, 1, 2, undef, undef, 5複合型の存在していないメンバーに対する local() の振る舞いは 将来変更される予定です。 負のインデックスを使って指定された配列要素の local() の振る舞いは 特に驚くもので、おそらく変更されます。
現在のブロックからある複合型エントリを削除してブロックの終了時に 復元するために、delete local $array[$idx] および delete local $hash{key} 構文を使えます。 これらはローカル化される前に配列/ハッシュの値を返すので、以下はそれぞれ 等価です:
do {
my $val = $array[$idx];
local $array[$idx];
delete $array[$idx];
$val
}および
do {
my $val = $hash{key};
local $hash{key};
delete $hash{key};
$val
}但し local は do ブロックのスコープです。 スライスも受け付けられます。
my %hash = (
a => [ 7, 8, 9 ],
b => 1,
)
{
my $a = delete local $hash{a};
# $a is [ 7, 8, 9 ]
# %hash is (b => 1)
{
my @nums = delete local @$a[0, 2]
# @nums is (7, 9)
# $a is [ undef, 8 ]
$a[0] = 999; # will be erased when the scope ends
}
# $a is back to [ 7, 8, 9 ]
}
# %hash is back to its original stateこの構文は Perl v5.12 から対応しています。
サブルーチンから、変更可能な値を返すことが可能です。 そうするためには、サブルーチンが左辺値を返すように宣言しなければなりません。
my $val;
sub canmod : lvalue {
$val; # or: return $val;
}
sub nomod {
$val;
}
canmod() = 5; # assigns to $val
nomod() = 5; # ERRORサブルーチンと、代入の右側のスカラ/リストコンテキストは サブルーチン呼び出しがスカラに置き換えられたかのようにして 決定されます。 例として、以下を考えると:
data(2,3) = get_data(3,4);両方のサブルーチンはスカラコンテキストで呼び出され、一方:
(data(2,3)) = get_data(3,4);及び:
(data(2),data(3)) = get_data(3,4);については全てのサブルーチンはリストコンテキストで呼び出されます。
左辺値サブルーチンは便利ですが、オブジェクトに対して使うと、カプセル化に 違反するかも知れないことを心に留めておく必要があります。 通常のミューテータは、指定された引数を守られている属性に代入する前に チェックできますが、左辺値サブルーチンはできません。 値の補完と取り出しに何らかの特別処理が必要な場合は、CPAN モジュールの Sentinel または似たようなものを使うことを考慮してください。
Perl 5.18 から、my や state を使ってプライベートなサブルーチンを 宣言できます。 state 変数の場合、state キーワードは use feature 'state' または use 5.010 またはそれ以上の下でのみ利用可能です。
Perl 5.26 より前では、レキシカルサブルーチンは実験的と見なされ、 use feature 'lexical_subs' プラグマの下でのみ利用可能でした。 また、"experimental::lexical_subs" 警告カテゴリを無効にしない限り 警告が発生していました。
これらのサブルーチンは、宣言されたブロックの内側で、宣言された後でのみ 見えます:
# Include these two lines if your code is intended to run under Perl
# versions earlier than 5.26.
no warnings "experimental::lexical_subs";
use feature 'lexical_subs';
foo(); # calls the package/global subroutine
state sub foo {
foo(); # also calls the package subroutine
}
foo(); # calls "state" sub
my $ref = \&foo; # take a reference to "state" sub
my sub bar { ... }
bar(); # calls "my" sub(直接)再帰レキシカルサブルーチンを書くことは出来ません:
# WRONG
my sub baz {
baz();
}This example fails because baz() は、現在定義しているレキシカルサブルーチンではなく、 パッケージ/グローバルサブルーチン baz を参照するので、 この例は失敗します。
解決法は、__SUB__ を使うことです:
my sub baz {
__SUB__->(); # calls itself
}レキシカルサブルーチンを先行宣言することは可能です。 sub foo {...} サブルーチン宣言文法は、先行する my sub; または state sub; 宣言を考慮します。 しかし、これを再帰サブルーチンを定義するのに使うのは良くない考えです:
my sub baz; # predeclaration
sub baz { # define the "my" sub
baz(); # WRONG: calls itself, but leaks memory
}my $f; $f = sub { $f->() } と同様、この例はメモリリークします。 baz という名前はサブルーチンへのリファレンスで、 サブルーチンは baz という名前を使います; これは互いに相手を有効にします ("Circular References" in perlref 参照)。
state sub vs my sub"state" サブルーチンと "my" サブルーチンの違いはなんでしょう? "my" サブルーチンが宣言されていると、ブロックが実行される毎に新しい サブルーチンが作成されます。 "state" サブルーチンは、一度目の内部のブロックの実行から次まで永続します。
したがって、一般的に、"state" サブルーチンの方が速いです。 しかし、クロージャを作成したいときには "my" サブルーチンが必要です:
sub whatever {
my $x = shift;
my sub inner {
... do something with $x ...
}
inner();
}この例で、whatever が呼び出されたときに新しい $x が作成され、さらに 新しい $x が見える新しい inner が作成されます。 "state" サブルーチンは最初の whatever の呼び出しからの $x だけが 見えます。
our サブルーチンour $variable と同様、our sub は同じ名前のパッケージサブルーチンへの レキシカルな別名を作成します。
これの主な二つの使用法は、内側のスコープの内側のパッケージサブルーチンを 使うために切り替えのためです:
sub foo { ... }
sub bar {
my sub foo { ... }
{
# need to use the outer foo here
our sub foo;
foo();
}
}もう一つは同じスコープのほかのパッケージから見えるサブルーチンを作ることです:
package MySneakyModule;
our sub do_something { ... }
sub do_something_with_caller {
package DB;
() = caller 1; # sets @DB::args
do_something(@args); # uses MySneakyModule::do_something
}警告: このセクションで説明されている仕組みは、古いバージョンの Perl に おいて参照渡しをシミュレートするための唯一の方法でした。 これは現在でも使うことができるのですが、新しいリファレンスの仕組みは これをより簡単に行います。後の説明を参照してください。
サブルーチンが渡された配列のローカルなコピーではなくてグローバルな ものの変更ができるように、サブルーチンに対して配列の値ではなく 配列の名前を渡したくなることもあるでしょう。 perl においては、これを *foo のようにアスタリスクを使って 行うことができます。 これは前に置かれたアスタリスクが変数やサブルーチンなどに対して使われる 前置文字全てにマッチするワイルドカードとしてみなすことが できるので、“型グロブ”としてよく知られています。
型グロブは評価されたときにその名前を持つ全てのオブジェクト(ファイルハンドル、 フォーマット、サブルーチンも含まれます)を表すスカラ値を生成します。 代入が行われたとき、* は代入したものを反映するようになります。 例:
sub doubleary {
local(*someary) = @_;
foreach $elem (@someary) {
$elem *= 2;
}
}
doubleary(*foo);
doubleary(*bar);スカラは既に参照渡しされているので、陽に $_[0] などで参照して この機構を使わなくてもスカラ引数を変更することができます。 全ての要素がスカラとして渡された配列の要素はすべて 変更することができますが、push、pop、もしくは配列のサイズを 変更するためには * 機構(もしくは同等のリファレンス機構)を 使う必要があります。 これは型グロブ(もしくはリファレンス)を渡すのを確実に高速にするでしょう。
配列の変更を望まないとしても、この機構は単一のリストの中にある複数の リストを渡すのに便利です; なぜなら、通常はリスト機構はすべての配列の値を 結合してしまうので独立した配列を取り出すことができないからです。 型グロブについては、 "Typeglobs and Filehandles" in perldata も参照してください。
my があるにも関らず、今でも local 演算子を使うべき場所が三ヶ所あります。 実際にはその三ヶ所においては、my ではなく、必ず local を 使わなければなりません。
グローバル変数(特に $_) に関して、一時的な値を与えたいとき。
@ARGV や句読点変数(punctuation variables)のようなグローバル変数では、 局所化のために local() を使わなければなりません。 以下のブロックは /etc/motd を読み込み、等価記号を使って行の塊を分割し、 その結果を @Fields に格納します。
{
local @ARGV = ("/etc/motd");
local $/ = undef;
local $_ = <>;
@Fields = split /^\s*=+\s*$/;
} 特に重要なのは、任意のルーチンの中で $_ を局所化し、それに対して 代入することです。 while 文での暗黙的な代入に注意してください。
ローカルなファイルハンドルやディレクトリハンドル、 もしくはローカル関数を作成する必要がある場合。
関数に固有のファイルハンドルが必要な関数は、完全な型グロブを使った local() を使わなければなりません。 これによって、新しいシンボルテーブルのエントリが作成されます:
sub ioqueue {
local (*READER, *WRITER); # not my!
pipe (READER, WRITER) or die "pipe: $!";
return (*READER, *WRITER);
}
($head, $tail) = ioqueue();無名シンボルテーブルを生成する方法については、Symbol モジュールを 参照してください。
型グロブに対するリファレンスの代入はエイリアスを生成するので、 以下の例では効果的にローカル関数(あるいは少なくともローカルエイリアス)を 生成するのに使うことができます。
{
local *grow = \&shrink; # only until this block exits
grow(); # really calls shrink()
move(); # if move() grow()s, it shrink()s too
}
grow(); # get the real grow() againこういったやり方で、名前によって関数を操作する方法に関しての詳細は "Function Templates" in perlref を参照してください。
配列やハッシュのある要素だけを一時的に変更したい場合。
一つの要素だけを局所化することが可能です。 通常はこれは動的に行われます。
{
local $SIG{INT} = 'IGNORE';
funct(); # uninterruptible
}
# interruptibility automatically restored hereしかし、これはレキシカル変数であっても動作します。
もし、配列やハッシュを二つ以上関数に渡したいとか関数から返したいと 考えていて、同時にそれらを完全な状態で扱いたいというのであれば、 明示的に参照渡しを使う必要があるでしょう。 これを行う前に、perlref で説明されているリファレンスを理解する 必要があります。 このセクションでは改めて説明するようなことはしません。
幾つか単純な例を挙げましょう。 まず最初に、ある関数に幾つかの配列を渡し、 全ての配列に対して pop を行って引数として受け取った配列の それぞれの最後の要素からなる新しいリストを返すということを 考えてみましょう。
@tailings = popmany ( \@a, \@b, \@c, \@d );
sub popmany {
my $aref;
my @retlist;
foreach $aref ( @_ ) {
push @retlist, pop @$aref;
}
return @retlist;
}以下の例は、引数として渡された全てのハッシュにあるキーのリストを 返す関数です:
@common = inter( \%foo, \%bar, \%joe );
sub inter {
my ($k, $href, %seen); # locals
foreach $href (@_) {
while ( $k = each %$href ) {
$seen{$k}++;
}
}
return grep { $seen{$_} == @_ } keys %seen;
}とはいうものの、これは通常のリストを返す機構を使っています。 ハッシュを渡そうとしたり、ハッシュを返そうとすると何が起きるのでしょうか? そうです、引数の一つだけを使い引数の連結が行われることを気にしなければ 通常の呼び出し規約と同じことです; ただし、少々高くつきます。
このように書くのはトラブルのもとです:
(@a, @b) = func(@c, @d);
or
(%a, %b) = func(%c, %d);これらの構文は単純にうまくいきません。 戻り値は @aや %aだけにセットされて、@b や %b はクリアされます。 それに加え、この関数は引数として二つの配列、二つのハッシュを受け取りません: 受け取るのは常に @_ に格納されている(二つの引数の内容が連結された)一つの 長いリストなのです。
これをリファレンス経由で扱うように変更できるのであれば、見た目はそれ程 良くありませんがプログラムを明確にできます。 以下の例は引数として配列のリファレンスを二つ取り、その配列の要素の数によって 順序づけられた二つの配列を返す関数です:
($aref, $bref) = func(\@c, \@d);
print "@$aref has more than @$bref\n";
sub func {
my ($cref, $dref) = @_;
if (@$cref > @$dref) {
return ($cref, $dref);
} else {
return ($dref, $cref);
}
}これは以下のように書くこともできます:
(*a, *b) = func(\@c, \@d);
print "@a has more than @b\n";
sub func {
local (*c, *d) = @_;
if (@c > @d) {
return (\@c, \@d);
} else {
return (\@d, \@c);
}
}この例では、シンボルテーブルの別名づけをするために型グロブを使っています。 しかし、これは微妙なものであり、my 変数を使った場合にはうまくいきません; なぜなら、グローバルなもの(local() で偽装したものを含む)だけが シンボルテーブルにあるからです。
ファイルハンドルを扱おうというのであれば、通常は *STDOUT のような 裸の型グロブ(bare typeglob)を使うことができますが、型グロブの リファレンスも動作します。 例えば:
splutter(\*STDOUT);
sub splutter {
my $fh = shift;
print $fh "her um well a hmmm\n";
}
$rec = get_rec(\*STDIN);
sub get_rec {
my $fh = shift;
return scalar <$fh>;
}新しいファイルハンドルを生成することを考えているのであれば、 以下のようにできます。 リファレンスではなく、生の *FH を渡すことに注意してください。
sub openit {
my $path = shift;
local *FH;
return open (FH, $path) ? *FH : undef;
}Perl はとても限られた形のコンパイル時引数チェックに対応しています。 これは PROTO セクションか プロトタイプ属性 で宣言できます。 以下のどちらかのように宣言すると:
sub mypush (\@@)
sub mypush :prototype(\@@)mypush() は push() が取るのとまったく同じ引数を取ります。
サブルーチンシグネチャ("Signatures" 参照)が有効の場合、より短い PROTO 文法は利用できません; シグネチャと衝突するからです。 この場合、プロトタイプは属性の形式でのみ宣言できます。
関数宣言はコンパイル時に可視でなければなりません。 プロトタイプの効果は、関数を & を使わない新しい形式の呼び出しで 解釈したときのみです。 言い換えれば、組み込み関数と同じように関数を呼び出せば、 それは組み込み関数と同じように振る舞う、ということです。 古い形式のサブルーチンと同じように呼び出せば、それは古い形式の サブルーチンと同じように振る舞います。 \&foo のようなサブルーチンのリファレンスや &{$subref} のような 間接的なサブルーチン呼び出し、$subref->() に関してはプロトタイプは なんの影響も及ぼさないので、この規則から外れます。
メソッド呼び出しはプロトタイプを行う/行わないによる影響を受けません; なぜなら 正確な呼び出しコードは、継承に依存しているためにコンパイル時には 不確定だからです。
組み込み関数のように動作するサブルーチンをあなたに定義させるのが この機能の基本的な目的なので、ここで対応した組み込み関数のように 解釈される幾つかの関数プロトタイプを挙げておきましょう。
宣言 呼び出し
sub mylink ($$) mylink $old, $new
sub myvec ($$$) myvec $var, $offset, 1
sub myindex ($$;$) myindex &getstring, "substr"
sub mysyswrite ($$$;$) mysyswrite $buf, 0, length($buf) - $off, $off
sub myreverse (@) myreverse $a, $b, $c
sub myjoin ($@) myjoin ":", $a, $b, $c
sub mypop (\@) mypop @array
sub mysplice (\@$$@) mysplice @array, 0, 2, @pushme
sub mykeys (\[%@]) mykeys $hashref->%*
sub myopen (*;$) myopen HANDLE, $name
sub mypipe (**) mypipe READHANDLE, WRITEHANDLE
sub mygrep (&@) mygrep { /foo/ } $a, $b, $c
sub myrand (;$) myrand 42
sub mytime () mytimeバックスラッシュが付けられたプロトタイプ文字は、実引数が その文字で始まるものでなければならないことを表します (オプションとして my, our, local が前置されます); $foo = 7 や my_function()->[0] のようにマークなしでも任意の 左辺値表現を受け付ける $ は例外です。 @_ の一部として渡された引数は、そのサブルーチン呼び出しにおいて 与えられた実引数に \ を適用したリファレンスとなります。
\[] バックスラッシュ記法を、一つまたは複数の引数型を指定するために 使えます。 例えば:
sub myref (\[$@%&*])というのは以下のように myref() を呼び出すのを許し:
myref $var
myref @array
myref %hash
myref &sub
myref *globmyref() の最初の引数は スカラ、配列、ハッシュ、コード、グロブのいずれかへの リファレンスです。
バックスラッシュが付けられていない文字は特別な意味を持っています。 バックスラッシュを付けられていない すべての @ と% は残りの引数全てを 取ってしまい、さらにリストコンテキストを強制します。 $ で表される引数はスカラコンテキストを強制されます。 第一引数として渡された場合、& は sub キーワードや連続したカンマを 要求しないような無名サブルーチンを要求します。
* は、スロットにある裸の単語、定数、スカラ式、型グロブ、 型グロブに対するリファレンスを許しています。 その値はサブルーチンにとって単純なスカラとすることも 型グロブに対するリファレンスにもなります。 そのような引数を常に型グロブリファレンスに変換したい場合は、 Symbol::qualify_to_ref() を以下のように使います:
use Symbol 'qualify_to_ref';
sub foo (*) {
my $fh = qualify_to_ref(shift, caller);
...
}+ プロトタイプは $ の特殊な代替物で、リテラルな配列やハッシュ変数が 与えられると \[@%] のように動作しますが、さもなければ引数に スカラコンテキストを強制します。 これは引数としてリテラルの配列または配列リファレンスのどちらかを 受け付けるような関数に有用です:
sub mypush (+@) {
my $aref = shift;
die "Not an array or arrayref" unless ref $aref eq 'ARRAY';
push @$aref, @_;
}関数で + プロトタイプを使ったとき、引数が受け付けられる型かを チェックしなければなりません。
セミコロン (;) は、必須の引数と省略可能な引数とを分割します。 @ や % の前ではこれは冗長です; その他のものを吸収します。
プロトタイプの最後の文字、あるいはセミコロン、@、% の直前に、$ の 代わりに _ を使えます: 引数が与えられない場合、$_ が代わりに 使われます。
上の例の最後の三つのものは、構文解析器が特別扱いするということに 注意してください。 mygrep() は本当のリスト演算子として解析され、myrand() は rand() と 同じく単項演算子の優先順位を持った真の単項演算子として、 そして mytime() は time() と同じ様な引数を取らないものとして 解析されます。つまり、
mytime +2;とすると、プロトタイプなしの場合にパースされる mytime(2) ではなく、 mytime() + 2 となります。 単項関数がリスト演算子と同じ優先順位を持つようにさせたいなら、プロトタイプの 末尾に ; を追加してください:
sub mygetprotobynumber($;);
mygetprotobynumber $a > $b; # parsed as mygetprotobynumber($a > $b)& に関して興味深いことは、初期位置を使って新しい構文を 生成できるということです:
sub try (&@) {
my($try,$catch) = @_;
eval { &$try };
if ($@) {
local $_ = $@;
&$catch;
}
}
sub catch (&) { $_[0] }
try {
die "phooey";
} catch {
/phooey/ and print "unphooey\n";
};これは “unphooey” を出力します。 (そう、@_ の可視性に関して解決していないことがあります。 現時点ではこれを無視します。 (ただし、@_ をレキシカルスコープにすれば上記のサブルーチンはクロージャーの ように振る舞うことができます... (んー、これってちょーっと Lisp っぽいかな? (気にしないでね。))))
以下の例は Perl の grep 演算子のの再実装です:
sub mygrep (&@) {
my $code = shift;
my @result;
foreach $_ (@_) {
push(@result, $_) if &$code;
}
@result;
}一部の人は、完全に英数字を使ったプロトタイプを好むかもしれません。 英数字は、将来名前付き仮引数を追加するときのために意図的に使わずに 残してあるのです。 現時点でのプロトタイプの機構の主な目的はモジュール作者がそのユーザーに 対してより良い診断メッセージを提供させるようにするためのものなのです。 この記法は Perl プログラマが非常に理解しやすく、モジュールの中身に 進入するようなことも読みづらくしたりすることもないと Larry は考えています。 回線の雑音は飲み込みやすい小さな丸薬に視覚的に押し込められるのです。
もしプロトタイプに英数字を使おうとすると、オプションの警告 "Illegal character in prototype..." が生成されます。 残念ながら、過去のバージョンの Perl では、有効なプロトタイプが前置されてさえ いれば、英数字を含むプロトタイプも認められていました。 この警告は、目障りなコードの大部分が修正されたなら、将来のバージョンの Perl で致命的エラーに格上げされるかもしれません。
新しい関数にプロトタイプを付けるのがおそらく最善であり、古い関数に対して プロトタイプを付けることはよくありません。 なぜなら、(プロトタイプを付けたことによって)リストコンテキストと スカラコンテキストを黙って変えてしまうようなことに関して 特に注意しなければならないからです。 たとえば以下の例のようなただ一つの引数を取ると決めた関数を考えてみましょう:
sub func ($) {
my $n = shift;
print "you gave me $n\n";
}そして、誰かがこの関数をリストを返すような配列や式を引数として 渡したとすると:
func(@foo);
func( $text =~ /\w+/g );自動的に scalar が引数の前に(こっそりと)付けられます; これには いささかびっくりすることになるかもしれません。 これまでそうであったような、要素を持った @foo が渡されることはありません。 その代わり、func() は 1、つまり @foo の要素の数を得るようになります。 そして m//g はスカラコンテキストで呼び出され、 単語のリストの代わりに真偽値の結果を返して pos($text) を進めます。 あいたた。
サブルーチンに PROTO と BLOCK の両方がある場合、プロトタイプは BLOCK が 完全に定義されるまで適用されません。 これは、プロトタイプを持つ再帰関数は、次のように、プロトタイプが 有効になるように事前定義する必要があります:
sub foo($$);
sub foo($$) {
foo 1, 2;
}もちろんこれは十分強力なものであり、世界をより良い場所にするという目的に 限って使用すべきものでしょう。
() というプロトタイプを持った関数はインライン展開される可能性を 持っています。 最適化と定数畳み込み後の結果が一つの定数か、何のリファレンスも持たない レキシカルスコープのスカラであったならば、その関数が & を使わずに 呼びされたときに呼び出しのその場に置かれます。 & を使って呼び出された関数は決してインライン展開されることは ありません。 (ほとんどの定数を宣言するための簡単な方法は constant を 参照してください。)
以下に挙げた関数は全てインライン展開されるでしょう:
sub pi () { 3.14159 } # 正確ではないが近い。
sub PI () { 4 * atan2 1, 1 } # 可能な限り良いもの
# そしてこれも展開されます!
sub ST_DEV () { 0 }
sub ST_INO () { 1 }
sub FLAG_FOO () { 1 << 8 }
sub FLAG_BAR () { 1 << 9 }
sub FLAG_MASK () { FLAG_FOO | FLAG_BAR }
sub OPT_BAZ () { not (0x1B58 & FLAG_MASK) }
sub N () { int(OPT_BAZ) / 3 }
sub FOO_SET () { 1 if FLAG_MASK & FLAG_FOO }
sub FOO_SET2 () { if (FLAG_MASK & FLAG_FOO) { 1 } }(最後の例は、Perl 5.20 以前では常にインライン展開されるわけではないことに 注意してください; 内部スコープを持つサブルーチンは一貫した 振る舞いをしません。) インライン化は明示的な return を使うことで撤回できます:
sub baz_val () {
if (OPT_BAZ) {
return 23;
}
else {
return 42;
}
}
sub bonk_val () { return 12345 }先に暗示したように、本体がその他にリファレンスを持たないレキシカル スコープのスカラで構成されている場合、BEGIN の時点でインラインサブルーチンを 動的に宣言することもできます。 ここでの最初の例のみがインライン化されます:
BEGIN {
my $var = 1;
no strict 'refs';
*INLINED = sub () { $var };
}
BEGIN {
my $var = 1;
my $ref = \$var;
no strict 'refs';
*NOT_INLINED = sub () { $var };
}これに関するそれほど明白でない欠陥 ([RT #79908] 参照) は、変数は直ちに インライン化され、通常のレキシカル変数のように振る舞うのを止めることです; 例えば、これは 79908 ではなく 79907 を出力します:
BEGIN {
my $x = 79907;
*RT_79908 = sub () { $x };
$x++;
}
print RT_79908(); # prints 79907Perl 5.22 から、このバグっぽい振る舞いは、後方互換性を維持するために、 検出されて廃止予定警告を出力します。 サブルーチンを (警告なしで) インライン化したい場合、その変数が宣言された 場所以外で変更されるかも知れないコンテキストで使われないことを 確認してください。
# Fine, no warning
BEGIN {
my $x = 54321;
*INLINED = sub () { $x };
}
# Warns. Future Perl versions will stop inlining it.
BEGIN {
my $x;
$x = 54321;
*ALSO_INLINED = sub () { $x };
}Perl 5.22 ではまた代替案として実験的な "const" 属性を導入しました。 (これを使う場合は "experimental::const_attr" 警告を無効化してください。) 無名サブルーチンに適用されると、サブルーチンを sub 式が評価されたときの 呼び出しに固定します。 返り値は捕捉され、定数サブルーチンに変換されます:
my $x = 54321;
*INLINED = sub : const { $x };
$x++;この例での INLINED の返り値は、その後 $x が変更されても常に 54321 です。 また、サブルーチンの内部で任意のコードを書くことができ、直ちに実行されて その返り値は同様に捕捉されます。
() プロトタイプを持ち、レキシカル変数を返すサブルーチンが本当にほしいなら、 明示的な return を追加することでインライン化しないことを簡単に強制できます:
BEGIN {
my $x = 79907;
*RT_79908 = sub () { return $x };
$x++;
}
print RT_79908(); # prints 79908サブルーチンがインライン化されていることを知る最も簡単な方法は B::Deparse によるものです。 1 を返す二つのサブルーチンの例を考えると、 () プロトタイプを持つものはインライン化を引き起こし、もう一つは 引き起こしません (明確化のために deparse の出力を切り詰めています):
$ perl -MO=Deparse -le 'sub ONE { 1 } if (ONE) { print ONE if ONE }'
sub ONE {
1;
}
if (ONE ) {
print ONE() if ONE ;
}
$ perl -MO=Deparse -le 'sub ONE () { 1 } if (ONE) { print ONE if ONE }'
sub ONE () { 1 }
do {
print 1
};インライン展開するのに適切であったサブルーチンを再定義するとデフォルトでは 警告を受けることになります。 この警告を、あるサブルーチンがインライン化可能と認識されるかどうかを 区別するために使うことができます; これはインライン化されていないサブルーチンを オーバーライドすることによる警告とは異なります:
$ perl -e 'sub one () {1} sub one () {2}'
Constant subroutine one redefined at -e line 1.
$ perl -we 'sub one {1} sub one {2}'
Subroutine one redefined at -e line 1.この警告は -w オプション(またはそれがないこと)に影響を受けるものに するには重大すぎると考えられました。 そのサブルーチンを再定義できる必要があるのならば、() プロトタイプを やめる(これは呼び出しのセマンティクスを変えてしまうので注意してください)か、 他の方法、例えば上述のように示的な return の追加によって、 インライン展開機構を働かせないようにしてサブルーチンが インライン展開されていないことを保証する必要があります:
sub not_inlined () { return 23 }多くの組み込み関数はオーバーライドすることができます; ただし、これを行うのは、 そうする理由と状況とがあるときのみに限るべきでしょう。 これが行われる典型的な例は、非 UNIX システムにおいて欠けている組み込み機能を エミュレートするためにパッケージを使おうとする場合でしょう。
オーバーライドはコンパイル時にモジュールからのみ名前を import できます-- 通常の先行宣言では十分ではありません。 しかしながら、use subs プラグマは import 構文を通して先行宣言を行い、 さらにそれらの名前が組み込みのものをオーバーライドできるようにします:
use subs 'chdir', 'chroot', 'chmod', 'chown';
chdir $somewhere;
sub chdir { ... }曖昧さなく組み込みのものを参照するために、特別なパッケージ修飾子 CORE:: を組み込みの名前に前置することができます。 たとえば CORE::open() とすると、たとえカレントパッケージが &open() といった別のサブルーチンを import していたとしても これは常に組み込み関数の open() を参照します。 これは通常の関数呼び出しのように見えますが、そうではありません: この場合の CORE:: 接頭辞は Perl の文法の一部で、CORE パッケージに何があるかに 関わらず、どのようなキーワードでも動作します。 \&CORE::open のように、これに対するリファレンスの取得は、一部の キーワードでのみ動作します。 CORE を参照してください。
ライブラリモジュールは、open だとか chdir のような組み込みの名前を デフォルトの @EXPORT リストの一部としてexport すべきではありません; なぜなら、ライブラリを使った人の名前空間を汚し、予期しない動作を 呼び起こす可能性があるからです。 @EXPORT_OK に名前を追加すれば、ユーザーがその名前を陽に指定すれば import することができ、暗黙の内に import されてしまうことはありません。 つまり、以下のようにすると
use Module 'open';open() のオーバーライドをインポートします。 しかし、以下のようにすると
use Module;デフォルトのインポートを行い、オーバーライドはしません。
組み込みのものに対するオーバーライディングのための機構は インポートを要求したパッケージに制限されています。 名前空間に関係なく組み込みの任意のものをオーバーライドしたいと 考えたときに使えることもある二番目の方法があります。 それは特殊な名前空間 CORE::GLOBAL に対して sub を インポートすることによるものです。 以下にちょっとした正規表現を使って glob 演算子を置き換える例を挙げます。
package REGlob;
require Exporter;
@ISA = 'Exporter';
@EXPORT_OK = 'glob';
sub import {
my $pkg = shift;
return unless @_;
my $sym = shift;
my $where = ($sym =~ s/^GLOBAL_// ? 'CORE::GLOBAL' : caller(0));
$pkg->export($where, $sym, @_);
}
sub glob {
my $pat = shift;
my @got;
if (opendir my $d, '.') {
@got = grep /$pat/, readdir $d;
closedir $d;
}
return @got;
}
1;そして以下は悪い使い方(かもしれない)例です:
#use REGlob 'GLOBAL_glob'; # override glob() in ALL namespaces
package Foo;
use REGlob 'glob'; # override glob() in Foo:: only
print for <^[a-z_]+\.pm\$>; # show all pragmatic modules最初のコメント部分は不自然で、危険ですらある例です。 グローバルに glob をオーバーライドすることによって、 完全に認識されていなかったりモジュール固有の名前空間との協調を 考慮せずに、glob の動作が 全ての 名前空間で強制的に新しい(そして破壊的な)ものになります。 こういったことは(それが本当にやらなければいけないこととした上で) 大いに注意したうえで行うべきものです。
前述の REGlob の例は、perl の glob 演算子をオーバーライドするのに 必要な全てのことを実装してはいません。 組み込みの glob はそれがスカラコンテキストで使われたのか リストコンテキストで使われたのかによって異なる動作をしますが、 先程の例の REGlob ではそうなっていません。 perl の組み込みのものの多くがこのようにコンテキストによって違う動作をし、 オーバーライドするものを記述する場合にはきちんとそれを サポートしていなければなりません。 glob のオーバーライディングの完全版は、 標準ライブラリにある File::DosGlob の実装で勉強してください。
組み込み関数をオーバーライドするとき、オーバーライドした関数は 組み込み関数の元の文法(もしあれば)と一貫しているべきです。 これは適切なプロトタイプを使うことで達成できます。 オーバーライドできる組み込み関数のプロトタイプを得るためには、 "CORE::builtin_name" を引き数として prototype 関数を使ってください ("prototype" in perlfunc を参照してください)。
(system や chomp のように)文法をプロトタイプで表現できない 組み込み関数に注意してください。 もしこれらをオーバーライドすると、もとの文法を完全に真似ることは できません。
組み込みの do, require, glob もオーバーライドできますが、特別な 魔法によって、これらの元の文法は保存され、オーバーライドしたもののために プロトタイプを定義する必要はありません。 (しかし、do BLOCK 文法はオーバーライドできません)。
require は特別な追加の黒魔法を持ちます: require をオーバーライドした ものを require Foo::Bar として起動すると、実際には @_ に引き数として "Foo/Bar.pm" を受け取ります。 "require" in perlfunc を参照してください。
そして、以前の例から気付いたかもしれませんが、もし glob を オーバーライドすると、グロブ演算子 <*> もオーバーライドされます。
同様に、readline 関数をオーバーライドすると 等価な I/O 演算子である <FILEHANDLE> もオーバーライドします。 また、readpipe をオーバーライドすると、演算子 `` と qx// も オーバーライドします。
最後に、いくつかの組み込み関数(exists や grep) は オーバーライドできません。
定義されていないサブルーチンを呼び出した場合、通常はそんなサブルーチンは ないといった内容のエラーが即座に発生するでしょう(メソッドとして 使われているサブルーチンも同様に、メソッドがそのクラスのパッケージの すべての基底クラス中に存在していなかったとき)。 しかし、AUTOLOAD サブルーチンがそのパッケージの中で定義されているか 元のサブルーチンで使われるパッケージの中で定義されていれば、 元のサブルーチンに対して渡されたであろう引数を伴ってその AUTOLOAD サブルーチンが呼び出されます。 元のサブルーチンの完全修飾された名前は AUTOLOAD ルーチンと同じ パッケージのグローバルな変数 $AUTOLOAD の中に現れます。 この名前は通常の引数として渡されることはありません。 なぜなら、その、あー、なんというかこれが理由です。 (例外として、存在しない import か unimport メソッドへの呼び出しは 単に無視されます。 また、AUTOLOAD サブルーチンが XSUB なら、サブルーチン名を取得するための その他の方法があります。 詳しくは "Autoloading with XSUBs" in perlguts を参照してください。)
多くの AUTOLOAD ルーチンは eval() を使った要求サブルーチンに 対する定義でロードされ、AUTOLOAD ルーチンのスタックフレームを トレースなしに消してしまうような特別な形式の goto() を使うサブルーチンを 実行します。 (実例は標準の AutoLoader モジュールのソースを参照してください。) しかし、AUTOLOAD ルーチンはそのようなルーチンの模倣をすることもできて、 かつそれを定義しません。 たとえば、定義されてない関数があったときに、それを引数として system() を起動するようにさせます。 あなたがやろうとしていることはこういうことです:
sub AUTOLOAD {
our $AUTOLOAD; # keep 'use strict' happy
my $program = $AUTOLOAD;
$program =~ s/.*:://;
system($program, @_);
}
date();
who();
ls('-l');このやり方で呼び出したい関数を先行宣言しておけば、括弧すら 必要ではなくなります。
use subs qw(date who ls);
date;
who;
ls '-l';この例のもっと完全なものが、CPAN にある Shell モジュールです; これは 未定義のサブルーチンの呼び出しを外部プログラムの呼び出しとして扱います。
この仕掛けは、モジュール作者がモジュールを自動ロード可能なファイルに 分割するのを助けるために使用可能です。 AutoLoader と AutoSplit で説明されている 標準の AutoLoader モジュールと、SelfLoader で説明されている 標準の SelfLoader モジュール、そして perlxs にある Perl プログラムに C の関数を追加することに関するドキュメントを参照してください。
サブルーチン宣言や定義には、それと結び付けられた属性のリストを 持たせることが出来ます。 このような属性が合った場合、スペースかコロンを区切りとして分割され、 use attributes があったかのように扱われます。 属性が現在対応している詳細については attributes を参照してください。 古い use attrs の制限と違って、sub : ATTRLIST の文法は 前方宣言でも動作し、サブルーチン定義だけではありません。
属性は単純な識別子名('_' 以外の句読点なし)でなければなりません。 パラメータリストを追加するときに、括弧('(',')')のネストが 正しいかどうかだけをチェックします。
(属性が不明だとしても)正常な文法の例です:
sub fnord (&\%) : switch(10,foo(7,3)) : expensive;
sub plugh () : Ugly('\(") :Bad;
sub xyzzy : _5x5 { ... }不正な文法の例です:
sub fnord : switch(10,foo(); # ()-string not balanced
sub snoid : Ugly('('); # ()-string not balanced
sub xyzzy : 5x5; # "5x5" not a valid identifier
sub plugh : Y2::north; # "Y2::north" not a simple identifier
sub snurt : foo + bar; # "+" not a colon or space属性リストはサブルーチンと結び付けられたコードに定数文字列の リストとして渡されます。 特に、上記の有効な文法の第二の例では、どのようにパースと起動が 行われるかという点においては以下のようになります:
use attributes __PACKAGE__, \&plugh, q[Ugly('\(")], 'Bad';属性リストとその操作に関するさらなる詳細については、 attributes を参照してください。
リファレンスとクロージャーについては "Function Templates" in perlref を 参照してください。 Perl から C のサブルーチンを呼び出すことに関して知りたければ、 perlxsを参照してください。 Perl のサブルーチンを C から呼び出したい場合は perlembed を参照してください。 自分の関数を別のファイルで構築することに関しては perlmod を参照してください。 どのライブラリモジュールがあなたのシステムで標準となっているかを 学ぶためには perlmodlib を参照してください。 オブジェクトメソッド呼び出しの作り方を学ぶには perlootut を 参照してください。