argra****@users*****
argra****@users*****
2009年 6月 17日 (水) 00:55:02 JST
Index: docs/perl/5.10.0/perlbot.pod
diff -u /dev/null docs/perl/5.10.0/perlbot.pod:1.1
--- /dev/null Wed Jun 17 00:55:02 2009
+++ docs/perl/5.10.0/perlbot.pod Wed Jun 17 00:55:01 2009
@@ -0,0 +1,865 @@
+
+=encoding euc-jp
+
+=head1 NAME
+
+=begin original
+
+perlbot - Bag'o Object Tricks (the BOT)
+
+=end original
+
+perlbot - Bag'o Object Tricks (the BOT)
+
+=head1 DESCRIPTION
+
+=begin original
+
+The following collection of tricks and hints is intended to whet curious
+appetites about such things as the use of instance variables and the
+mechanics of object and class relationships. The reader is encouraged to
+consult relevant textbooks for discussion of Object Oriented definitions and
+methodology. This is not intended as a tutorial for object-oriented
+programming or as a comprehensive guide to Perl's object oriented features,
+nor should it be construed as a style guide. If you're looking for tutorials,
+be sure to read L<perlboot>, L<perltoot>, and L<perltooc>.
+
+=end original
+
+ここにあるインスタンス変数の使用であるとか、オブジェクトやクラス関係の
+機構といったトリックやヒントのコレクションは、好奇心を刺激するようなものです。
+読者は、オブジェクト指向の定義や方法論についての議論については
+適切な教科書を参照することが求められます。
+つまり、これはオブジェクト指向プログラミングのチュートリアルを
+指向したものでなく、Perl のオブジェクト指向機能についての
+包括的なガイドでもなく、はたまたスタイルガイドとなるべきものでもありません。
+
+=begin original
+
+The Perl motto still holds: There's more than one way to do it.
+
+=end original
+
+Perlのモットーはまだ生きています: やり方は一通りじゃない。
+
+=head1 OO SCALING TIPS
+
+=over 5
+
+=item 1
+
+=begin original
+
+Do not attempt to verify the type of $self. That'll break if the class is
+inherited, when the type of $self is valid but its package isn't what you
+expect. See rule 5.
+
+=end original
+
+$self の型を確かめることはしないこと。
+$self の型が正当であってもそのパッケージがあなたの期待しているものと
+異なっているとき、クラスが継承されていればおかしな結果となってしまいます。
+規則 5 を参照してください。
+
+=item 2
+
+=begin original
+
+If an object-oriented (OO) or indirect-object (IO) syntax was used, then the
+object is probably the correct type and there's no need to become paranoid
+about it. Perl isn't a paranoid language anyway. If people subvert the OO
+or IO syntax then they probably know what they're doing and you should let
+them do it. See rule 1.
+
+=end original
+
+オブジェクト指向 (OO) あるいは 間接オブジェクト (IO) 構文が使われたならば、
+そのオブジェクトはおそらくは正しい型であり、
+それについて偏執的になる必要はありません。
+どうせ Perl は偏執的言語ではありません。
+OO 構文や IO 構文をくつがえす人々がいたなら、そういった人々はおそらく
+自分たちが行っていることを知っているでしょうし、
+あなたは彼らにそうさせておくべきなのです。
+規則 1 を参照してください。
+
+=item 3
+
+=begin original
+
+Use the two-argument form of bless(). Let a subclass use your constructor.
+See L<INHERITING A CONSTRUCTOR>.
+
+=end original
+
+引数 2 つの bless() を使いましょう。
+コンストラクタを使ってサブクラスにしましょう。
+L<INHERITING A CONSTRUCTOR> を参照してください。
+
+=item 4
+
+=begin original
+
+The subclass is allowed to know things about its immediate superclass, the
+superclass is allowed to know nothing about a subclass.
+
+=end original
+
+サブクラスは、すぐ上のスーパークラスが何であるかを知ることが許されています。
+スーパークラスはサブクラスについての何かを知ることを許されていません。
+
+=item 5
+
+=begin original
+
+Don't be trigger happy with inheritance. A "using", "containing", or
+"delegation" relationship (some sort of aggregation, at least) is often more
+appropriate. See L<OBJECT RELATIONSHIPS>, L<USING RELATIONSHIP WITH SDBM>,
+and L<"DELEGATION">.
+
+=end original
+
+やたらと継承を使わないようにしましょう。
+実装("using")、包含("containing")、委任("delegation")といった
+関係(少なくともある種の集合)は、たいていの場合継承よりも
+適切なものとなります。
+L<OBJECT RELATIONSHIPS>, L<USING RELATIONSHIP WITH SDBM>,
+L<"DELEGATION"> を参照してください。
+
+=item 6
+
+=begin original
+
+The object is the namespace. Make package globals accessible via the
+object. This will remove the guess work about the symbol's home package.
+See L<CLASS CONTEXT AND THE OBJECT>.
+
+=end original
+
+オブジェクトとは名前空間です。
+オブジェクトを通して、パッケージを大域的にアクセスできるようにします。
+これはシンボルのホームパッケージに関する当て推量を取り除くでしょう。
+L<CLASS CONTEXT AND THE OBJECT> を参照してください。
+
+=item 7
+
+=begin original
+
+IO syntax is certainly less noisy, but it is also prone to ambiguities that
+can cause difficult-to-find bugs. Allow people to use the sure-thing OO
+syntax, even if you don't like it.
+
+=end original
+
+IO 構文はそれほどややこしいものではありません。
+しかしその反面、見つけるのが難しいバグを引き起こすあいまいさになる
+傾向があります。
+あなたが好まないとしても、人々は OO 構文を使うことが許されているのです。
+
+=item 8
+
+=begin original
+
+Do not use function-call syntax on a method. You're going to be bitten
+someday. Someone might move that method into a superclass and your code
+will be broken. On top of that you're feeding the paranoia in rule 2.
+
+=end original
+
+メソッドを関数呼び出し形式で使わないようにしましょう。
+さもなければあなたはいつの日か痛い目にあうこととなるでしょう。
+誰かがそのようなメソッドをスーパークラスに移動させればあなたのプログラムは
+壊れてしまうのです。
+規則 2 の偏執狂になることに繋がりかねません。
+
+=item 9
+
+=begin original
+
+Don't assume you know the home package of a method. You're making it
+difficult for someone to override that method. See L<THINKING OF CODE REUSE>.
+
+=end original
+
+自分がメソッドのホームパッケージを知っていると仮定しないでください。
+それをやってしまうと、他の人がそのメソッドをオーバーライドするのが
+難しくなってしまいます。
+L<THINKING OF CODE REUSE> を参照してください。
+
+=back
+
+=head1 INSTANCE VARIABLES
+
+(インスタンス変数)
+
+=begin original
+
+An anonymous array or anonymous hash can be used to hold instance
+variables. Named parameters are also demonstrated.
+
+=end original
+
+無名配列や無名ハッシュはインスタンス変数を保持するのに使うことができます。
+名前付きのパラメータと一緒にお見せしましょう。
+
+ package Foo;
+
+ sub new {
+ my $type = shift;
+ my %params = @_;
+ my $self = {};
+ $self->{'High'} = $params{'High'};
+ $self->{'Low'} = $params{'Low'};
+ bless $self, $type;
+ }
+
+
+ package Bar;
+
+ sub new {
+ my $type = shift;
+ my %params = @_;
+ my $self = [];
+ $self->[0] = $params{'Left'};
+ $self->[1] = $params{'Right'};
+ bless $self, $type;
+ }
+
+ package main;
+
+ $a = Foo->new( 'High' => 42, 'Low' => 11 );
+ print "High=$a->{'High'}\n";
+ print "Low=$a->{'Low'}\n";
+
+ $b = Bar->new( 'Left' => 78, 'Right' => 40 );
+ print "Left=$b->[0]\n";
+ print "Right=$b->[1]\n";
+
+=head1 SCALAR INSTANCE VARIABLES
+
+(スカラインスタンス変数)
+
+=begin original
+
+An anonymous scalar can be used when only one instance variable is needed.
+
+=end original
+
+無名のスカラは、インスタンス変数が一つだけ必要とされるときのみ
+使うことができます。
+
+ package Foo;
+
+ sub new {
+ my $type = shift;
+ my $self;
+ $self = shift;
+ bless \$self, $type;
+ }
+
+ package main;
+
+ $a = Foo->new( 42 );
+ print "a=$$a\n";
+
+
+=head1 INSTANCE VARIABLE INHERITANCE
+
+(インスタンス変数の継承)
+
+=begin original
+
+This example demonstrates how one might inherit instance variables from a
+superclass for inclusion in the new class. This requires calling the
+superclass's constructor and adding one's own instance variables to the new
+object.
+
+=end original
+
+次の例は、どのようにして新しいクラスにスーパークラスからインスタンス変数を
+継承するのかということを示すものです。
+ここでは、スーパークラスのコンストラクタを呼び出すことと新しい
+オブジェクトでインスタンス変数を一つ追加するということを行っています。
+
+ package Bar;
+
+ sub new {
+ my $type = shift;
+ my $self = {};
+ $self->{'buz'} = 42;
+ bless $self, $type;
+ }
+
+ package Foo;
+ @ISA = qw( Bar );
+
+ sub new {
+ my $type = shift;
+ my $self = Bar->new;
+ $self->{'biz'} = 11;
+ bless $self, $type;
+ }
+
+ package main;
+
+ $a = Foo->new;
+ print "buz = ", $a->{'buz'}, "\n";
+ print "biz = ", $a->{'biz'}, "\n";
+
+
+
+=head1 OBJECT RELATIONSHIPS
+
+(オブジェクトの関係)
+
+=begin original
+
+The following demonstrates how one might implement "containing" and "using"
+relationships between objects.
+
+=end original
+
+以下の例では、包含("containing")や実装("using")といったオブジェクト間の
+関係をどのように実装するかということを説明しています。
+
+ package Bar;
+
+ sub new {
+ my $type = shift;
+ my $self = {};
+ $self->{'buz'} = 42;
+ bless $self, $type;
+ }
+
+ package Foo;
+
+ sub new {
+ my $type = shift;
+ my $self = {};
+ $self->{'Bar'} = Bar->new;
+ $self->{'biz'} = 11;
+ bless $self, $type;
+ }
+
+ package main;
+
+ $a = Foo->new;
+ print "buz = ", $a->{'Bar'}->{'buz'}, "\n";
+ print "biz = ", $a->{'biz'}, "\n";
+
+
+
+=head1 OVERRIDING SUPERCLASS METHODS
+
+(スーパークラスのメソッドをオーバーライドする)
+
+=begin original
+
+The following example demonstrates how to override a superclass method and
+then call the overridden method. The B<SUPER> pseudo-class allows the
+programmer to call an overridden superclass method without actually knowing
+where that method is defined.
+
+=end original
+
+以下の例ではどのようにスーパークラスのメソッドをオーバーライドするのか、
+そしてオーバーライドされたメソッドをどのように呼び出すのかを示します。
+擬似クラス B<SUPER> はプログラマがスーパークラスのメソッドを
+そのメソッドがどのクラスに属するかを知らなくても呼べるようにします。
+
+ package Buz;
+ sub goo { print "here's the goo\n" }
+
+ package Bar; @ISA = qw( Buz );
+ sub google { print "google here\n" }
+
+ package Baz;
+ sub mumble { print "mumbling\n" }
+
+ package Foo;
+ @ISA = qw( Bar Baz );
+
+ sub new {
+ my $type = shift;
+ bless [], $type;
+ }
+ sub grr { print "grumble\n" }
+ sub goo {
+ my $self = shift;
+ $self->SUPER::goo();
+ }
+ sub mumble {
+ my $self = shift;
+ $self->SUPER::mumble();
+ }
+ sub google {
+ my $self = shift;
+ $self->SUPER::google();
+ }
+
+ package main;
+
+ $foo = Foo->new;
+ $foo->mumble;
+ $foo->grr;
+ $foo->goo;
+ $foo->google;
+
+=begin original
+
+Note that C<SUPER> refers to the superclasses of the current package
+(C<Foo>), not to the superclasses of C<$self>.
+
+=end original
+
+C<SUPER> はカレントパッケージのスーパークラス(C<Foo>) を参照するのであって、
+C<$self> のスーパークラスではないことに注意してください。
+
+=head1 USING RELATIONSHIP WITH SDBM
+
+(SDBM での実装関係)
+
+=begin original
+
+This example demonstrates an interface for the SDBM class. This creates a
+"using" relationship between the SDBM class and the new class Mydbm.
+
+=end original
+
+この例は SDBM クラスに対するインターフェースを示します。
+この例では、SDBM クラスと、新しいクラス Mydbm との間の実装("using")関係を
+作り出します。
+
+ package Mydbm;
+
+ require SDBM_File;
+ require Tie::Hash;
+ @ISA = qw( Tie::Hash );
+
+ sub TIEHASH {
+ my $type = shift;
+ my $ref = SDBM_File->new(@_);
+ bless {'dbm' => $ref}, $type;
+ }
+ sub FETCH {
+ my $self = shift;
+ my $ref = $self->{'dbm'};
+ $ref->FETCH(@_);
+ }
+ sub STORE {
+ my $self = shift;
+ if (defined $_[0]){
+ my $ref = $self->{'dbm'};
+ $ref->STORE(@_);
+ } else {
+ die "Cannot STORE an undefined key in Mydbm\n";
+ }
+ }
+
+ package main;
+ use Fcntl qw( O_RDWR O_CREAT );
+
+ tie %foo, "Mydbm", "Sdbm", O_RDWR|O_CREAT, 0640;
+ $foo{'bar'} = 123;
+ print "foo-bar = $foo{'bar'}\n";
+
+ tie %bar, "Mydbm", "Sdbm2", O_RDWR|O_CREAT, 0640;
+ $bar{'Cathy'} = 456;
+ print "bar-Cathy = $bar{'Cathy'}\n";
+
+=head1 THINKING OF CODE REUSE
+
+(コードの再利用を考える)
+
+=begin original
+
+One strength of Object-Oriented languages is the ease with which old code
+can use new code. The following examples will demonstrate first how one can
+hinder code reuse and then how one can promote code reuse.
+
+=end original
+
+オブジェクト指向言語の一つの強みとは、古いコードと新しいコードを
+混ぜて使うのが簡単だと言うことです。
+以下の例では、まず最初にどのようにコードの再利用を妨害するかということを、
+続いてどのようにコードの再利用を促進するかということを示します。
+
+=begin original
+
+This first example illustrates a class which uses a fully-qualified method
+call to access the "private" method BAZ(). The second example will show
+that it is impossible to override the BAZ() method.
+
+=end original
+
+最初の例では、「プライベート」なメソッド BAZ() にアクセスするために
+完全修飾メソッド呼び出しを使っているクラスをお見せします。
+二番目の例ではオーバーライドすることのできない BAZ() メソッドを
+お見せします。
+
+ package FOO;
+
+ sub new {
+ my $type = shift;
+ bless {}, $type;
+ }
+ sub bar {
+ my $self = shift;
+ $self->FOO::private::BAZ;
+ }
+
+ package FOO::private;
+
+ sub BAZ {
+ print "in BAZ\n";
+ }
+
+ package main;
+
+ $a = FOO->new;
+ $a->bar;
+
+=begin original
+
+Now we try to override the BAZ() method. We would like FOO::bar() to call
+GOOP::BAZ(), but this cannot happen because FOO::bar() explicitly calls
+FOO::private::BAZ().
+
+=end original
+
+今度はメソッド BAZ() をオーバーライドしてみましょう。
+FOO::bar() で GOOP::BAZ() を呼び出したいのですが、これは FOO::bar() が陽に
+FOO::private::BAZ() を呼び出しているのでできません。
+
+ package FOO;
+
+ sub new {
+ my $type = shift;
+ bless {}, $type;
+ }
+ sub bar {
+ my $self = shift;
+ $self->FOO::private::BAZ;
+ }
+
+ package FOO::private;
+
+ sub BAZ {
+ print "in BAZ\n";
+ }
+
+ package GOOP;
+ @ISA = qw( FOO );
+ sub new {
+ my $type = shift;
+ bless {}, $type;
+ }
+
+ sub BAZ {
+ print "in GOOP::BAZ\n";
+ }
+
+ package main;
+
+ $a = GOOP->new;
+ $a->bar;
+
+=begin original
+
+To create reusable code we must modify class FOO, flattening class
+FOO::private. The next example shows a reusable class FOO which allows the
+method GOOP::BAZ() to be used in place of FOO::BAZ().
+
+=end original
+
+再利用可能なコードを作成するには、クラス FOO を修正して、
+クラス FOO:private を平らにしなければなりません。
+次の例では、FOO::BAZ() を使っている場所でメソッド GOOP:BAZ を
+置くことのできるクラス FOO をお見せします。
+
+ package FOO;
+
+ sub new {
+ my $type = shift;
+ bless {}, $type;
+ }
+ sub bar {
+ my $self = shift;
+ $self->BAZ;
+ }
+
+ sub BAZ {
+ print "in BAZ\n";
+ }
+
+ package GOOP;
+ @ISA = qw( FOO );
+
+ sub new {
+ my $type = shift;
+ bless {}, $type;
+ }
+ sub BAZ {
+ print "in GOOP::BAZ\n";
+ }
+
+ package main;
+
+ $a = GOOP->new;
+ $a->bar;
+
+=head1 CLASS CONTEXT AND THE OBJECT
+
+(クラスのコンテキストとオブジェクト)
+
+=begin original
+
+Use the object to solve package and class context problems. Everything a
+method needs should be available via the object or should be passed as a
+parameter to the method.
+
+=end original
+
+パッケージとクラスコンテキストの問題を解決するためにオブジェクトを
+使いましょう。
+メソッドが必要とするすべてはオブジェクトを通して使用可能であるべきであり、
+メソッドに対するパラメータとして渡されるべきなのです。
+
+=begin original
+
+A class will sometimes have static or global data to be used by the
+methods. A subclass may want to override that data and replace it with new
+data. When this happens the superclass may not know how to find the new
+copy of the data.
+
+=end original
+
+あるクラスが、ときとしてメソッドから使うためにスタティックなデータや
+グローバルなデータを持つことがあるでしょう。
+サブクラスでそのようなデータをオーバーライドして、それを新しいデータに
+置き換えたいことがあるかもしれません。
+このような事態になったとき、スーパークラスは新しいデータのコピーを
+どうやって見つけるのかを知ることができません。
+
+=begin original
+
+This problem can be solved by using the object to define the context of the
+method. Let the method look in the object for a reference to the data. The
+alternative is to force the method to go hunting for the data ("Is it in my
+class, or in a subclass? Which subclass?"), and this can be inconvenient
+and will lead to hackery. It is better just to let the object tell the
+method where that data is located.
+
+=end original
+
+この問題は、メソッドのコンテキストを定義するためのオブジェクトを
+使うことによって解決できます。
+オブジェクト中にあるメソッドにデータのリファレンスを見せましょう。
+もう一つの手段はメソッドにデータを探しまわさせる
+(「自分のクラスにあるの? それともサブクラス? どのサブクラス?」)ことですが、
+これは不便ですし、ハッカー的すぎます。
+オブジェクトに、データがどこに位置するかを知らせるメソッドを持つように
+させるのが良いのです。
+
+ package Bar;
+
+ %fizzle = ( 'Password' => 'XYZZY' );
+
+ sub new {
+ my $type = shift;
+ my $self = {};
+ $self->{'fizzle'} = \%fizzle;
+ bless $self, $type;
+ }
+
+ sub enter {
+ my $self = shift;
+
+=begin original
+
+ # Don't try to guess if we should use %Bar::fizzle
+ # or %Foo::fizzle. The object already knows which
+ # we should use, so just ask it.
+ #
+ my $fizzle = $self->{'fizzle'};
+
+=end original
+
+ # %Bar::fizzle と %Foo::fizzle のいずれを使うべき
+ # なのかを推測しようとしないこと。オブジェクトは既
+ # に答を知っています。だから、それを訊ねるだけです。
+ #
+ my $fizzle = $self->{'fizzle'};
+
+ print "The word is ", $fizzle->{'Password'}, "\n";
+ }
+
+ package Foo;
+ @ISA = qw( Bar );
+
+ %fizzle = ( 'Password' => 'Rumple' );
+
+ sub new {
+ my $type = shift;
+ my $self = Bar->new;
+ $self->{'fizzle'} = \%fizzle;
+ bless $self, $type;
+ }
+
+ package main;
+
+ $a = Bar->new;
+ $b = Foo->new;
+ $a->enter;
+ $b->enter;
+
+=head1 INHERITING A CONSTRUCTOR
+
+(コンストラクタの継承)
+
+=begin original
+
+An inheritable constructor should use the second form of bless() which allows
+blessing directly into a specified class. Notice in this example that the
+object will be a BAR not a FOO, even though the constructor is in class FOO.
+
+=end original
+
+継承可能なコンストラクタは、特定のクラスに直接 bless することのできる
+bless() の第二形式を使うべきです。
+以下の例において、クラス FOO のコンストラクタを通じて構成された
+オブジェクトであってもそれは FOO ではなく、BAR として存在するように
+なることに注意してください。
+
+ package FOO;
+
+ sub new {
+ my $type = shift;
+ my $self = {};
+ bless $self, $type;
+ }
+
+ sub baz {
+ print "in FOO::baz()\n";
+ }
+
+ package BAR;
+ @ISA = qw(FOO);
+
+ sub baz {
+ print "in BAR::baz()\n";
+ }
+
+ package main;
+
+ $a = BAR->new;
+ $a->baz;
+
+=head1 DELEGATION
+
+(委任)
+
+=begin original
+
+Some classes, such as SDBM_File, cannot be effectively subclassed because
+they create foreign objects. Such a class can be extended with some sort of
+aggregation technique such as the "using" relationship mentioned earlier or
+by delegation.
+
+=end original
+
+SDBM_File のようなクラスは外部オブジェクトを生成するので、効率良く
+サブクラス化することができません。
+そのようなクラスは実装("using")関係のような先に言及したものや、
+委任のような集成テクニックを用いることで拡張することができます。
+
+=begin original
+
+The following example demonstrates delegation using an AUTOLOAD() function to
+perform message-forwarding. This will allow the Mydbm object to behave
+exactly like an SDBM_File object. The Mydbm class could now extend the
+behavior by adding custom FETCH() and STORE() methods, if this is desired.
+
+=end original
+
+以下の例では、メッセージフォワーディングを実現するために
+AUTOLOAD 関数を使っている委任をお見せします。
+これは、Mydbm オブジェクトが SDBM_File オブジェクトと全く同じように
+振る舞うようにさせるものです。
+カスタマイズした FETCH() メソッドや STORE() メソッドを追加することによって、
+今や Mydbm クラスを拡張することもできるのです。
+
+ package Mydbm;
+
+ require SDBM_File;
+ require Tie::Hash;
+ @ISA = qw(Tie::Hash);
+
+ sub TIEHASH {
+ my $type = shift;
+ my $ref = SDBM_File->new(@_);
+ bless {'delegate' => $ref};
+ }
+
+ sub AUTOLOAD {
+ my $self = shift;
+
+=begin original
+
+ # The Perl interpreter places the name of the
+ # message in a variable called $AUTOLOAD.
+
+=end original
+
+ # Perl インタプリタはメッセージの名前を
+ # $AUTOLOAD と呼ばれる変数に置いています
+
+=begin original
+
+ # DESTROY messages should never be propagated.
+ return if $AUTOLOAD =~ /::DESTROY$/;
+
+=end original
+
+ # DESTROY メッセージは伝播させるべきでない
+ return if $AUTOLOAD =~ /::DESTROY$/;
+
+=begin original
+
+ # Remove the package name.
+ $AUTOLOAD =~ s/^Mydbm:://;
+
+=end original
+
+ # パッケージ名を取り除く
+ $AUTOLOAD =~ s/^Mydbm:://;
+
+=begin original
+
+ # Pass the message to the delegate.
+ $self->{'delegate'}->$AUTOLOAD(@_);
+ }
+
+=end original
+
+ # delegate にメッセージを渡す
+ $self->{'delegate'}->$AUTOLOAD(@_);
+ }
+
+ package main;
+ use Fcntl qw( O_RDWR O_CREAT );
+
+ tie %foo, "Mydbm", "adbm", O_RDWR|O_CREAT, 0640;
+ $foo{'bar'} = 123;
+ print "foo-bar = $foo{'bar'}\n";
+
+=head1 SEE ALSO
+
+L<perlboot>, L<perltoot>, L<perltooc>.
+
+=begin meta
+
+Created: KIMURA Koichi
+Updated: Kentaro Shirakata <argra****@ub32*****> (5.8.8-)
+
+=end meta
+