The goto-LABEL form finds the statement labeled with LABEL and
resumes execution there. It can't be used to get out of a block or
subroutine given to sort. It can be used to go almost anywhere
else within the dynamic scope, including out of subroutines, but it's
usually better to use some other construct such as last or die.
The author of Perl has never felt the need to use this form of goto
(in Perl, that is; C is another matter). (The difference is that C
does not offer named loops combined with loop control. Perl does, and
this replaces most structured uses of goto in other languages.)
The goto-EXPR form expects a label name, whose scope will be resolved
dynamically. This allows for computed gotos per FORTRAN, but isn't
necessarily recommended if you're optimizing for maintainability:
- goto ("FOO", "BAR", "GLARCH")[$i];
As shown in this example, goto-EXPR is exempt from the "looks like a
function" rule. A pair of parentheses following it does not (necessarily)
delimit its argument. goto("NE")."XT" is equivalent to goto NEXT
.
Use of goto-LABEL or goto-EXPR to jump into a construct is
deprecated and will issue a warning. Even then, it may not be used to
go into any construct that requires initialization, such as a
subroutine or a foreach
loop. It also can't be used to go into a
construct that is optimized away.
The goto-&NAME form is quite different from the other forms of
goto. In fact, it isn't a goto in the normal sense at all, and
doesn't have the stigma associated with other gotos. Instead, it
exits the current subroutine (losing any changes set by local()) and
immediately calls in its place the named subroutine using the current
value of @_. This is used by AUTOLOAD
subroutines that wish to
load another subroutine and then pretend that the other subroutine had
been called in the first place (except that any modifications to @_
in the current subroutine are propagated to the other subroutine.)
After the goto, not even caller will be able to tell that this
routine was called first.
NAME needn't be the name of a subroutine; it can be a scalar variable containing a code reference, or a block that evaluates to a code reference.