/
perlref.pod
1553 lines (1102 loc) · 48.8 KB
/
perlref.pod
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
=encoding euc-jp
=head1 NAME
X<reference> X<pointer> X<data structure> X<structure> X<struct>
=begin original
perlref - Perl references and nested data structures
=end original
perlref - Perlのリファレンスとネストしたデータ構造
=head1 NOTE
(注意)
=begin original
This is complete documentation about all aspects of references.
For a shorter, tutorial introduction to just the essential features,
see L<perlreftut>.
=end original
本ドキュメントはリファレンスに関するものです。
チュートリアルに関しては L<perlreftut> を参照してください。
=head1 DESCRIPTION
=begin original
Before release 5 of Perl it was difficult to represent complex data
structures, because all references had to be symbolic--and even then
it was difficult to refer to a variable instead of a symbol table entry.
Perl now not only makes it easier to use symbolic references to variables,
but also lets you have "hard" references to any piece of data or code.
Any scalar may hold a hard reference. Because arrays and hashes contain
scalars, you can now easily build arrays of arrays, arrays of hashes,
hashes of arrays, arrays of hashes of functions, and so on.
=end original
リリース 5 以前の Perl ではすべてのリファレンスはシンボリックでなければ
ならなかったために、複雑なデータ構造を表現することが困難でした。
そしてシンボルテーブルのエントリーではなく変数を参照したいと望んだときも
困難であったのです。
Perl はシンボリックリファレンスを変数として使うことを簡単にしただけでなく、
任意のデータについて「ハード」リファレンスを持つことを可能としたのです。
任意のスカラはハードリファレンスを保持することができます。
配列とハッシュはスカラから構成されているので、あなたはいまや配列の配列、
ハッシュの配列、配列のハッシュ、関数のハッシュの配列等々を簡単に
組み立てることができるのです。
=begin original
Hard references are smart--they keep track of reference counts for you,
automatically freeing the thing referred to when its reference count goes
to zero. (Reference counts for values in self-referential or
cyclic data structures may not go to zero without a little help; see
L<perlobj/"Two-Phased Garbage Collection"> for a detailed explanation.)
If that thing happens to be an object, the object is destructed. See
L<perlobj> for more about objects. (In a sense, everything in Perl is an
object, but we usually reserve the word for references to objects that
have been officially "blessed" into a class package.)
=end original
ハードリファレンスは賢く実際に参照されている数を管理していて、その数が
0 になれば自動的に解放を行ないます。
(自己参照や循環データ(cyclic data)にある値に対する参照カウントは、
ちょっとした手助けなしにはゼロにはなりません。
詳しくは L<perlobj/"Two-Phased Garbage Collection"> を参照してください。)
そのものがオブジェクトであるときには、デストラクタが動作します。
オブジェクトについてより詳しくは、L<perlobj> を参照してください。
(ある意味では、Perl のすべてがオブジェクトですが、通常、
クラスパッケージ内で公に "bless" されているものへのリファレンスに対して、
この用語を用います。)
=begin original
Symbolic references are names of variables or other objects, just as a
symbolic link in a Unix filesystem contains merely the name of a file.
The C<*glob> notation is something of a symbolic reference. (Symbolic
references are sometimes called "soft references", but please don't call
them that; references are confusing enough without useless synonyms.)
X<reference, symbolic> X<reference, soft>
X<symbolic reference> X<soft reference>
=end original
UNIX ファイルシステム上でのシンボリックリンクが単にファイルの名前を
持っているだけであるのと同様に、シンボリックリファレンスは変数の
名前を保持します。
C<*glob> の記法は、シンボリックリファレンスの一種です
(シンボリックリファレンスは時折“ソフトリファレンス”と
呼ばれますが、そういう呼びかたをしないでください。
リファレンスは同義語を使わないでいてさえ混乱を招くのですから)。
X<reference, symbolic> X<reference, soft>
X<symbolic reference> X<soft reference>
=begin original
In contrast, hard references are more like hard links in a Unix file
system: They are used to access an underlying object without concern for
what its (other) name is. When the word "reference" is used without an
adjective, as in the following paragraph, it is usually talking about a
hard reference.
X<reference, hard> X<hard reference>
=end original
対照的に、 ハードリファレンスはUNIXのファイルシステム上のハードリンクに
似ています。
ハードリンクはそれがなんの名前であるのかを気にせずに
基礎をなすオブジェクトにアクセスするために使われます。
以下の節にあるように“リファレンス”と言う言葉を形容なしに使った
場合、通常はハードリファレンスのことを指します。
X<reference, hard> X<hard reference>
=begin original
References are easy to use in Perl. There is just one overriding
principle: Perl does no implicit referencing or dereferencing. When a
scalar is holding a reference, it always behaves as a simple scalar. It
doesn't magically start being an array or hash or subroutine; you have to
tell it explicitly to do so, by dereferencing it.
=end original
Perlでリファレンスを使うのは非常に簡単です。
原則のオーバーライドが一つあるだけです。
Perl はリファレンス(referencing)やデリファレンス(defreferencing)を
暗黙に行うことはありません。
スカラがリファレンスを保持しているとき、それは常に単純なスカラとして
振る舞います。
勝手に配列や、ハッシュ、サブルーチンとして振る舞うようなことはありません。
デリファレンスをすることによって、自分で明示的に Perl に
教える必要があります。
=head2 Making References
X<reference, creation> X<referencing>
(リファレンスを作る)
=begin original
References can be created in several ways.
=end original
リファレンスは幾つかのやり方で構築することができます。
=over 4
=item 1.
X<\> X<backslash>
=begin original
By using the backslash operator on a variable, subroutine, or value.
(This works much like the & (address-of) operator in C.)
This typically creates I<another> reference to a variable, because
there's already a reference to the variable in the symbol table. But
the symbol table reference might go away, and you'll still have the
reference that the backslash returned. Here are some examples:
=end original
変数、サブルーチン、値にバックスラッシュ演算子を使うことによる
(これは C での & (アドレス) 演算子に似た働きをします)。
既にシンボルテーブルには変数へのリファレンスが存在していますから、
この方法は I<別の> リファレンスを作るものです。
しかし、シンボルテーブルのリファレンスがなくなったとしても、
バックスラッシュが返したリファレンスが存在することになります。
例をいくつかあげます:
$scalarref = \$foo;
$arrayref = \@ARGV;
$hashref = \%ENV;
$coderef = \&handler;
$globref = \*foo;
=begin original
It isn't possible to create a true reference to an IO handle (filehandle
or dirhandle) using the backslash operator. The most you can get is a
reference to a typeglob, which is actually a complete symbol table entry.
But see the explanation of the C<*foo{THING}> syntax below. However,
you can still use type globs and globrefs as though they were IO handles.
=end original
バックスラッシュ演算子を使って IO ハンドル(ファイルハンドルまたは
ディレクトリハンドル)へのリファレンスを生成することはできません。
もっとも良く扱うリファレンスは型グロブに対するリファレンス(実際には
シンボルテーブルのエントリである)でしょう。
後述する *foo{THING} 構文の説明を参照してください。
しかしながら、IO ハンドルであったものとして型グロブや型グロブの
リファレンス(grobref)を使うこともできます。
=item 2.
X<array, anonymous> X<[> X<[]> X<square bracket>
X<bracket, square> X<arrayref> X<array reference> X<reference, array>
=begin original
A reference to an anonymous array can be created using square
brackets:
=end original
名前の無い配列へのリファレンスは、大かっこを使って作ることができます:
$arrayref = [1, 2, ['a', 'b', 'c']];
=begin original
Here we've created a reference to an anonymous array of three elements
whose final element is itself a reference to another anonymous array of three
elements. (The multidimensional syntax described later can be used to
access this. For example, after the above, C<< $arrayref->[2][1] >> would have
the value "b".)
=end original
ここでは、『「名前の無い 3 個の要素を持つ配列」を最後の要素として持つ
3 個要素の名前の無い配列』へのリファレンスを作っています。
(あとで述べる多次元構文を使って、これをアクセスすることができます。
たとえば、上記のようにした後では、
C<< $arrayref->[2][1] >> が "b" となります。)
=begin original
Taking a reference to an enumerated list is not the same
as using square brackets--instead it's the same as creating
a list of references!
=end original
列挙リストに対するリファレンスを取るということは、大かっこを使うことと
同じではありません。
これはリファレンスのリストを生成することと同じなのです!
@list = (\$a, \@b, \%c);
@list = \($a, @b, %c); # same thing!
=begin original
As a special case, C<\(@foo)> returns a list of references to the contents
of C<@foo>, not a reference to C<@foo> itself. Likewise for C<%foo>,
except that the key references are to copies (since the keys are just
strings rather than full-fledged scalars).
=end original
特殊な場合として、C<\(@foo)> は C<@foo> 自身へのリファレンスではなく、
C<@foo> の内容のそれぞれへのリファレンスのリストを返します。
C<%foo> も同様ですが、キーのコピーに対するリファレンスである点が
異なります(これはキーが完全なスカラではなく単なる文字列であるためです)。
=item 3.
X<hash, anonymous> X<{> X<{}> X<curly bracket>
X<bracket, curly> X<brace> X<hashref> X<hash reference> X<reference, hash>
=begin original
A reference to an anonymous hash can be created using curly
brackets:
=end original
名前の無いハッシュへのリファレンスは、中かっこを使って作ることができます:
$hashref = {
'Adam' => 'Eve',
'Clyde' => 'Bonnie',
};
=begin original
Anonymous hash and array composers like these can be intermixed freely to
produce as complicated a structure as you want. The multidimensional
syntax described below works for these too. The values above are
literals, but variables and expressions would work just as well, because
assignment operators in Perl (even within local() or my()) are executable
statements, not compile-time declarations.
=end original
無名ハッシュと配列のコンストラクタは、複雑な構造を作るために自由に
組み合わせることができます。
後述する多次元構文は、そのようなものに対しても使うことができます。
上記の値はリテラルですが、変数や式であってもかまいません。
Perl での代入演算は、(たとえ、local() や my() の中でも) コンパイル時の
宣言文ではなく、実行文だからです。
=begin original
Because curly brackets (braces) are used for several other things
including BLOCKs, you may occasionally have to disambiguate braces at the
beginning of a statement by putting a C<+> or a C<return> in front so
that Perl realizes the opening brace isn't starting a BLOCK. The economy and
mnemonic value of using curlies is deemed worth this occasional extra
hassle.
=end original
中かっこは、BLOCK を始めとして他のことにも使われますから、
開きの中かっこが BLOCK の開始でないことを Perl に教える
ために文の最初の中かっこの前に C<+> や C<return> をつけて、
曖昧さをなくすようにする必要がある場合があります。
このちょっとした余分な作業は、中かっこの使用に関連して
実際に使ってみる価値や覚えておくだけの価値があるでしょう。
=begin original
For example, if you wanted a function to make a new hash and return a
reference to it, you have these options:
=end original
たとえば、新しいハッシュを作って、それへのリファレンスを返す関数が欲しければ、
以下のような選択肢があります:
sub hashem { { @_ } } # silently wrong
sub hashem { +{ @_ } } # ok
sub hashem { return { @_ } } # ok
=begin original
On the other hand, if you want the other meaning, you can do this:
=end original
その一方で、以下のようにすることもできます:
sub showem { { @_ } } # ambiguous (currently ok, but may change)
sub showem { {; @_ } } # ok
sub showem { { return @_ } } # ok
=begin original
The leading C<+{> and C<{;> always serve to disambiguate
the expression to mean either the HASH reference, or the BLOCK.
=end original
先頭にある C<+{> や C<{;> が、その式が実際には
ハッシュのリファレンスなのかブロックなのかの
曖昧さを除去するためにあります。
=item 4.
X<subroutine, anonymous> X<subroutine, reference> X<reference, subroutine>
X<scope, lexical> X<closure> X<lexical> X<lexical scope>
=begin original
A reference to an anonymous subroutine can be created by using
C<sub> without a subname:
=end original
無名サブルーチンのへのリファレンスは、サブルーチン名の無い C<sub> を使って
作ることができます:
$coderef = sub { print "Boink!\n" };
=begin original
Note the semicolon. Except for the code
inside not being immediately executed, a C<sub {}> is not so much a
declaration as it is an operator, like C<do{}> or C<eval{}>. (However, no
matter how many times you execute that particular line (unless you're in an
C<eval("...")>), $coderef will still have a reference to the I<same>
anonymous subroutine.)
=end original
セミコロンに注意してください。
内部のコードが即座に実行されるのではないということを除けば、C<sub{}> は、
宣言というよりもむしろ、C<do{}> や C<eval{}> のような演算子です(しかし、
C<eval("...")> の中でなければ、何回その行を実行しようとも
$coderef は、I<同一の> 無名サブルーチンをリファレンスすることになります)。
=begin original
Anonymous subroutines act as closures with respect to my() variables,
that is, variables lexically visible within the current scope. Closure
is a notion out of the Lisp world that says if you define an anonymous
function in a particular lexical context, it pretends to run in that
context even when it's called outside the context.
=end original
無名サブルーチンは my() 変数に関連するクロージャのように振る舞います。
つまり、変数はカレントのスコープの中においてレキシカルに見えます。
クロージャは、無名関数をある特定のレキシカルコンテキストで
定義した場合にたとえそのコンテキストの外側で呼び出されたとしても
定義されたときのコンテキストで実行されることを要求するという
Lisp の世界の概念です。
=begin original
In human terms, it's a funny way of passing arguments to a subroutine when
you define it as well as when you call it. It's useful for setting up
little bits of code to run later, such as callbacks. You can even
do object-oriented stuff with it, though Perl already provides a different
mechanism to do that--see L<perlobj>.
=end original
わかりやすく言えば、あなたがサブルーチンを呼び出すときと同じように、
サブルーチンを定義するときに引数を渡すという奇妙なやり方ということです。
あなたはこれでオブジェクト指向的性質を実現することも
できます。
が、Perl はすでにこれとは異なる仕組みを提供しています --
L<perlobj> を参照してください。
=begin original
You might also think of closure as a way to write a subroutine
template without using eval(). Here's a small example of how
closures work:
=end original
クロージャは 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");
=begin original
This prints
=end original
出力はこうなります。
Howdy, world!
Greetings, earthlings!
=begin original
Note particularly that $x continues to refer to the value passed
into newprint() I<despite> "my $x" having gone out of scope by the
time the anonymous subroutine runs. That's what a closure is all
about.
=end original
ここで特に、無名サブルーチンの実行時には“my $x”がスコープの外にあるにも
B<かかわらず>、$x が newprint() に渡された値を参照しつづけていることに
注意してください。
これがクロージャがクロージャたる由縁です。
=begin original
This applies only to lexical variables, by the way. Dynamic variables
continue to work as they have always worked. Closure is not something
that most Perl programmers need trouble themselves about to begin with.
=end original
これはレキシカル変数にのみ適用されます。
動的変数はこれまでと同じように動作します。
クロージャは、大部分の Perl プログラマーがそれを使いはじめるために
トラブルをしょいこんでしまうような代物ではありません。
=item 5.
X<constructor> X<new>
=begin original
References are often returned by special subroutines called constructors. Perl
objects are just references to a special type of object that happens to know
which package it's associated with. Constructors are just special subroutines
that know how to create that association. They do so by starting with an
ordinary reference, and it remains an ordinary reference even while it's also
being an object. Constructors are often named C<new()>. You I<can> call them
indirectly:
=end original
リファレンスはコンストラクタと呼ばれる特別なサブルーチンが返すようにして
いることが多くなっています。
Perlのオブジェクトは、自分がどのパッケージと関係を持っているかを
知っているものへのリファレンスでしかありません。
コンストラクタは、その関係付けをどのように行なうかを知っているという意味で、
特別なサブルーチンにすぎません。
単なるリファレンスとしてスタートし、オブジェクトといわれている間でも
通常のリファレンスであることに変わりはありません。
コンストラクタは、慣習的に C<new()> と名前を付けられます。
間接的に呼び出すことも I<可能です>:
$objref = new Doggie( Tail => 'short', Ears => 'long' );
=begin original
But that can produce ambiguous syntax in certain cases, so it's often
better to use the direct method invocation approach:
=end original
しかし、これは場合によってはあいまいな文法となる場合があるので、
たいていは直接メソッド起動手法を使う方がよいです:
$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)
=item 6.
X<autovivification>
=begin original
References of the appropriate type can spring into existence if you
dereference them in a context that assumes they exist. Because we haven't
talked about dereferencing yet, we can't show you any examples yet.
=end original
適切な型のリファレンスは、そういったリファレンスが存在するかのような文脈で
デリファレンスを行うと、実際に存在するようになります。
デリファレンスについてはまだ話していないので、まだ例を示すことができません。
=item 7.
X<*foo{THING}> X<*>
=begin original
A reference can be created by using a special syntax, lovingly known as
the *foo{THING} syntax. *foo{THING} returns a reference to the THING
slot in *foo (which is the symbol table entry which holds everything
known as foo).
=end original
リファレンスは、*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};
=begin original
All of these are self-explanatory except for C<*foo{IO}>. It returns
the IO handle, used for file handles (L<perlfunc/open>), sockets
(L<perlfunc/socket> and L<perlfunc/socketpair>), and directory
handles (L<perlfunc/opendir>). For compatibility with previous
versions of Perl, C<*foo{FILEHANDLE}> is a synonym for C<*foo{IO}>, though it
is deprecated as of 5.8.0. If deprecation warnings are in effect, it will warn
of its use.
=end original
これら全ては、C<*foo{IO}> を除いて自己説明的です。
ファイルハンドル(L<perlfunc/open>)、ソケット(L<perlfunc/socket> と
L<perlfunc/socketpair>)、ディレクトリハンドル(L<perlfunc/opendir>)
として使われる IO ハンドルを返します。
過去のバージョンの Perl に対する互換性のために、
C<*foo{FILEHANDLE}> は C<*foo{IO}> の同義語ですが、5.8.0 からは
非推奨です。
非推奨警告が有効になっていれば、使用すると警告が出ます。
=begin original
C<*foo{THING}> returns undef if that particular THING hasn't been used yet,
except in the case of scalars. C<*foo{SCALAR}> returns a reference to an
anonymous scalar if $foo hasn't been used yet. This might change in a
future release.
=end original
C<*foo{THING}> は、スカラの場合を除いた特定の THING がまだ
使われていない場合には undef を返します。
C<*foo{SCALAR}> は、$foo がまだ使われていなかった場合には
無名スカラへのリファレンスを返します。
これは将来のリリースでは変わる可能性があります。
=begin original
C<*foo{IO}> is an alternative to the C<*HANDLE> mechanism given in
L<perldata/"Typeglobs and Filehandles"> for passing filehandles
into or out of subroutines, or storing into larger data structures.
Its disadvantage is that it won't create a new filehandle for you.
Its advantage is that you have less risk of clobbering more than
you want to with a typeglob assignment. (It still conflates file
and directory handles, though.) However, if you assign the incoming
value to a scalar instead of a typeglob as we do in the examples
below, there's no risk of that happening.
=end original
C<*foo{IO}> は、L<perldata/"Typeglobs and Filehandles"> にある
ファイルハンドルをサブルーチンに渡したり、あるいは逆に
サブルーチンから返すために、あるいは大きなデータ構造を格納する
ために用いられる C<*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>;
}
=back
=head2 Using References
X<reference, use> X<dereferencing> X<dereference>
(リファレンスを使う)
=begin original
That's it for creating references. By now you're probably dying to
know how to use references to get back to your long-lost data. There
are several basic methods.
=end original
リファレンスの作り方はこれだけです。
ここまでくると、どこか参照のかなたへ行ってしまったデータを取り戻すために、
どうやってリファレンスを使うかを知りたいことでしょう。
基本的な方法がいくつかあります。
=over 4
=item 1.
=begin original
Anywhere you'd put an identifier (or chain of identifiers) as part
of a variable or subroutine name, you can replace the identifier with
a simple scalar variable containing a reference of the correct type:
=end original
変数名やサブルーチン名の一部として識別子を置くところでは、適切な
型のリファレンスを持った単純スカラ変数でその識別子を
置き換えることができます:
$bar = $$scalarref;
push(@$arrayref, $filename);
$$arrayref[0] = "January";
$$hashref{"KEY"} = "VALUE";
&$coderef(1,2,3);
print $globref "output\n";
=begin original
It's important to understand that we are specifically I<not> dereferencing
C<$arrayref[0]> or C<$hashref{"KEY"}> there. The dereference of the
scalar variable happens I<before> it does any key lookups. Anything more
complicated than a simple scalar variable must use methods 2 or 3 below.
However, a "simple scalar" includes an identifier that itself uses method
1 recursively. Therefore, the following prints "howdy".
=end original
$arrayref[0] や $hashref{"KEY"} という形でしているの I<ではない> ことが
大切です。
スカラ変数のデリファレンスは、いかなる key の検索よりも I<前に> 行なわれます。
単純スカラ変数より込み入ったものはすべて、
以下の 2 番か 3 番の方法が採られます。
しかしながら、「単純スカラ」には、この 1 番目の方法を再帰的に使っている
識別子も含まれます。
したがって、以下はは、"howdy" と出力します。
$refrefref = \\\"howdy";
print $$$$refrefref;
=item 2.
=begin original
Anywhere you'd put an identifier (or chain of identifiers) as part of a
variable or subroutine name, you can replace the identifier with a
BLOCK returning a reference of the correct type. In other words, the
previous examples could be written like this:
=end original
変数名やサブルーチン名の一部として識別子を置くところでは、適切な型の
リファレンスを返す 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
=begin original
Admittedly, it's a little silly to use the curlies in this case, but
the BLOCK can contain any arbitrary expression, in particular,
subscripted expressions:
=end original
確かにこの場合には中かっこを付けるのはばかげたことかもしれませんが、
BLOCK には任意の式、特に添字を付けた式を入れることができます:
&{ $dispatch{$index} }(1,2,3); # call correct routine
=begin original
Because of being able to omit the curlies for the simple case of C<$$x>,
people often make the mistake of viewing the dereferencing symbols as
proper operators, and wonder about their precedence. If they were,
though, you could use parentheses instead of braces. That's not the case.
Consider the difference below; case 0 is a short-hand version of case 1,
I<not> case 2:
=end original
単純な <$$x> の場合には中かっこが省略できるので、シンボルの
デリファレンスを適当な演算子のように受け取って、その優先順位はどのくらいかと
悩む人があります。
しかし、もし演算子であれば、中かっこの代わりに、
普通の括弧が使えることでしょう。
そうではありません。
以下の違いを考えてみてください。
CASE 0 は、CASE 1 を短くしたものであり、CASE 2 を
短くしたものでは B<ありません>:
$$hashref{"KEY"} = "VALUE"; # CASE 0
${$hashref}{"KEY"} = "VALUE"; # CASE 1
${$hashref{"KEY"}} = "VALUE"; # CASE 2
${$hashref->{"KEY"}} = "VALUE"; # CASE 3
=begin original
Case 2 is also deceptive in that you're accessing a variable
called %hashref, not dereferencing through $hashref to the hash
it's presumably referencing. That would be case 3.
=end original
CASE 2 もまた間違えやすいもので、%hashref という変数をアクセスするものです。
$hashref を仲介して、それが指すことになっているハッシュを
デリファレンスしているものではありません。
それは、CASE 3 です。
=item 3.
=begin original
Subroutine calls and lookups of individual array elements arise often
enough that it gets cumbersome to use method 2. As a form of
syntactic sugar, the examples for method 2 may be written:
=end original
配列の個々の要素を使う場合が増えると、2 番の方法を使うのが
煩わしくなってきます。
構文上の打開策として上記の 2 行は、以下のように書けます:
$arrayref->[0] = "January"; # Array element
$hashref->{"KEY"} = "VALUE"; # Hash element
$coderef->(1,2,3); # Subroutine call
=begin original
The left side of the arrow can be any expression returning a reference,
including a previous dereference. Note that C<$array[$x]> is I<not> the
same thing as C<< $array->[$x] >> here:
=end original
矢印の左側には先行するデリファレンスを含めて、リファレンスを返す任意の式が
書けます(C<$array[$x]> は、C<< $array->[$x] >> と同じでは I<ありません>)。
$array[$x]->{"foo"}->[0] = "January";
=begin original
This is one of the cases we mentioned earlier in which references could
spring into existence when in an lvalue context. Before this
statement, C<$array[$x]> may have been undefined. If so, it's
automatically defined with a hash reference so that we can look up
C<{"foo"}> in it. Likewise C<< $array[$x]->{"foo"} >> will automatically get
defined with an array reference so that we can look up C<[0]> in it.
This process is called I<autovivification>.
=end original
これが、先の左辺値コンテキストで用いるとリファレンスが
存在するようになるというケースの一つです。
この文以前には、C<$array[$x]> は未定義かもしれません。
その場合自動的にハッシュリファレンスと定義されて、C<{"foo"}> が
検索できるようになります。
同じように C<< $array[$x]->{"foo"} >> が配列リファレンスで定義されるので、
C<[0]> をそこで探すことができます。
このプロセスは I<自動有効化> (autovivification) と呼ばれます。
=begin original
One more thing here. The arrow is optional I<between> brackets
subscripts, so you can shrink the above down to
=end original
もう一つ。
矢印は、括弧付きの添字の I<間> では、省略することができるので、
上の例は、以下のように書けます:
$array[$x]{"foo"}[0] = "January";
=begin original
Which, in the degenerate case of using only ordinary arrays, gives you
multidimensional arrays just like C's:
=end original
通常の配列だけを使うように限定すれば、ちょうど C の多次元配列のように
使うことができます:
$score[$x][$y][$z] += 42;
=begin original
Well, okay, not entirely like C's arrays, actually. C doesn't know how
to grow its arrays on demand. Perl does.
=end original
ああ、そうだ、実際には全く C の配列と同じという訳ではありません。
C では、必要に応じて配列を大きくするなどということはできません。
Perl では、それができます。
=item 4.
=begin original
If a reference happens to be a reference to an object, then there are
probably methods to access the things referred to, and you should probably
stick to those methods unless you're in the class package that defines the
object's methods. In other words, be nice, and don't violate the object's
encapsulation without a very good reason. Perl does not enforce
encapsulation. We are not totalitarians here. We do expect some basic
civility though.
=end original
リファレンスが、オブジェクトに対するものである場合には、参照されるものを
アクセスするためのメソッドがあるはずで、オブジェクトのメソッドを
定義するクラスパッケージ内でなければ、そのメソッドを使うように
した方が良いでしょう。
言い換えると、良識をもって、特別正当な理由がない限り、
オブジェクトのカプセル化を反古にしてはいけないということです。
Perl は、カプセル化を強要したりはしません。
私達は、全体主義者ではありません。
ただ、なにがしかの基本的な節度を期待しています。
=back
=begin original
Using a string or number as a reference produces a symbolic reference,
as explained above. Using a reference as a number produces an
integer representing its storage location in memory. The only
useful thing to be done with this is to compare two references
numerically to see whether they refer to the same location.
X<reference, numeric context>
=end original
文字列や数値をリファレンスとして使うと、上述したようにシンボリック
リファレンスを生成します。
リファレンスを数値として使うと、メモリ内のストレージの位置の
整数表現を生成します。
これを利用して便利な唯一の状況は、二つのリファレンスを数値として
比較することで、同じ場所を参照しているかどうかを調べる場合です。
X<reference, numeric context>
if ($ref1 == $ref2) { # cheap numeric compare of references
print "refs 1 and 2 refer to the same thing\n";
}
=begin original
Using a reference as a string produces both its referent's type,
including any package blessing as described in L<perlobj>, as well
as the numeric address expressed in hex. The ref() operator returns
just the type of thing the reference is pointing to, without the
address. See L<perlfunc/ref> for details and examples of its use.
X<reference, string context>
=end original
リファレンスを文字列として使うと、参照しているものの型
(L<perlobj> で記述しているように、bless しているパッケージを含みます)と、
16 進数で表現された数値アドレスの両方を生成します。
ref() 演算子は、アドレス抜きで、リファレンスが示しているものの型だけを
返します。
この使い方の詳細と例については L<perlfunc/ref> を参照してください。
X<reference, string context>
=begin original
The bless() operator may be used to associate the object a reference
points to with a package functioning as an object class. See L<perlobj>.
=end original
bless() 演算子は、オブジェクトをオブジェクトクラスとして機能する
パッケージと結び付けるために使うことができます。
L<perlobj> を参照してください。
=begin original
A typeglob may be dereferenced the same way a reference can, because
the dereference syntax always indicates the type of reference desired.
So C<${*foo}> and C<${\$foo}> both indicate the same scalar variable.
=end original
デリファレンスの構文では常に目的とするリファレンスの型を
示すことができるので、型グロブをリファレンスと同じように
デリファレンスすることができます。
つまり、C<${*foo}> と C<${\$foo}> は、どちらも同じスカラ変数を
示すことになります。
=begin original
Here's a trick for interpolating a subroutine call into a string:
=end original
次の例に示すのは、文字列にサブルーチン呼び出しを埋め込む仕掛けです:
print "My sub returned @{[mysub(1,2,3)]} that time.\n";
=begin original
The way it works is that when the C<@{...}> is seen in the double-quoted
string, it's evaluated as a block. The block creates a reference to an
anonymous array containing the results of the call to C<mysub(1,2,3)>. So
the whole block returns a reference to an array, which is then
dereferenced by C<@{...}> and stuck into the double-quoted string. This
chicanery is also useful for arbitrary expressions:
=end original
ダブルクォートで囲まれた文字列中に C<@{...}> が見つかると、その
文字列はブロックとして評価されます。
ブロックでは、C<mysub(1,2,3)> の呼び出しを実行し、その結果に対する
無名配列へのリファレンスが作られます。
つまり、ブロック全体では、配列へのリファレンスを返すこととなり、
C<@{...}> でデリファレンスされた後、ダブルクォートで囲まれた文字列の中に、
埋め込まれることになります。
このごまかしは任意の式にも有用です:
print "That yields @{[$n + 5]} widgets\n";