perlsub.1

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

.Vb 8
\&    {
\&        my $secret_val = 0;
\&        sub gimme_another {
\&            return ++$secret_val;
\&        }
\&    }
\&    # $secret_val now becomes unreachable by the outside
\&    # world, but retains its value between calls to gimme_another
.Ve
.PP
If this function is being sourced in from a separate file
via \f(CW\*(C`require\*(C'\fR or \f(CW\*(C`use\*(C'\fR, then this is probably just fine.  If it's
all in the main program, you'll need to arrange for the \f(CW\*(C`my\*(C'\fR
to be executed early, either by putting the whole block above
your main program, or more likely, placing merely a \f(CW\*(C`BEGIN\*(C'\fR
code block around it to make sure it gets executed before your program
starts to run:
.PP
.Vb 6
\&    BEGIN {
\&        my $secret_val = 0;
\&        sub gimme_another {
\&            return ++$secret_val;
\&        }
\&    }
.Ve
.PP
See \*(L"\s-1BEGIN\s0, \s-1UNITCHECK\s0, \s-1CHECK\s0, \s-1INIT\s0 and \s-1END\s0\*(R" in perlmod about the
special triggered code blocks, \f(CW\*(C`BEGIN\*(C'\fR, \f(CW\*(C`UNITCHECK\*(C'\fR, \f(CW\*(C`CHECK\*(C'\fR,
\&\f(CW\*(C`INIT\*(C'\fR and \f(CW\*(C`END\*(C'\fR.
.PP
If declared at the outermost scope (the file scope), then lexicals
work somewhat like C's file statics.  They are available to all
functions in that same file declared below them, but are inaccessible
from outside that file.  This strategy is sometimes used in modules
to create private variables that the whole module can see.
.Sh "Temporary Values via \fIlocal()\fP"
.IX Xref "local scope, dynamic dynamic scope variable, local variable, temporary"
.IX Subsection "Temporary Values via local()"
\&\fB\s-1WARNING\s0\fR: In general, you should be using \f(CW\*(C`my\*(C'\fR instead of \f(CW\*(C`local\*(C'\fR, because
it's faster and safer.  Exceptions to this include the global punctuation
variables, global filehandles and formats, and direct manipulation of the
Perl symbol table itself.  \f(CW\*(C`local\*(C'\fR is mostly used when the current value
of a variable must be visible to called subroutines.
.PP
Synopsis:
.PP
.Vb 1
\&    # localization of values
\&
\&    local $foo;                 # make $foo dynamically local
\&    local (@wid, %get);         # make list of variables local
\&    local $foo = "flurp";       # make $foo dynamic, and init it
\&    local @oof = @bar;          # make @oof dynamic, and init it
\&
\&    local $hash{key} = "val";   # sets a local value for this hash entry
\&    local ($cond ? $v1 : $v2);  # several types of lvalues support
\&                                # localization
\&
\&    # localization of symbols
\&
\&    local *FH;                  # localize $FH, @FH, %FH, &FH  ...
\&    local *merlyn = *randal;    # now $merlyn is really $randal, plus
\&                                #     @merlyn is really @randal, etc
\&    local *merlyn = \*(Aqrandal\*(Aq;   # SAME THING: promote \*(Aqrandal\*(Aq to *randal
\&    local *merlyn = \e$randal;   # just alias $merlyn, not @merlyn etc
.Ve
.PP
A \f(CW\*(C`local\*(C'\fR modifies its listed variables to be \*(L"local\*(R" to the
enclosing block, \f(CW\*(C`eval\*(C'\fR, or \f(CW\*(C`do FILE\*(C'\fR\-\-and to \fIany subroutine
called from within that block\fR.  A \f(CW\*(C`local\*(C'\fR just gives temporary
values to global (meaning package) variables.  It does \fInot\fR create
a local variable.  This is known as dynamic scoping.  Lexical scoping
is done with \f(CW\*(C`my\*(C'\fR, which works more like C's auto declarations.
.PP
Some types of lvalues can be localized as well : hash and array elements
and slices, conditionals (provided that their result is always
localizable), and symbolic references.  As for simple variables, this
creates new, dynamically scoped values.
.PP
If more than one variable or expression is given to \f(CW\*(C`local\*(C'\fR, they must be
placed in parentheses.  This operator works
by saving the current values of those variables in its argument list on a
hidden stack and restoring them upon exiting the block, subroutine, or
eval.  This means that called subroutines can also reference the local
variable, but not the global one.  The argument list may be assigned to if
desired, which allows you to initialize your local variables.  (If no
initializer is given for a particular variable, it is created with an
undefined value.)
.PP
Because \f(CW\*(C`local\*(C'\fR is a run-time operator, it gets executed each time
through a loop.  Consequently, it's more efficient to localize your
variables outside the loop.
.PP
\fIGrammatical note on \fIlocal()\fI\fR
.IX Xref "local, context"
.IX Subsection "Grammatical note on local()"
.PP
A \f(CW\*(C`local\*(C'\fR is simply a modifier on an lvalue expression.  When you assign to
a \f(CW\*(C`local\*(C'\fRized variable, the \f(CW\*(C`local\*(C'\fR doesn't change whether its list is viewed
as a scalar or an array.  So
.PP
.Vb 2
\&    local($foo) = <STDIN>;
\&    local @FOO = <STDIN>;
.Ve
.PP
both supply a list context to the right-hand side, while
.PP
.Vb 1
\&    local $foo = <STDIN>;
.Ve
.PP
supplies a scalar context.
.PP
\fILocalization of special variables\fR
.IX Xref "local, special variable"
.IX Subsection "Localization of special variables"
.PP
If you localize a special variable, you'll be giving a new value to it,
but its magic won't go away.  That means that all side-effects related
to this magic still work with the localized value.
.PP
This feature allows code like this to work :
.PP
.Vb 2
\&    # Read the whole contents of FILE in $slurp
\&    { local $/ = undef; $slurp = <FILE>; }
.Ve
.PP
Note, however, that this restricts localization of some values ; for
example, the following statement dies, as of perl 5.9.0, with an error
\&\fIModification of a read-only value attempted\fR, because the \f(CW$1\fR variable is
magical and read-only :
.PP
.Vb 1
\&    local $1 = 2;
.Ve
.PP
Similarly, but in a way more difficult to spot, the following snippet will
die in perl 5.9.0 :
.PP
.Vb 5
\&    sub f { local $_ = "foo"; print }
\&    for ($1) {
\&        # now $_ is aliased to $1, thus is magic and readonly
\&        f();
\&    }
.Ve
.PP
See next section for an alternative to this situation.
.PP
\&\fB\s-1WARNING\s0\fR: Localization of tied arrays and hashes does not currently
work as described.
This will be fixed in a future release of Perl; in the meantime, avoid
code that relies on any particular behaviour of localising tied arrays
or hashes (localising individual elements is still okay).
See \*(L"Localising Tied Arrays and Hashes Is Broken\*(R" in perl58delta for more
details.
.IX Xref "local, tie"
.PP
\fILocalization of globs\fR
.IX Xref "local, glob glob"
.IX Subsection "Localization of globs"
.PP
The construct
.PP
.Vb 1
\&    local *name;
.Ve
.PP
creates a whole new symbol table entry for the glob \f(CW\*(C`name\*(C'\fR in the
current package.  That means that all variables in its glob slot ($name,
\&\f(CW@name\fR, \f(CW%name\fR, &name, and the \f(CW\*(C`name\*(C'\fR filehandle) are dynamically reset.
.PP
This implies, among other things, that any magic eventually carried by
those variables is locally lost.  In other words, saying \f(CW\*(C`local */\*(C'\fR
will not have any effect on the internal value of the input record
separator.
.PP
Notably, if you want to work with a brand new value of the default scalar
\&\f(CW$_\fR, and avoid the potential problem listed above about \f(CW$_\fR previously
carrying a magic value, you should use \f(CW\*(C`local *_\*(C'\fR instead of \f(CW\*(C`local $_\*(C'\fR.
As of perl 5.9.1, you can also use the lexical form of \f(CW$_\fR (declaring it
with \f(CW\*(C`my $_\*(C'\fR), which avoids completely this problem.
.PP
\fILocalization of elements of composite types\fR
.IX Xref "local, composite type element local, array element local, hash element"
.IX Subsection "Localization of elements of composite types"
.PP
It's also worth taking a moment to explain what happens when you
\&\f(CW\*(C`local\*(C'\fRize a member of a composite type (i.e. an array or hash element).
In this case, the element is \f(CW\*(C`local\*(C'\fRized \fIby name\fR. This means that
when the scope of the \f(CW\*(C`local()\*(C'\fR ends, the saved value will be
restored to the hash element whose key was named in the \f(CW\*(C`local()\*(C'\fR, or
the array element whose index was named in the \f(CW\*(C`local()\*(C'\fR.  If that
element was deleted while the \f(CW\*(C`local()\*(C'\fR was in effect (e.g. by a
\&\f(CW\*(C`delete()\*(C'\fR from a hash or a \f(CW\*(C`shift()\*(C'\fR of an array), it will spring
back into existence, possibly extending an array and filling in the
skipped elements with \f(CW\*(C`undef\*(C'\fR.  For instance, if you say
.PP
.Vb 10
\&    %hash = ( \*(AqThis\*(Aq => \*(Aqis\*(Aq, \*(Aqa\*(Aq => \*(Aqtest\*(Aq );
\&    @ary  = ( 0..5 );
\&    {
\&         local($ary[5]) = 6;
\&         local($hash{\*(Aqa\*(Aq}) = \*(Aqdrill\*(Aq;
\&         while (my $e = pop(@ary)) {
\&             print "$e . . .\en";
\&             last unless $e > 3;
\&         }
\&         if (@ary) {
\&             $hash{\*(Aqonly a\*(Aq} = \*(Aqtest\*(Aq;
\&             delete $hash{\*(Aqa\*(Aq};
\&         }
\&    }
\&    print join(\*(Aq \*(Aq, map { "$_ $hash{$_}" } sort keys %hash),".\en";
\&    print "The array has ",scalar(@ary)," elements: ",
\&          join(\*(Aq, \*(Aq, map { defined $_ ? $_ : \*(Aqundef\*(Aq } @ary),"\en";
.Ve
.PP
Perl will print
.PP
.Vb 5
\&    6 . . .
\&    4 . . .
\&    3 . . .
\&    This is a test only a test.
\&    The array has 6 elements: 0, 1, 2, undef, undef, 5
.Ve
.PP
The behavior of \fIlocal()\fR on non-existent members of composite
types is subject to change in future.
.Sh "Lvalue subroutines"
.IX Xref "lvalue subroutine, lvalue"
.IX Subsection "Lvalue subroutines"
\&\fB\s-1WARNING\s0\fR: Lvalue subroutines are still experimental and the
implementation may change in future versions of Perl.
.PP
It is possible to return a modifiable value from a subroutine.
To do this, you have to declare the subroutine to return an lvalue.
.PP
.Vb 8
\&    my $val;
\&    sub canmod : lvalue {
\&        # return $val; this doesn\*(Aqt work, don\*(Aqt say "return"
\&        $val;
\&    }
\&    sub nomod {
\&        $val;
\&    }
\&
\&    canmod() = 5;   # assigns to $val
\&    nomod()  = 5;   # ERROR
.Ve
.PP
The scalar/list context for the subroutine and for the right-hand
side of assignment is determined as if the subroutine call is replaced
by a scalar. For example, consider:
.PP
.Vb 1
\&    data(2,3) = get_data(3,4);
.Ve
.PP
Both subroutines here are called in a scalar context, while in:
.PP
.Vb 1
\&    (data(2,3)) = get_data(3,4);
.Ve
.PP
and in:
.PP
.Vb 1
\&    (data(2),data(3)) = get_data(3,4);
.Ve
.PP
all the subroutines are called in a list context.
.IP "Lvalue subroutines are \s-1EXPERIMENTAL\s0" 4
.IX Item "Lvalue subroutines are EXPERIMENTAL"
They appear to be convenient, but there are several reasons to be
circumspect.
.Sp
You can't use the return keyword, you must pass out the value before
falling out of subroutine scope. (see comment in example above).  This
is usually not a problem, but it disallows an explicit return out of a
deeply nested loop, which is sometimes a nice way out.
.Sp
They violate encapsulation.  A normal mutator can check the supplied
argument before setting the attribute it is protecting, an lvalue
subroutine never gets that chance.  Consider;
.Sp
.Vb 1
\&    my $some_array_ref = [];    # protected by mutators ??
\&
\&    sub set_arr {               # normal mutator
\&        my $val = shift;
\&        die("expected array, you supplied ", ref $val)
\&           unless ref $val eq \*(AqARRAY\*(Aq;
\&        $some_array_ref = $val;
\&    }
\&    sub set_arr_lv : lvalue {   # lvalue mutator
\&        $some_array_ref;
\&    }
\&
\&    # set_arr_lv cannot stop this !
\&    set_arr_lv() = { a => 1 };
.Ve
.Sh "Passing Symbol Table Entries (typeglobs)"
.IX Xref "typeglob *"
.IX Subsection "Passing Symbol Table Entries (typeglobs)"
\&\fB\s-1WARNING\s0\fR: The mechanism described in this section was originally
the only way to simulate pass-by-reference in older versions of
Perl.  While it still works fine in modern versions, the new reference
mechanism is generally easier to work with.  See below.
.PP
Sometimes you don't want to pass the value of an array to a subroutine
but rather the name of it, so that the subroutine can modify the global
copy of it rather than working with a local copy.  In perl you can
refer to all objects of a particular name by prefixing the name
with a star: \f(CW*foo\fR.  This is often known as a \*(L"typeglob\*(R", because the
star on the front can be thought of as a wildcard match for all the
funny prefix characters on variables and subroutines and such.
.PP
When evaluated, the typeglob produces a scalar value that represents
all the objects of that name, including any filehandle, format, or
subroutine.  When assigned to, it causes the name mentioned to refer to
whatever \f(CW\*(C`*\*(C'\fR value was assigned to it.  Example:
.PP
.Vb 8
\&    sub doubleary {
\&        local(*someary) = @_;
\&        foreach $elem (@someary) {
\&            $elem *= 2;
\&        }
\&    }
\&    doubleary(*foo);
\&    doubleary(*bar);
.Ve