File: perlref.html

package info (click to toggle)
perl-doc-html 5.26.0-4
  • links: PTS, VCS
  • area: main
  • in suites: sid
  • size: 39,400 kB
  • sloc: xml: 36; makefile: 7
file content (1045 lines) | stat: -rw-r--r-- 89,909 bytes parent folder | download
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
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
  <title>perlref - perldoc.perl.org</title>
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
  <meta http-equiv="Content-Language" content="en-gb">
  <link rel="search" type="application/opensearchdescription+xml" title="Search perldoc.perl.org" href="/static/search.xml"/>
  <link href="static/css-20100830.css" rel="stylesheet" rev="stylesheet" type="text/css" media="screen">
  <link href="static/exploreperl.css" rel="stylesheet" rev="stylesheet" type="text/css">
</head>

<body onLoad="perldoc.startup();" onPageShow="if (event.persisted) perldoc.startup();">
    <div id="page">
      
      <div id="header">
	<div id="homepage_link">
	  <a href="index.html"></a>
	</div>
	<div id="strapline">
	  Perl Programming Documentation
	</div>
	<div id="download_link" class="download">
	  <a href="http://www.perl.org/get.html">Download Perl</a>
	</div>
	<div id="explore_link" class="download">
	  <a id="explore_anchor" href="#">Explore</a>
	</div>
      </div>
      
      <div id="body">
        <div id="left_column">
          <div class="side_group">
            
	    <div class="side_panel doc_panel">
              <p>Manual</p>
              <ul>
                <li><a href="index-overview.html">Overview</a>
                <li><a href="index-tutorials.html">Tutorials</a>
                <li><a href="index-faq.html">FAQs</a>
                <li><a href="index-history.html">History / Changes</a>
                <li><a href="index-licence.html">License</a>
              </ul>
            </div>
            <div class="side_panel doc_panel">
              <p>Reference</p>
              <ul>
                <li><a href="index-language.html">Language</a>
                <li><a href="index-functions.html">Functions</a>
                <li><a href="perlop.html">Operators</a>
                <li><a href="perlvar.html">Special Variables</a>
                <li><a href="index-pragmas.html">Pragmas</a>
                <li><a href="index-utilities.html">Utilities</a>
                <li><a href="index-internals.html">Internals</a>
                <li><a href="index-platforms.html">Platform Specific</a>
              </ul>
            </div>
            <div class="side_panel doc_panel">
              <p>Modules</p>
              <ul>
		<li>
		
                
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		
                  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		
                  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		    
		  
		
                  
		
                  
		
                  
		    
		  
		
                  
		
                  
		
		
                    <a href="index-modules-A.html">A</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-B.html">B</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-C.html">C</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-D.html">D</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-E.html">E</a>
                    
                      
                        <li>
                      
                    
                
                    <a href="index-modules-F.html">F</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-G.html">G</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-H.html">H</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-I.html">I</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-L.html">L</a>
                    
                      
                        <li>
                      
                    
                
                    <a href="index-modules-M.html">M</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-N.html">N</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-O.html">O</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-P.html">P</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-S.html">S</a>
                    
                      
                        <li>
                      
                    
                
                    <a href="index-modules-T.html">T</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-U.html">U</a>
                    
                      
                        &bull;
                      
                    
                
                    <a href="index-modules-X.html">X</a>
                    
                
              </ul>
            </div>
            
	      <div class="side_panel doc_panel">
		<p>Tools</p>
		<ul>
		  <li><a href="preferences.html">Preferences</a>
		</ul>
	      </div>
            
          </div>
        </div>
        <div id="centre_column">
          <div id="content_header">
            <div id="title_bar">
              <div id="page_name">
                <h1>perlref</h1>
              </div>
              <div id="perl_version">
                Perl 5 version 26.0 documentation
              </div>
              <div class="page_links" id="page_links_top">
                <a href="#" onClick="toolbar.goToTop();return false;">Go to top</a>
		
              </div>
	      <div class="page_links" id="page_links_bottom">
		
                  <a href="#" id="page_index_toggle">Show page index</a> &bull;
		
                <a href="#" id="recent_pages_toggle">Show recent pages</a>		
	      </div>
	      <div id="search_form">
		<form action="search.html" method="GET" id="search">
		  <input type="text" name="q" id="search_box" alt="Search">
		</form>
	      </div>
            </div>
            <div id="breadcrumbs">
                
    <a href="index.html">Home</a> &gt;
    
      
        <a href="index-language.html">Language reference</a> &gt;
      
    
    perlref
  

            </div>
          </div>
          <div id="content_body">
	    <!--[if lt IE 7]>
 <div class="noscript">
   <p>
     <strong>It looks like you're using Internet Explorer 6. This is a very old
     browser which does not offer full support for modern websites.</strong>
   </p>
   <p>
     Unfortunately this means that this website will not work on
     your computer.
   </p>
   <p>
     Don't miss out though! To view the site (and get a better experience from
     many other websites), simply upgrade to
     <a href="http://www.microsoft.com/windows/Internet-explorer/default.aspx">Internet
Explorer 8</a>
     or download an alternative browser such as
     <a href="http://www.mozilla.com/en-US/firefox/firefox.html">Firefox</a>,
     <a href="http://www.apple.com/safari/download/">Safari</a>, or
     <a href="http://www.google.co.uk/chrome">Google Chrome</a>.
   </p>
   <p>
     All of these browsers are free. If you're using a PC at work, you may
     need to contact your IT administrator.
   </p>
 </div>
<![endif]-->
	    <noscript>
	      <div class="noscript">
	      <p>
                <strong>Please note: Many features of this site require JavaScript. You appear to have JavaScript disabled,
	        or are running a non-JavaScript capable web browser.</strong>
	      </p>
	      <p>
		To get the best experience, please enable JavaScript or download a modern web browser such as <a href="http://www.microsoft.com/windows/Internet-explorer/default.aspx">Internet Explorer 8</a>, <a href="http://www.mozilla.com/en-US/firefox/firefox.html">Firefox</a>, <a href="http://www.apple.com/safari/download/">Safari</a>, or <a href="http://www.google.co.uk/chrome">Google Chrome</a>.
              </p>
	      </div>
	    </noscript>

	    <div id="recent_pages" class="hud_container">
	      <div id="recent_pages_header" class="hud_header">
		<div id="recent_pages_close" class="hud_close"><a href="#" onClick="recentPages.hide();return false;"></a></div>
		<div id="recent_pages_title" class="hud_title"><span class="hud_span_top">Recently read</span></div>
		<div id="recent_pages_topright" class="hud_topright"></div>
	      </div>
	      <div id="recent_pages_content" class="hud_content">
	      </div>
	      <div id="recent_pages_footer" class="hud_footer">
		<div id="recent_pages_bottomleft" class="hud_bottomleft"></div>
		<div id="recent_pages_bottom" class="hud_bottom"><span class="hud_span_bottom"></span></div>
		<div id="recent_pages_resize" class="hud_resize"></div>
	      </div>
	    </div>
  
	    <div id="from_search"></div>
            <h1>perlref</h1>


  <!--    -->
<ul><li><a href="#NAME">NAME
    </a><li><a href="#NOTE">NOTE</a><li><a href="#DESCRIPTION">DESCRIPTION</a><ul><li><a href="#Making-References">Making References
 </a><li><a href="#Using-References">Using References
  </a><li><a href="#Circular-References">Circular References
 </a><li><a href="#Symbolic-references">Symbolic references
 
 </a><li><a href="#Not-so-symbolic-references">Not-so-symbolic references</a><li><a href="#Pseudo-hashes%3a-Using-an-array-as-a-hash">Pseudo-hashes: Using an array as a hash
  </a><li><a href="#Function-Templates">Function Templates
   
   </a></ul><li><a href="#WARNING%3a-Don't-use-references-as-hash-keys">WARNING: Don't use references as hash keys
 </a><ul><li><a href="#Postfix-Dereference-Syntax">Postfix Dereference Syntax</a><li><a href="#Postfix-Reference-Slicing">Postfix Reference Slicing</a><li><a href="#Assigning-to-References">Assigning to References</a></ul><li><a href="#Declaring-a-Reference-to-a-Variable">Declaring a Reference to a Variable</a><li><a href="#SEE-ALSO">SEE ALSO</a></ul><a name="NAME"></a><h1>NAME
    </h1>
<p>perlref - Perl references and nested data structures</p>
<a name="NOTE"></a><h1>NOTE</h1>
<p>This is complete documentation about all aspects of references.
For a shorter, tutorial introduction to just the essential features,
see <a href="perlreftut.html">perlreftut</a>.</p>
<a name="DESCRIPTION"></a><h1>DESCRIPTION</h1>
<p>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.</p>
<p>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
<a href="#Circular-References">Circular References</a> for a detailed explanation.)
If that thing happens to be an object, the object is destructed.  See
<a href="perlobj.html">perlobj</a> 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.)</p>
<p>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 <code class="inline"><span class="i">*glob</span></code>
 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.)
 
 </p>
<p>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.
 </p>
<p>References are easy to use in Perl.  There is just one overriding
principle: in general, 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.</p>
<a name="Making-References"></a><h2>Making References
 </h2>
<p>References can be created in several ways.</p>
<dl>
<dt>1.
 </dt><dd>
<p>By using the backslash operator on a variable, subroutine, or value.
(This works much like the &amp; (address-of) operator in C.)
This typically creates <i>another</i> 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:</p>
<pre class="verbatim"><ol><li>    <span class="i">$scalarref</span> = \<span class="i">$foo</span><span class="sc">;</span></li><li>    <span class="i">$arrayref</span>  = \<span class="i">@ARGV</span><span class="sc">;</span></li><li>    <span class="i">$hashref</span>   = \<span class="i">%ENV</span><span class="sc">;</span></li><li>    <span class="i">$coderef</span>   = \<span class="i">&amp;handler</span><span class="sc">;</span></li><li>    <span class="i">$globref</span>   = \<span class="i">*foo</span><span class="sc">;</span></li></ol></pre><p>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 <code class="inline"><span class="i">*foo</span>{<span class="w">THING</span>}</code>
 syntax below.  However,
you can still use type globs and globrefs as though they were IO handles.</p>
</dd>
<dt>2.
   
   </dt><dd>
<p>A reference to an anonymous array can be created using square
brackets:</p>
<pre class="verbatim"><ol><li>    <span class="i">$arrayref</span> = <span class="s">[</span><span class="n">1</span><span class="cm">,</span> <span class="n">2</span><span class="cm">,</span> <span class="s">[</span><span class="q">&#39;a&#39;</span><span class="cm">,</span> <span class="q">&#39;b&#39;</span><span class="cm">,</span> <span class="q">&#39;c&#39;</span><span class="s">]</span><span class="s">]</span><span class="sc">;</span></li></ol></pre><p>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, <code class="inline"><span class="i">$arrayref</span>-&gt;[<span class="n">2</span>][<span class="n">1</span>]</code>
 would have
the value "b".)</p>
<p>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!</p>
<pre class="verbatim"><ol><li>    <span class="i">@list</span> = <span class="s">(</span>\<span class="i">$a</span><span class="cm">,</span> \<span class="i">@b</span><span class="cm">,</span> \<span class="i">%c</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">@list</span> = \<span class="s">(</span><span class="i">$a</span><span class="cm">,</span> <span class="i">@b</span><span class="cm">,</span> <span class="i">%c</span><span class="s">)</span><span class="sc">;</span>      <span class="c"># same thing!</span></li></ol></pre><p>As a special case, <code class="inline">\<span class="s">(</span><span class="i">@foo</span><span class="s">)</span></code>
 returns a list of references to the contents
of <code class="inline"><span class="i">@foo</span></code>
, not a reference to <code class="inline"><span class="i">@foo</span></code>
 itself.  Likewise for <code class="inline"><span class="i">%foo</span></code>
,
except that the key references are to copies (since the keys are just
strings rather than full-fledged scalars).</p>
</dd>
<dt>3.
   
    </dt><dd>
<p>A reference to an anonymous hash can be created using curly
brackets:</p>
<pre class="verbatim"><ol><li>    <span class="i">$hashref</span> = <span class="s">{</span></li><li>        <span class="q">&#39;Adam&#39;</span>  <span class="cm">=&gt;</span> <span class="q">&#39;Eve&#39;</span><span class="cm">,</span></li><li>        <span class="q">&#39;Clyde&#39;</span> <span class="cm">=&gt;</span> <span class="q">&#39;Bonnie&#39;</span><span class="cm">,</span></li><li>    <span class="s">}</span><span class="sc">;</span></li></ol></pre><p>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.</p>
<p>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 <code class="inline">+</code>
 or a <code class="inline"><a class="l_k" href="functions/return.html">return</a></code> 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.</p>
<p>For example, if you wanted a function to make a new hash and return a
reference to it, you have these options:</p>
<pre class="verbatim"><ol><li>    sub hashem {        { @_ } }   # silently wrong</li><li>    sub hashem {       +{ @_ } }   # ok</li><li>    sub hashem { return { @_ } }   # ok</li></ol></pre><p>On the other hand, if you want the other meaning, you can do this:</p>
<pre class="verbatim"><ol><li><a name="showem"></a>    sub <span class="m">showem</span> <span class="s">{</span>        <span class="s">{</span> <span class="i">@_</span> <span class="s">}</span> <span class="s">}</span>   <span class="c"># ambiguous (currently ok,</span></li><li>                                   <span class="c"># but may change)</span></li><li><a name="showem-1"></a>    sub <span class="m">showem</span> <span class="s">{</span>       <span class="s">{</span><span class="sc">;</span> <span class="i">@_</span> <span class="s">}</span> <span class="s">}</span>   <span class="c"># ok</span></li><li><a name="showem-2"></a>    sub <span class="m">showem</span> <span class="s">{</span> <span class="s">{</span> <a class="l_k" href="functions/return.html">return</a> <span class="i">@_</span> <span class="s">}</span> <span class="s">}</span>   <span class="c"># ok</span></li></ol></pre><p>The leading <code class="inline">+{</code> and <code class="inline">{;</code> always serve to disambiguate
the expression to mean either the HASH reference, or the BLOCK.</p>
</dd>
<dt>4.
  
   </dt><dd>
<p>A reference to an anonymous subroutine can be created by using
<code class="inline"><a class="l_k" href="functions/sub.html">sub</a></code> without a subname:</p>
<pre class="verbatim"><ol><li>    <span class="i">$coderef</span> = <a class="l_k" href="functions/sub.html">sub</a> <span class="s">{</span> <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;Boink!\n&quot;</span> <span class="s">}</span><span class="sc">;</span></li></ol></pre><p>Note the semicolon.  Except for the code
inside not being immediately executed, a <code class="inline"><a class="l_k" href="functions/sub.html">sub</a> <span class="s">{</span><span class="s">}</span></code>
 is not so much a
declaration as it is an operator, like <code class="inline"><a class="l_k" href="functions/do.html">do{}</a></code> or <code class="inline"><a class="l_k" href="functions/eval.html">eval{}</a></code>.  (However, no
matter how many times you execute that particular line (unless you're in an
<code class="inline"><a class="l_k" href="functions/eval.html">eval("...")</a></code>), $coderef will still have a reference to the <i>same</i>
anonymous subroutine.)</p>
<p>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.</p>
<p>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 <a href="perlobj.html">perlobj</a>.</p>
<p>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:</p>
<pre class="verbatim"><ol><li><a name="newprint"></a>    sub <span class="m">newprint</span> <span class="s">{</span></li><li>        <a class="l_k" href="functions/my.html">my</a> <span class="i">$x</span> = <a class="l_k" href="functions/shift.html">shift</a><span class="sc">;</span></li><li>        <a class="l_k" href="functions/return.html">return</a> <a class="l_k" href="functions/sub.html">sub</a> <span class="s">{</span> <a class="l_k" href="functions/my.html">my</a> <span class="i">$y</span> = <a class="l_k" href="functions/shift.html">shift</a><span class="sc">;</span> <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;$x, $y!\n&quot;</span><span class="sc">;</span> <span class="s">}</span><span class="sc">;</span></li><li>    <span class="s">}</span></li><li>    <span class="i">$h</span> = <span class="i">newprint</span><span class="s">(</span><span class="q">&quot;Howdy&quot;</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">$g</span> = <span class="i">newprint</span><span class="s">(</span><span class="q">&quot;Greetings&quot;</span><span class="s">)</span><span class="sc">;</span></li><li></li><li>    <span class="c"># Time passes...</span></li><li></li><li>    <span class="i">&amp;$h</span><span class="s">(</span><span class="q">&quot;world&quot;</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">&amp;$g</span><span class="s">(</span><span class="q">&quot;earthlings&quot;</span><span class="s">)</span><span class="sc">;</span></li></ol></pre><p>This prints</p>
<pre class="verbatim"><ol><li>    <span class="w">Howdy</span><span class="cm">,</span> <span class="w">world</span>!</li><li>    <span class="w">Greetings</span><span class="cm">,</span> <span class="w">earthlings</span>!</li></ol></pre><p>Note particularly that $x continues to refer to the value passed
into newprint() <i>despite</i> "my $x" having gone out of scope by the
time the anonymous subroutine runs.  That's what a closure is all
about.</p>
<p>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.</p>
</dd>
<dt>5.
 </dt><dd>
<p>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 <code class="inline"><span class="i">new</span><span class="s">(</span><span class="s">)</span></code>
.  You <i>can</i> call them
indirectly:</p>
<pre class="verbatim"><ol><li>    <span class="i">$objref</span> = <span class="w">new</span> <span class="i">Doggie</span><span class="s">(</span> <span class="w">Tail</span> <span class="cm">=&gt;</span> <span class="q">'short'</span><span class="cm">,</span> <span class="w">Ears</span> <span class="cm">=&gt;</span> <span class="q">'long'</span> <span class="s">)</span><span class="sc">;</span></li></ol></pre><p>But that can produce ambiguous syntax in certain cases, so it's often
better to use the direct method invocation approach:</p>
<pre class="verbatim"><ol><li>    <span class="i">$objref</span>   = <span class="w">Doggie</span><span class="w">-&gt;new</span><span class="s">(</span><span class="w">Tail</span> <span class="cm">=&gt;</span> <span class="q">&#39;short&#39;</span><span class="cm">,</span> <span class="w">Ears</span> <span class="cm">=&gt;</span> <span class="q">&#39;long&#39;</span><span class="s">)</span><span class="sc">;</span></li><li></li><li>    <a class="l_k" href="functions/use.html">use</a> <span class="w">Term::Cap</span><span class="sc">;</span></li><li>    <span class="i">$terminal</span> = <span class="w">Term::Cap</span><span class="w">-&gt;Tgetent</span><span class="s">(</span> <span class="s">{</span> <span class="w">OSPEED</span> <span class="cm">=&gt;</span> <span class="n">9600</span> <span class="s">}</span><span class="s">)</span><span class="sc">;</span></li><li></li><li>    <a class="l_k" href="functions/use.html">use</a> <span class="w">Tk</span><span class="sc">;</span></li><li>    <span class="i">$main</span>    = <span class="w">MainWindow</span><span class="w">-&gt;new</span><span class="s">(</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">$menubar</span> = <span class="i">$main</span><span class="i">-&gt;Frame</span><span class="s">(</span>-<span class="w">relief</span>              <span class="cm">=&gt;</span> <span class="q">&quot;raised&quot;</span><span class="cm">,</span></li><li>                            -<span class="w">borderwidth</span>         <span class="cm">=&gt;</span> <span class="n">2</span><span class="s">)</span></li></ol></pre></dd>
<dt>6.
</dt><dd>
<p>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.</p>
</dd>
<dt>7.
 </dt><dd>
<p>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).</p>
<pre class="verbatim"><ol><li>    <span class="i">$scalarref</span> = <span class="i">*foo</span>{<span class="w">SCALAR</span>}<span class="sc">;</span></li><li>    <span class="i">$arrayref</span>  = <span class="i">*ARGV</span>{<span class="w">ARRAY</span>}<span class="sc">;</span></li><li>    <span class="i">$hashref</span>   = <span class="i">*ENV</span>{<span class="w">HASH</span>}<span class="sc">;</span></li><li>    <span class="i">$coderef</span>   = <span class="i">*handler</span>{<span class="w">CODE</span>}<span class="sc">;</span></li><li>    <span class="i">$ioref</span>     = <span class="i">*STDIN</span>{<span class="w">IO</span>}<span class="sc">;</span></li><li>    <span class="i">$globref</span>   = <span class="i">*foo</span>{<span class="w">GLOB</span>}<span class="sc">;</span></li><li>    <span class="i">$formatref</span> = <span class="i">*foo</span>{<span class="w">FORMAT</span>}<span class="sc">;</span></li><li>    <span class="i">$globname</span>  = <span class="i">*foo</span>{<span class="w">NAME</span>}<span class="sc">;</span>    <span class="c"># &quot;foo&quot;</span></li><li>    <span class="i">$pkgname</span>   = <span class="i">*foo</span>{<span class="w">PACKAGE</span>}<span class="sc">;</span> <span class="c"># &quot;main&quot;</span></li></ol></pre><p>Most of these are self-explanatory, but <code class="inline"><span class="i">*foo</span>{<span class="w">IO</span>}</code>

deserves special attention.  It returns
the IO handle, used for file handles (<a href="functions/open.html">open</a>), sockets
(<a href="functions/socket.html">socket</a> and <a href="functions/socketpair.html">socketpair</a>), and directory
handles (<a href="functions/opendir.html">opendir</a>).  For compatibility with previous
versions of Perl, <code class="inline"><span class="i">*foo</span>{<span class="w">FILEHANDLE</span>}</code>
 is a synonym for <code class="inline"><span class="i">*foo</span>{<span class="w">IO</span>}</code>
, though it
is discouraged, to encourage a consistent use of one name: IO.  On perls
between v5.8 and v5.22, it will issue a deprecation warning, but this
deprecation has since been rescinded.</p>
<p><code class="inline"><span class="i">*foo</span>{<span class="w">THING</span>}</code>
 returns undef if that particular THING hasn't been used yet,
except in the case of scalars.  <code class="inline"><span class="i">*foo</span>{<span class="w">SCALAR</span>}</code>
 returns a reference to an
anonymous scalar if $foo hasn't been used yet.  This might change in a
future release.</p>
<p><code class="inline"><span class="i">*foo</span>{<span class="w">NAME</span>}</code>
 and <code class="inline"><span class="i">*foo</span>{<span class="w">PACKAGE</span>}</code>
 are the exception, in that they return
strings, rather than references.  These return the package and name of the
typeglob itself, rather than one that has been assigned to it.  So, after
<code class="inline"><span class="i">*foo</span>=<span class="i">*Foo::bar</span></code>
, <code class="inline"><span class="i">*foo</span></code>
 will become "*Foo::bar" when used as a string,
but <code class="inline"><span class="i">*foo</span>{<span class="w">PACKAGE</span>}</code>
 and <code class="inline"><span class="i">*foo</span>{<span class="w">NAME</span>}</code>
 will continue to produce "main" and
"foo", respectively.</p>
<p><code class="inline"><span class="i">*foo</span>{<span class="w">IO</span>}</code>
 is an alternative to the <code class="inline"><span class="i">*HANDLE</span></code>
 mechanism given in
<a href="perldata.html#Typeglobs-and-Filehandles">Typeglobs and Filehandles in perldata</a> 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.</p>
<pre class="verbatim"><ol><li>    <span class="i">splutter</span><span class="s">(</span><span class="i">*STDOUT</span><span class="s">)</span><span class="sc">;</span>          <span class="c"># pass the whole glob</span></li><li>    <span class="i">splutter</span><span class="s">(</span><span class="i">*STDOUT</span>{<span class="w">IO</span>}<span class="s">)</span><span class="sc">;</span>      <span class="c"># pass both file and dir handles</span></li><li></li><li><a name="splutter"></a>    sub <span class="m">splutter</span> <span class="s">{</span></li><li>        <a class="l_k" href="functions/my.html">my</a> <span class="i">$fh</span> = <a class="l_k" href="functions/shift.html">shift</a><span class="sc">;</span></li><li>        <a class="l_k" href="functions/print.html">print</a> <span class="i">$fh</span> <span class="q">&quot;her um well a hmmm\n&quot;</span><span class="sc">;</span></li><li>    <span class="s">}</span></li><li></li><li>    <span class="i">$rec</span> = <span class="i">get_rec</span><span class="s">(</span><span class="i">*STDIN</span><span class="s">)</span><span class="sc">;</span>     <span class="c"># pass the whole glob</span></li><li>    <span class="i">$rec</span> = <span class="i">get_rec</span><span class="s">(</span><span class="i">*STDIN</span>{<span class="w">IO</span>}<span class="s">)</span><span class="sc">;</span> <span class="c"># pass both file and dir handles</span></li><li></li><li><a name="get_rec"></a>    sub <span class="m">get_rec</span> <span class="s">{</span></li><li>        <a class="l_k" href="functions/my.html">my</a> <span class="i">$fh</span> = <a class="l_k" href="functions/shift.html">shift</a><span class="sc">;</span></li><li>        <a class="l_k" href="functions/return.html">return</a> <a class="l_k" href="functions/scalar.html">scalar</a> <span class="q">&lt;$fh&gt;</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre></dd>
</dl>
<a name="Using-References"></a><h2>Using References
  </h2>
<p>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.</p>
<dl>
<dt>1.</dt><dd>
<p>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:</p>
<pre class="verbatim"><ol><li>    <span class="i">$bar</span> = <span class="i">$$scalarref</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/push.html">push</a><span class="s">(</span><span class="i">@$arrayref</span><span class="cm">,</span> <span class="i">$filename</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">$$arrayref</span>[<span class="n">0</span>] = <span class="q">&quot;January&quot;</span><span class="sc">;</span></li><li>    <span class="i">$$hashref</span>{<span class="q">&quot;KEY&quot;</span>} = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span></li><li>    <span class="i">&amp;$coderef</span><span class="s">(</span><span class="n">1</span><span class="cm">,</span><span class="n">2</span><span class="cm">,</span><span class="n">3</span><span class="s">)</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/print.html">print</a> <span class="i">$globref</span> <span class="q">&quot;output\n&quot;</span><span class="sc">;</span></li></ol></pre><p>It's important to understand that we are specifically <i>not</i> dereferencing
<code class="inline"><span class="i">$arrayref</span>[<span class="n">0</span>]</code>
 or <code class="inline"><span class="i">$hashref</span>{<span class="q">&quot;KEY&quot;</span>}</code>
 there.  The dereference of the
scalar variable happens <i>before</i> 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".</p>
<pre class="verbatim"><ol><li>    <span class="i">$refrefref</span> = \\\<span class="q">&quot;howdy&quot;</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/print.html">print</a> <span class="i">$$$$refrefref</span><span class="sc">;</span></li></ol></pre></dd>
<dt>2.</dt><dd>
<p>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:</p>
<pre class="verbatim"><ol><li>    <span class="i">$bar</span> = <span class="i">$</span>{<span class="i">$scalarref</span>}<span class="sc">;</span></li><li>    <a class="l_k" href="functions/push.html">push</a><span class="s">(</span><span class="i">@</span>{<span class="i">$arrayref</span>}<span class="cm">,</span> <span class="i">$filename</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">$</span>{<span class="i">$arrayref</span>}[<span class="n">0</span>] = <span class="q">&quot;January&quot;</span><span class="sc">;</span></li><li>    <span class="i">$</span>{<span class="i">$hashref</span>}{<span class="q">&quot;KEY&quot;</span>} = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span></li><li>    <span class="i">&amp;</span>{<span class="i">$coderef</span>}<span class="s">(</span><span class="n">1</span><span class="cm">,</span><span class="n">2</span><span class="cm">,</span><span class="n">3</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="i">$globref</span><span class="i">-&gt;print</span><span class="s">(</span><span class="q">&quot;output\n&quot;</span><span class="s">)</span><span class="sc">;</span>  <span class="c"># iff IO::Handle is loaded</span></li></ol></pre><p>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:</p>
<pre class="verbatim"><ol><li>    <span class="i">&amp;</span>{ <span class="i">$dispatch</span>{<span class="i">$index</span>} }<span class="s">(</span><span class="n">1</span><span class="cm">,</span><span class="n">2</span><span class="cm">,</span><span class="n">3</span><span class="s">)</span><span class="sc">;</span>      <span class="c"># call correct routine</span></li></ol></pre><p>Because of being able to omit the curlies for the simple case of <code class="inline"><span class="i">$$x</span></code>
,
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</i> case 2:</p>
<pre class="verbatim"><ol><li>    <span class="i">$$hashref</span>{<span class="q">&quot;KEY&quot;</span>}   = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span>       <span class="c"># CASE 0</span></li><li>    <span class="i">$</span>{<span class="i">$hashref</span>}{<span class="q">&quot;KEY&quot;</span>} = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span>       <span class="c"># CASE 1</span></li><li>    <span class="i">$</span>{<span class="i">$hashref</span>{<span class="q">&quot;KEY&quot;</span>}} = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span>       <span class="c"># CASE 2</span></li><li>    <span class="i">$</span>{<span class="i">$hashref</span>-&gt;{<span class="q">&quot;KEY&quot;</span>}} = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span>     <span class="c"># CASE 3</span></li></ol></pre><p>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.</p>
</dd>
<dt>3.</dt><dd>
<p>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:</p>
<pre class="verbatim"><ol><li>    <span class="i">$arrayref</span>-&gt;[<span class="n">0</span>] = <span class="q">&quot;January&quot;</span><span class="sc">;</span>   <span class="c"># Array element</span></li><li>    <span class="i">$hashref</span>-&gt;{<span class="q">&quot;KEY&quot;</span>} = <span class="q">&quot;VALUE&quot;</span><span class="sc">;</span>  <span class="c"># Hash element</span></li><li>    <span class="i">$coderef</span>-&gt;<span class="s">(</span><span class="n">1</span><span class="cm">,</span><span class="n">2</span><span class="cm">,</span><span class="n">3</span><span class="s">)</span><span class="sc">;</span>            <span class="c"># Subroutine call</span></li></ol></pre><p>The left side of the arrow can be any expression returning a reference,
including a previous dereference.  Note that <code class="inline"><span class="i">$array</span>[<span class="i">$x</span>]</code>
 is <i>not</i> the
same thing as <code class="inline"><span class="i">$array</span>-&gt;[<span class="i">$x</span>]</code>
 here:</p>
<pre class="verbatim"><ol><li>    <span class="i">$array</span>[<span class="i">$x</span>]-&gt;{<span class="q">&quot;foo&quot;</span>}-&gt;[<span class="n">0</span>] = <span class="q">&quot;January&quot;</span><span class="sc">;</span></li></ol></pre><p>This is one of the cases we mentioned earlier in which references could
spring into existence when in an lvalue context.  Before this
statement, <code class="inline"><span class="i">$array</span>[<span class="i">$x</span>]</code>
 may have been undefined.  If so, it's
automatically defined with a hash reference so that we can look up
<code class="inline"><span class="s">{</span><span class="q">&quot;foo&quot;</span><span class="s">}</span></code>
 in it.  Likewise <code class="inline"><span class="i">$array</span>[<span class="i">$x</span>]-&gt;{<span class="q">&quot;foo&quot;</span>}</code>
 will automatically get
defined with an array reference so that we can look up <code class="inline"><span class="s">[</span><span class="n">0</span><span class="s">]</span></code>
 in it.
This process is called <i>autovivification</i>.</p>
<p>One more thing here.  The arrow is optional <i>between</i> brackets
subscripts, so you can shrink the above down to</p>
<pre class="verbatim"><ol><li>    <span class="i">$array</span>[<span class="i">$x</span>]{<span class="q">&quot;foo&quot;</span>}[<span class="n">0</span>] = <span class="q">&quot;January&quot;</span><span class="sc">;</span></li></ol></pre><p>Which, in the degenerate case of using only ordinary arrays, gives you
multidimensional arrays just like C's:</p>
<pre class="verbatim"><ol><li>    <span class="i">$score</span>[<span class="i">$x</span>][<span class="i">$y</span>][<span class="i">$z</span>] += <span class="n">42</span><span class="sc">;</span></li></ol></pre><p>Well, okay, not entirely like C's arrays, actually.  C doesn't know how
to grow its arrays on demand.  Perl does.</p>
</dd>
<dt>4.</dt><dd>
<p>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.</p>
</dd>
</dl>
<p>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.
</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/if.html">if</a> <span class="s">(</span><span class="i">$ref1</span> == <span class="i">$ref2</span><span class="s">)</span> <span class="s">{</span>  <span class="c"># cheap numeric compare of references</span></li><li>        <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;refs 1 and 2 refer to the same thing\n&quot;</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre><p>Using a reference as a string produces both its referent's type,
including any package blessing as described in <a href="perlobj.html">perlobj</a>, 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 <a href="functions/ref.html">ref</a> for details and examples of its use.
</p>
<p>The bless() operator may be used to associate the object a reference
points to with a package functioning as an object class.  See <a href="perlobj.html">perlobj</a>.</p>
<p>A typeglob may be dereferenced the same way a reference can, because
the dereference syntax always indicates the type of reference desired.
So <code class="inline"><span class="i">$</span>{<span class="i">*foo</span>}</code>
 and <code class="inline"><span class="i">$</span>{\<span class="i">$foo</span>}</code>
 both indicate the same scalar variable.</p>
<p>Here's a trick for interpolating a subroutine call into a string:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;My sub returned @{[mysub(1,2,3)]} that time.\n&quot;</span><span class="sc">;</span></li></ol></pre><p>The way it works is that when the <code class="inline"><span class="i">@</span>{...}</code>
 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 <code class="inline"><span class="i">mysub</span><span class="s">(</span><span class="n">1</span><span class="cm">,</span><span class="n">2</span><span class="cm">,</span><span class="n">3</span><span class="s">)</span></code>
.  So
the whole block returns a reference to an array, which is then
dereferenced by <code class="inline"><span class="i">@</span>{...}</code>
 and stuck into the double-quoted string. This
chicanery is also useful for arbitrary expressions:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;That yields @{[$n + 5]} widgets\n&quot;</span><span class="sc">;</span></li></ol></pre><p>Similarly, an expression that returns a reference to a scalar can be
dereferenced via <code class="inline"><span class="i">$</span>{...}</code>
. Thus, the above expression may be written
as:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;That yields ${\($n + 5)} widgets\n&quot;</span><span class="sc">;</span></li></ol></pre><a name="Circular-References"></a><h2>Circular References
 </h2>
<p>It is possible to create a "circular reference" in Perl, which can lead
to memory leaks. A circular reference occurs when two references
contain a reference to each other, like this:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/my.html">my</a> <span class="i">$foo</span> = <span class="s">{</span><span class="s">}</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/my.html">my</a> <span class="i">$bar</span> = <span class="s">{</span> <span class="w">foo</span> <span class="cm">=&gt;</span> <span class="i">$foo</span> <span class="s">}</span><span class="sc">;</span></li><li>    <span class="i">$foo</span>-&gt;{<span class="w">bar</span>} = <span class="i">$bar</span><span class="sc">;</span></li></ol></pre><p>You can also create a circular reference with a single variable:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/my.html">my</a> <span class="i">$foo</span><span class="sc">;</span></li><li>    <span class="i">$foo</span> = \<span class="i">$foo</span><span class="sc">;</span></li></ol></pre><p>In this case, the reference count for the variables will never reach 0,
and the references will never be garbage-collected. This can lead to
memory leaks.</p>
<p>Because objects in Perl are implemented as references, it's possible to
have circular references with objects as well. Imagine a TreeNode class
where each node references its parent and child nodes. Any node with a
parent will be part of a circular reference.</p>
<p>You can break circular references by creating a "weak reference". A
weak reference does not increment the reference count for a variable,
which means that the object can go out of scope and be destroyed. You
can weaken a reference with the <code class="inline"><span class="w">weaken</span></code>
 function exported by the
<a href="Scalar/Util.html">Scalar::Util</a> module.</p>
<p>Here's how we can make the first example safer:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/use.html">use</a> <span class="w">Scalar::Util</span> <span class="q">&#39;weaken&#39;</span><span class="sc">;</span></li><li></li><li>    <a class="l_k" href="functions/my.html">my</a> <span class="i">$foo</span> = <span class="s">{</span><span class="s">}</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/my.html">my</a> <span class="i">$bar</span> = <span class="s">{</span> <span class="w">foo</span> <span class="cm">=&gt;</span> <span class="i">$foo</span> <span class="s">}</span><span class="sc">;</span></li><li>    <span class="i">$foo</span>-&gt;{<span class="w">bar</span>} = <span class="i">$bar</span><span class="sc">;</span></li><li></li><li>    <span class="w">weaken</span> <span class="i">$foo</span>-&gt;{<span class="w">bar</span>}<span class="sc">;</span></li></ol></pre><p>The reference from <code class="inline"><span class="i">$foo</span></code>
 to <code class="inline"><span class="i">$bar</span></code>
 has been weakened. When the
<code class="inline"><span class="i">$bar</span></code>
 variable goes out of scope, it will be garbage-collected. The
next time you look at the value of the <code class="inline"><span class="i">$foo</span>-&gt;{<span class="w">bar</span>}</code>
 key, it will
be <code class="inline"><a class="l_k" href="functions/undef.html">undef</a></code>.</p>
<p>This action at a distance can be confusing, so you should be careful
with your use of weaken. You should weaken the reference in the
variable that will go out of scope <i>first</i>. That way, the longer-lived
variable will contain the expected reference until it goes out of
scope.</p>
<a name="Symbolic-references"></a><h2>Symbolic references
 
 </h2>
<p>We said that references spring into existence as necessary if they are
undefined, but we didn't say what happens if a value used as a
reference is already defined, but <i>isn't</i> a hard reference.  If you
use it as a reference, it'll be treated as a symbolic
reference.  That is, the value of the scalar is taken to be the <i>name</i>
of a variable, rather than a direct link to a (possibly) anonymous
value.</p>
<p>People frequently expect it to work like this.  So it does.</p>
<pre class="verbatim"><ol><li>    <span class="i">$name</span> = <span class="q">&quot;foo&quot;</span><span class="sc">;</span></li><li>    <span class="i">$$name</span> = <span class="n">1</span><span class="sc">;</span>                 <span class="c"># Sets $foo</span></li><li>    <span class="i">$</span>{<span class="i">$name</span>} = <span class="n">2</span><span class="sc">;</span>               <span class="c"># Sets $foo</span></li><li>    <span class="i">$</span>{<span class="i">$name</span> x <span class="n">2</span>} = <span class="n">3</span><span class="sc">;</span>           <span class="c"># Sets $foofoo</span></li><li>    <span class="i">$name</span>-&gt;[<span class="n">0</span>] = <span class="n">4</span><span class="sc">;</span>             <span class="c"># Sets $foo[0]</span></li><li>    <span class="i">@$name</span> = <span class="s">(</span><span class="s">)</span><span class="sc">;</span>                <span class="c"># Clears @foo</span></li><li>    <span class="i">&amp;$name</span><span class="s">(</span><span class="s">)</span><span class="sc">;</span>                   <span class="c"># Calls &amp;foo()</span></li><li>    <span class="i">$pack</span> = <span class="q">&quot;THAT&quot;</span><span class="sc">;</span></li><li>    <span class="i">$</span>{<span class="q">&quot;${pack}::$name&quot;</span>} = <span class="n">5</span><span class="sc">;</span>    <span class="c"># Sets $THAT::foo without eval</span></li></ol></pre><p>This is powerful, and slightly dangerous, in that it's possible
to intend (with the utmost sincerity) to use a hard reference, and
accidentally use a symbolic reference instead.  To protect against
that, you can say</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/use.html">use</a> <span class="w">strict</span> <span class="q">&#39;refs&#39;</span><span class="sc">;</span></li></ol></pre><p>and then only hard references will be allowed for the rest of the enclosing
block.  An inner block may countermand that with</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/no.html">no</a> <span class="w">strict</span> <span class="q">&#39;refs&#39;</span><span class="sc">;</span></li></ol></pre><p>Only package variables (globals, even if localized) are visible to
symbolic references.  Lexical variables (declared with my()) aren't in
a symbol table, and thus are invisible to this mechanism.  For example:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/local.html">local</a> <span class="i">$value</span> = <span class="n">10</span><span class="sc">;</span></li><li>    <span class="i">$ref</span> = <span class="q">&quot;value&quot;</span><span class="sc">;</span></li><li>    <span class="s">{</span></li><li>        <a class="l_k" href="functions/my.html">my</a> <span class="i">$value</span> = <span class="n">20</span><span class="sc">;</span></li><li>        <a class="l_k" href="functions/print.html">print</a> <span class="i">$$ref</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre><p>This will still print 10, not 20.  Remember that local() affects package
variables, which are all "global" to the package.</p>
<a name="Not-so-symbolic-references"></a><h2>Not-so-symbolic references</h2>
<p>Brackets around a symbolic reference can simply
serve to isolate an identifier or variable name from the rest of an
expression, just as they always have within a string.  For example,</p>
<pre class="verbatim"><ol><li>    <span class="i">$push</span> = <span class="q">&quot;pop on &quot;</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;${push}over&quot;</span><span class="sc">;</span></li></ol></pre><p>has always meant to print "pop on over", even though push is
a reserved word.  This is generalized to work the same
without the enclosing double quotes, so that</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/print.html">print</a> <span class="i">$</span>{<span class="w">push</span>} . <span class="q">&quot;over&quot;</span><span class="sc">;</span></li></ol></pre><p>and even</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/print.html">print</a> <span class="i">$</span>{ <span class="w">push</span> } . <span class="q">&quot;over&quot;</span><span class="sc">;</span></li></ol></pre><p>will have the same effect.  This
construct is <i>not</i> considered to be a symbolic reference when you're
using strict refs:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/use.html">use</a> <span class="w">strict</span> <span class="q">&#39;refs&#39;</span><span class="sc">;</span></li><li>    <span class="i">$</span>{ <span class="w">bareword</span> }<span class="sc">;</span>      <span class="c"># Okay, means $bareword.</span></li><li>    <span class="i">$</span>{ <span class="q">&quot;bareword&quot;</span> }<span class="sc">;</span>    <span class="c"># Error, symbolic reference.</span></li></ol></pre><p>Similarly, because of all the subscripting that is done using single words,
the same rule applies to any bareword that is used for subscripting a hash.
So now, instead of writing</p>
<pre class="verbatim"><ol><li>    <span class="i">$array</span>{ <span class="q">&quot;aaa&quot;</span> }{ <span class="q">&quot;bbb&quot;</span> }{ <span class="q">&quot;ccc&quot;</span> }</li></ol></pre><p>you can write just</p>
<pre class="verbatim"><ol><li>    <span class="i">$array</span>{ <span class="w">aaa</span> }{ <span class="w">bbb</span> }{ <span class="w">ccc</span> }</li></ol></pre><p>and not worry about whether the subscripts are reserved words.  In the
rare event that you do wish to do something like</p>
<pre class="verbatim"><ol><li>    <span class="i">$array</span>{ <span class="w">shift</span> }</li></ol></pre><p>you can force interpretation as a reserved word by adding anything that
makes it more than a bareword:</p>
<pre class="verbatim"><ol><li>    $array{ shift() }</li><li>    $array{ +shift }</li><li>    $array{ shift @_ }</li></ol></pre><p>The <code class="inline"><a class="l_k" href="functions/use.html">use</a> <span class="w">warnings</span></code>
 pragma or the <b>-w</b> switch will warn you if it
interprets a reserved word as a string.
But it will no longer warn you about using lowercase words, because the
string is effectively quoted.</p>
<a name="Pseudo-hashes%3a-Using-an-array-as-a-hash"></a><h2>Pseudo-hashes: Using an array as a hash
  </h2>
<p>Pseudo-hashes have been removed from Perl.  The 'fields' pragma
remains available.</p>
<a name="Function-Templates"></a><h2>Function Templates
   
   </h2>
<p>As explained above, an anonymous function with access to the lexical
variables visible when that function was compiled, creates a closure.  It
retains access to those variables even though it doesn't get run until
later, such as in a signal handler or a Tk callback.</p>
<p>Using a closure as a function template allows us to generate many functions
that act similarly.  Suppose you wanted functions named after the colors
that generated HTML font changes for the various colors:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/print.html">print</a> <span class="q">&quot;Be &quot;</span><span class="cm">,</span> <span class="i">red</span><span class="s">(</span><span class="q">&quot;careful&quot;</span><span class="s">)</span><span class="cm">,</span> <span class="q">&quot;with that &quot;</span><span class="cm">,</span> <span class="i">green</span><span class="s">(</span><span class="q">&quot;light&quot;</span><span class="s">)</span><span class="sc">;</span></li></ol></pre><p>The red() and green() functions would be similar.  To create these,
we'll assign a closure to a typeglob of the name of the function we're
trying to build.</p>
<pre class="verbatim"><ol><li>    <span class="i">@colors</span> = <span class="q">qw(red blue green yellow orange purple violet)</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/for.html">for</a> <a class="l_k" href="functions/my.html">my</a> <span class="i">$name</span> <span class="s">(</span><span class="i">@colors</span><span class="s">)</span> <span class="s">{</span></li><li>        <a class="l_k" href="functions/no.html">no</a> <span class="w">strict</span> <span class="q">&#39;refs&#39;</span><span class="sc">;</span>       <span class="c"># allow symbol table manipulation</span></li><li>        <span class="i">*$name</span> = <span class="i">*</span>{<a class="l_k" href="functions/uc.html">uc</a> <span class="i">$name</span>} = <a class="l_k" href="functions/sub.html">sub</a> <span class="s">{</span> <span class="q">&quot;&lt;FONT COLOR=&#39;$name&#39;&gt;@_&lt;/FONT&gt;&quot;</span> <span class="s">}</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre><p>Now all those different functions appear to exist independently.  You can
call red(), RED(), blue(), BLUE(), green(), etc.  This technique saves on
both compile time and memory use, and is less error-prone as well, since
syntax checks happen at compile time.  It's critical that any variables in
the anonymous subroutine be lexicals in order to create a proper closure.
That's the reasons for the <code class="inline"><a class="l_k" href="functions/my.html">my</a></code> on the loop iteration variable.</p>
<p>This is one of the only places where giving a prototype to a closure makes
much sense.  If you wanted to impose scalar context on the arguments of
these functions (probably not a wise idea for this particular example),
you could have written it this way instead:</p>
<pre class="verbatim"><ol><li>    <span class="i">*$name</span> = <span class="i">sub ($)</span> <span class="s">{</span> <span class="q">&quot;&lt;FONT COLOR=&#39;$name&#39;&gt;$_[0]&lt;/FONT&gt;&quot;</span> <span class="s">}</span><span class="sc">;</span></li></ol></pre><p>However, since prototype checking happens at compile time, the assignment
above happens too late to be of much use.  You could address this by
putting the whole loop of assignments within a BEGIN block, forcing it
to occur during compilation.</p>
<p>Access to lexicals that change over time--like those in the <code class="inline">for</code>
 loop
above, basically aliases to elements from the surrounding lexical scopes--
only works with anonymous subs, not with named subroutines. Generally
said, named subroutines do not nest properly and should only be declared
in the main package scope.</p>
<p>This is because named subroutines are created at compile time so their
lexical variables get assigned to the parent lexicals from the first
execution of the parent block. If a parent scope is entered a second
time, its lexicals are created again, while the nested subs still
reference the old ones.</p>
<p>Anonymous subroutines get to capture each time you execute the <code class="inline"><a class="l_k" href="functions/sub.html">sub</a></code>
operator, as they are created on the fly. If you are accustomed to using
nested subroutines in other programming languages with their own private
variables, you'll have to work at it a bit in Perl.  The intuitive coding
of this type of thing incurs mysterious warnings about "will not stay
shared" due to the reasons explained above.
For example, this won't work:</p>
<pre class="verbatim"><ol><li><a name="outer"></a>    sub <span class="m">outer</span> <span class="s">{</span></li><li>        <a class="l_k" href="functions/my.html">my</a> <span class="i">$x</span> = <span class="i">$_</span>[<span class="n">0</span>] + <span class="n">35</span><span class="sc">;</span></li><li><a name="inner"></a>        sub <span class="m">inner</span> <span class="s">{</span> <a class="l_k" href="functions/return.html">return</a> <span class="i">$x</span> * <span class="n">19</span> <span class="s">}</span>   <span class="c"># WRONG</span></li><li>        <a class="l_k" href="functions/return.html">return</a> <span class="i">$x</span> + <span class="i">inner</span><span class="s">(</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre><p>A work-around is the following:</p>
<pre class="verbatim"><ol><li><a name="outer"></a>    sub <span class="m">outer</span> <span class="s">{</span></li><li>        <a class="l_k" href="functions/my.html">my</a> <span class="i">$x</span> = <span class="i">$_</span>[<span class="n">0</span>] + <span class="n">35</span><span class="sc">;</span></li><li>        <a class="l_k" href="functions/local.html">local</a> <span class="i">*inner</span> = <a class="l_k" href="functions/sub.html">sub</a> <span class="s">{</span> <a class="l_k" href="functions/return.html">return</a> <span class="i">$x</span> * <span class="n">19</span> <span class="s">}</span><span class="sc">;</span></li><li>        <a class="l_k" href="functions/return.html">return</a> <span class="i">$x</span> + <span class="i">inner</span><span class="s">(</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre><p>Now inner() can only be called from within outer(), because of the
temporary assignments of the anonymous subroutine. But when it does,
it has normal access to the lexical variable $x from the scope of
outer() at the time outer is invoked.</p>
<p>This has the interesting effect of creating a function local to another
function, something not normally supported in Perl.</p>
<a name="WARNING%3a-Don't-use-references-as-hash-keys"></a><h1>WARNING: Don't use references as hash keys
 </h1>
<p>You may not (usefully) use a reference as the key to a hash.  It will be
converted into a string:</p>
<pre class="verbatim"><ol><li>    <span class="i">$x</span>{ \<span class="i">$a</span> } = <span class="i">$a</span><span class="sc">;</span></li></ol></pre><p>If you try to dereference the key, it won't do a hard dereference, and
you won't accomplish what you're attempting.  You might want to do something
more like</p>
<pre class="verbatim"><ol><li>    <span class="i">$r</span> = \<span class="i">@a</span><span class="sc">;</span></li><li>    <span class="i">$x</span>{ <span class="i">$r</span> } = <span class="i">$r</span><span class="sc">;</span></li></ol></pre><p>And then at least you can use the values(), which will be
real refs, instead of the keys(), which won't.</p>
<p>The standard Tie::RefHash module provides a convenient workaround to this.</p>
<a name="Postfix-Dereference-Syntax"></a><h2>Postfix Dereference Syntax</h2>
<p>Beginning in v5.20.0, a postfix syntax for using references is
available.  It behaves as described in <a href="#Using-References">Using References</a>, but instead
of a prefixed sigil, a postfixed sigil-and-star is used.</p>
<p>For example:</p>
<pre class="verbatim"><ol><li>    <span class="i">$r</span> = \<span class="i">@a</span><span class="sc">;</span></li><li>    <span class="i">@b</span> = <span class="i">$r</span>-&gt;<span class="i">@*</span><span class="sc">;</span> <span class="c"># equivalent to @$r or @{ $r }</span></li><li></li><li>    <span class="i">$r</span> = <span class="s">[</span> <span class="n">1</span><span class="cm">,</span> <span class="s">[</span> <span class="n">2</span><span class="cm">,</span> <span class="n">3</span> <span class="s">]</span><span class="cm">,</span> <span class="n">4</span> <span class="s">]</span><span class="sc">;</span></li><li>    <span class="i">$r</span>-&gt;[<span class="n">1</span>]-&gt;<span class="i">@*</span><span class="sc">;</span>  <span class="c"># equivalent to @{ $r-&gt;[1] }</span></li></ol></pre><p>In Perl 5.20 and 5.22, this syntax must be enabled with <code class="inline"><a class="l_k" href="functions/use.html">use</a> <span class="w">feature</span>
<span class="q">&#39;postderef&#39;</span></code>
. As of Perl 5.24, no feature declarations are required to make
it available.</p>
<p>Postfix dereference should work in all circumstances where block
(circumfix) dereference worked, and should be entirely equivalent.  This
syntax allows dereferencing to be written and read entirely
left-to-right.  The following equivalencies are defined:</p>
<pre class="verbatim"><ol><li>  <span class="i">$sref</span><span class="i">-&gt;$</span>*<span class="sc">;</span>  <span class="c"># same as  ${ $sref }</span></li><li>  <span class="i">$aref</span>-&gt;<span class="i">@*</span><span class="sc">;</span>  <span class="c"># same as  @{ $aref }</span></li><li>  <span class="i">$aref</span><span class="i">-&gt;$</span><span class="c">#*; # same as $#{ $aref }</span></li><li>  <span class="i">$href</span>-&gt;%<span class="i">*;</span>  <span class="c"># same as  %{ $href }</span></li><li>  <span class="i">$cref</span>-&gt;&amp;<span class="i">*;</span>  <span class="c"># same as  &amp;{ $cref }</span></li><li>  <span class="i">$gref</span>-&gt;**<span class="sc">;</span>  <span class="c"># same as  *{ $gref }</span></li></ol></pre><p>Note especially that <code class="inline"><span class="i">$cref</span>-&gt;&amp;<span class="i">*</span></code>
 is <i>not</i> equivalent to <code class="inline"><span class="i">$cref</span>-&gt;<span class="s">(</span><span class="s">)</span></code>
, and can serve different purposes.</p>
<p>Glob elements can be extracted through the postfix dereferencing feature:</p>
<pre class="verbatim"><ol><li>  <span class="i">$gref</span>-&gt;*{<span class="w">SCALAR</span>}<span class="sc">;</span> <span class="c"># same as *{ $gref }{SCALAR}</span></li></ol></pre><p>Postfix array and scalar dereferencing <i>can</i> be used in interpolating
strings (double quotes or the <code class="inline"><a class="l_k" href="functions/qq.html">qq</a></code> operator), but only if the
<code class="inline"><span class="w">postderef_qq</span></code>
 feature is enabled.</p>
<a name="Postfix-Reference-Slicing"></a><h2>Postfix Reference Slicing</h2>
<p>Value slices of arrays and hashes may also be taken with postfix
dereferencing notation, with the following equivalencies:</p>
<pre class="verbatim"><ol><li>  <span class="i">$aref</span>-&gt;<span class="i">@[</span> ... ]<span class="sc">;</span>  <span class="c"># same as @$aref[ ... ]</span></li><li>  <span class="i">$href</span>-&gt;<span class="i">@</span>{ ... }<span class="sc">;</span>  <span class="c"># same as @$href{ ... }</span></li></ol></pre><p>Postfix key/value pair slicing, added in 5.20.0 and documented in
<a href="perldata.html#Key%2fValue-Hash-Slices">the Key/Value Hash Slices section of perldata</a>, also behaves as expected:</p>
<pre class="verbatim"><ol><li>  <span class="i">$aref</span>-&gt;%[ ... ]<span class="sc">;</span>  <span class="c"># same as %$aref[ ... ]</span></li><li>  <span class="i">$href</span>-&gt;%{ ... }<span class="sc">;</span>  <span class="c"># same as %$href{ ... }</span></li></ol></pre><p>As with postfix array, postfix value slice dereferencing <i>can</i> be used
in interpolating strings (double quotes or the <code class="inline"><a class="l_k" href="functions/qq.html">qq</a></code> operator), but only
if the <code class="inline"><span class="w">postderef_qq</span></code>
 <a href="feature.html">feature</a> is enabled.</p>
<a name="Assigning-to-References"></a><h2>Assigning to References</h2>
<p>Beginning in v5.22.0, the referencing operator can be assigned to.  It
performs an aliasing operation, so that the variable name referenced on the
left-hand side becomes an alias for the thing referenced on the right-hand
side:</p>
<pre class="verbatim"><ol><li>    \<span class="i">$a</span> = \<span class="i">$b</span><span class="sc">;</span> <span class="c"># $a and $b now point to the same scalar</span></li><li>    \<span class="i">&amp;foo</span> = \<span class="i">&amp;bar</span><span class="sc">;</span> <span class="c"># foo() now means bar()</span></li></ol></pre><p>This syntax must be enabled with <code class="inline"><a class="l_k" href="functions/use.html">use</a> <span class="w">feature</span> <span class="q">&#39;refaliasing&#39;</span></code>
.  It is
experimental, and will warn by default unless <code class="inline"><a class="l_k" href="functions/no.html">no</a> <span class="w">warnings</span>
<span class="q">&#39;experimental::refaliasing&#39;</span></code>
 is in effect.</p>
<p>These forms may be assigned to, and cause the right-hand side to be
evaluated in scalar context:</p>
<pre class="verbatim"><ol><li>    \<span class="i">$scalar</span></li><li>    \<span class="i">@array</span></li><li>    \<span class="i">%hash</span></li><li>    \<span class="i">&amp;sub</span></li><li>    \<a class="l_k" href="functions/my.html">my</a> <span class="i">$scalar</span></li><li>    \<a class="l_k" href="functions/my.html">my</a> <span class="i">@array</span></li><li>    \<a class="l_k" href="functions/my.html">my</a> <span class="i">%hash</span></li><li>    \<span class="w">state</span> <span class="i">$scalar</span> <span class="c"># or @array, etc.</span></li><li>    \<a class="l_k" href="functions/our.html">our</a> <span class="i">$scalar</span>   <span class="c"># etc.</span></li><li>    \<a class="l_k" href="functions/local.html">local</a> <span class="i">$scalar</span> <span class="c"># etc.</span></li><li>    \<a class="l_k" href="functions/local.html">local</a> <a class="l_k" href="functions/our.html">our</a> <span class="i">$scalar</span> <span class="c"># etc.</span></li><li>    \<span class="i">$some_array</span>[<span class="i">$index</span>]</li><li>    \<span class="i">$some_hash</span>{<span class="i">$key</span>}</li><li>    \<a class="l_k" href="functions/local.html">local</a> <span class="i">$some_array</span>[<span class="i">$index</span>]</li><li>    \<a class="l_k" href="functions/local.html">local</a> <span class="i">$some_hash</span>{<span class="i">$key</span>}</li><li>    <span class="w">condition</span> ? \<span class="i">$this</span> <span class="co">:</span> \<span class="i">$that</span>[<span class="n">0</span>] <span class="c"># etc.</span></li></ol></pre><p>Slicing operations and parentheses cause
the right-hand side to be evaluated in
list context:</p>
<pre class="verbatim"><ol><li>    \<span class="i">@array</span>[<span class="n">5</span>..<span class="n">7</span>]</li><li>    <span class="s">(</span>\<span class="i">@array</span>[<span class="n">5</span>..<span class="n">7</span>]<span class="s">)</span></li><li>    \<span class="s">(</span><span class="i">@array</span>[<span class="n">5</span>..<span class="n">7</span>]<span class="s">)</span></li><li>    \<span class="i">@hash</span>{<span class="q">&#39;foo&#39;</span><span class="cm">,</span><span class="q">&#39;bar&#39;</span>}</li><li>    <span class="s">(</span>\<span class="i">@hash</span>{<span class="q">&#39;foo&#39;</span><span class="cm">,</span><span class="q">&#39;bar&#39;</span>}<span class="s">)</span></li><li>    \<span class="s">(</span><span class="i">@hash</span>{<span class="q">&#39;foo&#39;</span><span class="cm">,</span><span class="q">&#39;bar&#39;</span>}<span class="s">)</span></li><li>    <span class="s">(</span>\<span class="i">$scalar</span><span class="s">)</span></li><li>    \<span class="s">(</span><span class="i">$scalar</span><span class="s">)</span></li><li>    \<span class="s">(</span><a class="l_k" href="functions/my.html">my</a> <span class="i">$scalar</span><span class="s">)</span></li><li>    \<a class="l_k" href="functions/my.html">my</a><span class="s">(</span><span class="i">$scalar</span><span class="s">)</span></li><li>    <span class="s">(</span>\<span class="i">@array</span><span class="s">)</span></li><li>    <span class="s">(</span>\<span class="i">%hash</span><span class="s">)</span></li><li>    <span class="s">(</span>\<span class="i">&amp;sub</span><span class="s">)</span></li><li>    \<span class="s">(</span><span class="i">&amp;sub</span><span class="s">)</span></li><li>    \<span class="s">(</span><span class="i">$foo</span><span class="cm">,</span> <span class="i">@bar</span><span class="cm">,</span> <span class="i">%baz</span><span class="s">)</span></li><li>    <span class="s">(</span>\<span class="i">$foo</span><span class="cm">,</span> \<span class="i">@bar</span><span class="cm">,</span> \<span class="i">%baz</span><span class="s">)</span></li></ol></pre><p>Each element on the right-hand side must be a reference to a datum of the
right type.  Parentheses immediately surrounding an array (and possibly
also <code class="inline"><a class="l_k" href="functions/my.html">my</a></code>/<code class="inline"><a class="l_k" href="functions/state.html">state</a></code>/<code class="inline"><a class="l_k" href="functions/our.html">our</a></code>/<code class="inline"><a class="l_k" href="functions/local.html">local</a></code>) will make each element of the array an
alias to the corresponding scalar referenced on the right-hand side:</p>
<pre class="verbatim"><ol><li>    \<span class="s">(</span><span class="i">@a</span><span class="s">)</span> = \<span class="s">(</span><span class="i">@b</span><span class="s">)</span><span class="sc">;</span> <span class="c"># @a and @b now have the same elements</span></li><li>    \<a class="l_k" href="functions/my.html">my</a><span class="s">(</span><span class="i">@a</span><span class="s">)</span> = \<span class="s">(</span><span class="i">@b</span><span class="s">)</span><span class="sc">;</span> <span class="c"># likewise</span></li><li>    \<span class="s">(</span><a class="l_k" href="functions/my.html">my</a> <span class="i">@a</span><span class="s">)</span> = \<span class="s">(</span><span class="i">@b</span><span class="s">)</span><span class="sc">;</span> <span class="c"># likewise</span></li><li>    <a class="l_k" href="functions/push.html">push</a> <span class="i">@a</span><span class="cm">,</span> <span class="n">3</span><span class="sc">;</span> <span class="c"># but now @a has an extra element that @b lacks</span></li><li>    \<span class="s">(</span><span class="i">@a</span><span class="s">)</span> = <span class="s">(</span>\<span class="i">$a</span><span class="cm">,</span> \<span class="i">$b</span><span class="cm">,</span> \<span class="i">$c</span><span class="s">)</span><span class="sc">;</span> <span class="c"># @a now contains $a, $b, and $c</span></li></ol></pre><p>Combining that form with <code class="inline"><a class="l_k" href="functions/local.html">local</a></code> and putting parentheses immediately
around a hash are forbidden (because it is not clear what they should do):</p>
<pre class="verbatim"><ol><li>    \<a class="l_k" href="functions/local.html">local</a><span class="s">(</span><span class="i">@array</span><span class="s">)</span> = <span class="i">foo</span><span class="s">(</span><span class="s">)</span><span class="sc">;</span> <span class="c"># WRONG</span></li><li>    \<span class="s">(</span><span class="i">%hash</span><span class="s">)</span>       = <span class="i">bar</span><span class="s">(</span><span class="s">)</span><span class="sc">;</span> <span class="c"># wRONG</span></li></ol></pre><p>Assignment to references and non-references may be combined in lists and
conditional ternary expressions, as long as the values on the right-hand
side are the right type for each element on the left, though this may make
for obfuscated code:</p>
<pre class="verbatim"><ol><li>    <span class="s">(</span><a class="l_k" href="functions/my.html">my</a> <span class="i">$tom</span><span class="cm">,</span> \<a class="l_k" href="functions/my.html">my</a> <span class="i">$dick</span><span class="cm">,</span> \<a class="l_k" href="functions/my.html">my</a> <span class="i">@harry</span><span class="s">)</span> = <span class="s">(</span>\<span class="n">1</span><span class="cm">,</span> \<span class="n">2</span><span class="cm">,</span> <span class="s">[</span><span class="n">1</span>..<span class="n">3</span><span class="s">]</span><span class="s">)</span><span class="sc">;</span></li><li>    <span class="c"># $tom is now \1</span></li><li>    <span class="c"># $dick is now 2 (read-only)</span></li><li>    <span class="c"># @harry is (1,2,3)</span></li><li></li><li>    <a class="l_k" href="functions/my.html">my</a> <span class="i">$type</span> = <a class="l_k" href="functions/ref.html">ref</a> <span class="i">$thingy</span><span class="sc">;</span></li><li>    <span class="s">(</span><span class="i">$type</span> ? <span class="i">$type</span> <a class="l_k" href="functions/eq.html">eq</a> <span class="q">&#39;ARRAY&#39;</span> ? \<span class="i">@foo</span> <span class="co">:</span> \<span class="i">$bar</span> <span class="co">:</span> <span class="i">$baz</span><span class="s">)</span> = <span class="i">$thingy</span><span class="sc">;</span></li></ol></pre><p>The <code class="inline">foreach</code>
 loop can also take a reference constructor for its loop
variable, though the syntax is limited to one of the following, with an
optional <code class="inline"><a class="l_k" href="functions/my.html">my</a></code>, <code class="inline"><a class="l_k" href="functions/state.html">state</a></code>, or <code class="inline"><a class="l_k" href="functions/our.html">our</a></code> after the backslash:</p>
<pre class="verbatim"><ol><li>    \<span class="i">$s</span></li><li>    \<span class="i">@a</span></li><li>    \<span class="i">%h</span></li><li>    \<span class="i">&amp;c</span></li></ol></pre><p>No parentheses are permitted.  This feature is particularly useful for
arrays-of-arrays, or arrays-of-hashes:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/foreach.html">foreach</a> \<a class="l_k" href="functions/my.html">my</a> <span class="i">@a</span> <span class="s">(</span><span class="i">@array_of_arrays</span><span class="s">)</span> <span class="s">{</span></li><li>        <span class="i">frobnicate</span><span class="s">(</span><span class="i">$a</span>[<span class="n">0</span>]<span class="cm">,</span> <span class="i">$a</span>[<span class="n">-1</span>]<span class="s">)</span><span class="sc">;</span></li><li>    <span class="s">}</span></li><li></li><li>    <a class="l_k" href="functions/foreach.html">foreach</a> \<a class="l_k" href="functions/my.html">my</a> <span class="i">%h</span> <span class="s">(</span><span class="i">@array_of_hashes</span><span class="s">)</span> <span class="s">{</span></li><li>        <span class="i">$h</span>{<span class="w">gelastic</span>}++ <a class="l_k" href="functions/if.html">if</a> <span class="i">$h</span>{<span class="w">type</span>} <a class="l_k" href="functions/eq.html">eq</a> <span class="q">&#39;funny&#39;</span><span class="sc">;</span></li><li>    <span class="s">}</span></li></ol></pre><p><b>CAVEAT:</b> Aliasing does not work correctly with closures.  If you try to
alias lexical variables from an inner subroutine or <code class="inline"><a class="l_k" href="functions/eval.html">eval</a></code>, the aliasing
will only be visible within that inner sub, and will not affect the outer
subroutine where the variables are declared.  This bizarre behavior is
subject to change.</p>
<a name="Declaring-a-Reference-to-a-Variable"></a><h1>Declaring a Reference to a Variable</h1>
<p>Beginning in v5.26.0, the referencing operator can come after <code class="inline"><a class="l_k" href="functions/my.html">my</a></code>,
<code class="inline"><a class="l_k" href="functions/state.html">state</a></code>, <code class="inline"><a class="l_k" href="functions/our.html">our</a></code>, or <code class="inline"><a class="l_k" href="functions/local.html">local</a></code>.  This syntax must be enabled with <code class="inline"><a class="l_k" href="functions/use.html">use</a>
<span class="w">feature</span> <span class="q">&#39;declared_refs&#39;</span></code>
.  It is experimental, and will warn by default
unless <code class="inline"><a class="l_k" href="functions/no.html">no</a> <span class="w">warnings</span> <span class="q">&#39;experimental::refaliasing&#39;</span></code>
 is in effect.</p>
<p>This feature makes these:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/my.html">my</a> \<span class="i">$x</span><span class="sc">;</span></li><li>    <a class="l_k" href="functions/our.html">our</a> \<span class="i">$y</span><span class="sc">;</span></li></ol></pre><p>equivalent to:</p>
<pre class="verbatim"><ol><li>    \<a class="l_k" href="functions/my.html">my</a> <span class="i">$x</span><span class="sc">;</span></li><li>    \<a class="l_k" href="functions/our.html">our</a> <span class="i">$x</span><span class="sc">;</span></li></ol></pre><p>It is intended mainly for use in assignments to references (see
<a href="#Assigning-to-References">Assigning to References</a>, above).  It also allows the backslash to be
used on just some items in a list of declared variables:</p>
<pre class="verbatim"><ol><li>    <a class="l_k" href="functions/my.html">my</a> <span class="s">(</span><span class="i">$foo</span><span class="cm">,</span> \<span class="i">@bar</span><span class="cm">,</span> \<span class="i">%baz</span><span class="s">)</span><span class="sc">;</span> <span class="c"># equivalent to:  my $foo, \my(@bar, %baz);</span></li></ol></pre><a name="SEE-ALSO"></a><h1>SEE ALSO</h1>
<p>Besides the obvious documents, source code can be instructive.
Some pathological examples of the use of references can be found
in the <i>t/op/ref.t</i> regression test in the Perl source directory.</p>
<p>See also <a href="perldsc.html">perldsc</a> and <a href="perllol.html">perllol</a> for how to use references to create
complex data structures, and <a href="perlootut.html">perlootut</a> and <a href="perlobj.html">perlobj</a>
for how to use them to create objects.</p>




  <div id="page_index" class="hud_container">
    <div id="page_index_header" class="hud_header">
      <div id="page_index_close" class="hud_close"><a href="#" onClick="pageIndex.hide();return false;"></a></div>
      <div id="page_index_title" class="hud_title"><span class="hud_span_top">Page index</span></div>
      <div id="page_index_topright" class="hud_topright"></div>
    </div>
    <div id="page_index_content" class="hud_content">
      <ul><li><a href="#NAME">NAME
    </a><li><a href="#NOTE">NOTE</a><li><a href="#DESCRIPTION">DESCRIPTION</a><ul><li><a href="#Making-References">Making References
 </a><li><a href="#Using-References">Using References
  </a><li><a href="#Circular-References">Circular References
 </a><li><a href="#Symbolic-references">Symbolic references
 
 </a><li><a href="#Not-so-symbolic-references">Not-so-symbolic references</a><li><a href="#Pseudo-hashes%3a-Using-an-array-as-a-hash">Pseudo-hashes: Using an array as a hash
  </a><li><a href="#Function-Templates">Function Templates
   
   </a></ul><li><a href="#WARNING%3a-Don't-use-references-as-hash-keys">WARNING: Don't use references as hash keys
 </a><ul><li><a href="#Postfix-Dereference-Syntax">Postfix Dereference Syntax</a><li><a href="#Postfix-Reference-Slicing">Postfix Reference Slicing</a><li><a href="#Assigning-to-References">Assigning to References</a></ul><li><a href="#Declaring-a-Reference-to-a-Variable">Declaring a Reference to a Variable</a><li><a href="#SEE-ALSO">SEE ALSO</a></ul>
    </div>
    <div id="page_index_footer" class="hud_footer">
      <div id="page_index_bottomleft" class="hud_bottomleft"></div>
      <div id="page_index_bottom" class="hud_bottom"><span class="hud_span_bottom"></span></div>
      <div id="page_index_resize" class="hud_resize"></div>
    </div>
  </div>


	    &nbsp;
          </div>
          <div id="content_footer">
          </div>
        </div>
        <div class="clear"></div>
      </div>
      
    <div id="footer">
      <div id="footer_content">
        <div id="footer_strapline">
          perldoc.perl.org - Official documentation for the Perl programming language
        </div>
        <div id="footer_links">
          <div id="address">
            <p class="name">Contact details</p>
            <p class="address">
	      Site maintained by <a href="mailto:jj@jonallen.info">Jon Allen (JJ)</a><br>
	    </p>
            <p class="contact">
              Documentation maintained by the <a href="http://lists.cpan.org/showlist.cgi?name=perl5-porters">Perl 5 Porters</a>
            </p>
          </div>
          <ul class="f1">
            <li>Manual
              <ul class="f2">
                <li><a href="index-overview.html">Overview</a>
                <li><a href="index-tutorials.html">Tutorials</a>
                <li><a href="index-faq.html">FAQs</a>
                <li><a href="index-history.html">Changes</a>
              </ul>
            <li>Reference
              <ul class="f2">
                <li><a href="index-language.html">Language</a>
                <li><a href="index-functions.html">Functions</a>
                <li><a href="perlop.html">Operators</a>
                <li><a href="perlvar.html">Variables</a>
              </ul>
            <li>Modules
              <ul class="f2">
                <li><a href="index-modules-A.html">Modules</a>
                <li><a href="index-pragmas.html">Pragmas</a>
                <li><a href="index-utilities.html">Utilities</a>
              </ul>
            <li>Misc
              <ul class="f2">
                <li><a href="index-licence.html">License</a>
                <li><a href="index-internals.html">Internals</a>
                <li><a href="index-platforms.html">Platforms</a>
              </ul>          </ul>
          <div class="clear"></div>
        </div>
      </div>
      <div id="footer_end">
      </div>
    </div>
      
    </div>
      <script language="JavaScript" type="text/javascript" src="static/exploreperl.js"></script>
      <script language="JavaScript" src="static/combined-20100403.js" type="text/javascript"></script>
<script language="JavaScript" type="text/javascript">
  perldoc.setPath(0);
  perldoc.pageName    = 'perlref';
  perldoc.pageAddress = 'perlref.html';
  perldoc.contentPage = 1;
  explorePerl.render();
  explorePerl.addEvents('explore_anchor');
</script>
    
  </body>
</html>