perlsub.1

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

.PP
.Vb 1
\&    (@a, @b)   = upcase(@list1, @list2);
.Ve
.PP
Like the flattened incoming parameter list, the return list is also
flattened on return.  So all you have managed to do here is stored
everything in \f(CW@a\fR and made \f(CW@b\fR empty.  See 
\&\*(L"Pass by Reference\*(R" for alternatives.
.PP
A subroutine may be called using an explicit \f(CW\*(C`&\*(C'\fR prefix.  The
\&\f(CW\*(C`&\*(C'\fR is optional in modern Perl, as are parentheses if the
subroutine has been predeclared.  The \f(CW\*(C`&\*(C'\fR is \fInot\fR optional
when just naming the subroutine, such as when it's used as
an argument to \fIdefined()\fR or \fIundef()\fR.  Nor is it optional when you
want to do an indirect subroutine call with a subroutine name or
reference using the \f(CW\*(C`&$subref()\*(C'\fR or \f(CW\*(C`&{$subref}()\*(C'\fR constructs,
although the \f(CW\*(C`$subref\->()\*(C'\fR notation solves that problem.
See perlref for more about all that.
.IX Xref "&"
.PP
Subroutines may be called recursively.  If a subroutine is called
using the \f(CW\*(C`&\*(C'\fR form, the argument list is optional, and if omitted,
no \f(CW@_\fR array is set up for the subroutine: the \f(CW@_\fR array at the
time of the call is visible to subroutine instead.  This is an
efficiency mechanism that new users may wish to avoid.
.IX Xref "recursion"
.PP
.Vb 2
\&    &foo(1,2,3);        # pass three arguments
\&    foo(1,2,3);         # the same
\&
\&    foo();              # pass a null list
\&    &foo();             # the same
\&
\&    &foo;               # foo() get current args, like foo(@_) !!
\&    foo;                # like foo() IFF sub foo predeclared, else "foo"
.Ve
.PP
Not only does the \f(CW\*(C`&\*(C'\fR form make the argument list optional, it also
disables any prototype checking on arguments you do provide.  This
is partly for historical reasons, and partly for having a convenient way
to cheat if you know what you're doing.  See Prototypes below.
.IX Xref "&"
.PP
Subroutines whose names are in all upper case are reserved to the Perl
core, as are modules whose names are in all lower case.  A subroutine in
all capitals is a loosely-held convention meaning it will be called
indirectly by the run-time system itself, usually due to a triggered event.
Subroutines that do special, pre-defined things include \f(CW\*(C`AUTOLOAD\*(C'\fR, \f(CW\*(C`CLONE\*(C'\fR,
\&\f(CW\*(C`DESTROY\*(C'\fR plus all functions mentioned in perltie and PerlIO::via.
.PP
The \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 subroutines
are not so much subroutines as named special code blocks, of which you
can have more than one in a package, and which you can \fBnot\fR call
explicitly.  See \*(L"\s-1BEGIN\s0, \s-1UNITCHECK\s0, \s-1CHECK\s0, \s-1INIT\s0 and \s-1END\s0\*(R" in perlmod
.Sh "Private Variables via \fImy()\fP"
.IX Xref "my variable, lexical lexical lexical variable scope, lexical lexical scope attributes, my"
.IX Subsection "Private Variables via my()"
Synopsis:
.PP
.Vb 5
\&    my $foo;            # declare $foo lexically local
\&    my (@wid, %get);    # declare list of variables local
\&    my $foo = "flurp";  # declare $foo lexical, and init it
\&    my @oof = @bar;     # declare @oof lexical, and init it
\&    my $x : Foo = $y;   # similar, with an attribute applied
.Ve
.PP
\&\fB\s-1WARNING\s0\fR: The use of attribute lists on \f(CW\*(C`my\*(C'\fR declarations is still
evolving.  The current semantics and interface are subject to change.
See attributes and Attribute::Handlers.
.PP
The \f(CW\*(C`my\*(C'\fR operator declares the listed variables to be lexically
confined to the enclosing block, conditional (\f(CW\*(C`if/unless/elsif/else\*(C'\fR),
loop (\f(CW\*(C`for/foreach/while/until/continue\*(C'\fR), subroutine, \f(CW\*(C`eval\*(C'\fR,
or \f(CW\*(C`do/require/use\*(C'\fR'd file.  If more than one value is listed, the
list must be placed in parentheses.  All listed elements must be
legal lvalues.  Only alphanumeric identifiers may be lexically
scoped\*(--magical built-ins like \f(CW$/\fR must currently be \f(CW\*(C`local\*(C'\fRized
with \f(CW\*(C`local\*(C'\fR instead.
.PP
Unlike dynamic variables created by the \f(CW\*(C`local\*(C'\fR operator, lexical
variables declared with \f(CW\*(C`my\*(C'\fR are totally hidden from the outside
world, including any called subroutines.  This is true if it's the
same subroutine called from itself or elsewhere\*(--every call gets
its own copy.
.IX Xref "local"
.PP
This doesn't mean that a \f(CW\*(C`my\*(C'\fR variable declared in a statically
enclosing lexical scope would be invisible.  Only dynamic scopes
are cut off.   For example, the \f(CW\*(C`bumpx()\*(C'\fR function below has access
to the lexical \f(CW$x\fR variable because both the \f(CW\*(C`my\*(C'\fR and the \f(CW\*(C`sub\*(C'\fR
occurred at the same scope, presumably file scope.
.PP
.Vb 2
\&    my $x = 10;
\&    sub bumpx { $x++ }
.Ve
.PP
An \f(CW\*(C`eval()\*(C'\fR, however, can see lexical variables of the scope it is
being evaluated in, so long as the names aren't hidden by declarations within
the \f(CW\*(C`eval()\*(C'\fR itself.  See perlref.
.IX Xref "eval, scope of"
.PP
The parameter list to \fImy()\fR may be assigned to if desired, which allows you
to initialize your variables.  (If no initializer is given for a
particular variable, it is created with the undefined value.)  Commonly
this is used to name input parameters to a subroutine.  Examples:
.PP
.Vb 4
\&    $arg = "fred";        # "global" variable
\&    $n = cube_root(27);
\&    print "$arg thinks the root is $n\en";
\& fred thinks the root is 3
\&
\&    sub cube_root {
\&        my $arg = shift;  # name doesn\*(Aqt matter
\&        $arg **= 1/3;
\&        return $arg;
\&    }
.Ve
.PP
The \f(CW\*(C`my\*(C'\fR is simply a modifier on something you might assign to.  So when
you do assign to variables in its argument list, \f(CW\*(C`my\*(C'\fR doesn't
change whether those variables are viewed as a scalar or an array.  So
.PP
.Vb 2
\&    my ($foo) = <STDIN>;                # WRONG?
\&    my @FOO = <STDIN>;
.Ve
.PP
both supply a list context to the right-hand side, while
.PP
.Vb 1
\&    my $foo = <STDIN>;
.Ve
.PP
supplies a scalar context.  But the following declares only one variable:
.PP
.Vb 1
\&    my $foo, $bar = 1;                  # WRONG
.Ve
.PP
That has the same effect as
.PP
.Vb 2
\&    my $foo;
\&    $bar = 1;
.Ve
.PP
The declared variable is not introduced (is not visible) until after
the current statement.  Thus,
.PP
.Vb 1
\&    my $x = $x;
.Ve
.PP
can be used to initialize a new \f(CW$x\fR with the value of the old \f(CW$x\fR, and
the expression
.PP
.Vb 1
\&    my $x = 123 and $x == 123
.Ve
.PP
is false unless the old \f(CW$x\fR happened to have the value \f(CW123\fR.
.PP
Lexical scopes of control structures are not bounded precisely by the
braces that delimit their controlled blocks; control expressions are
part of that scope, too.  Thus in the loop
.PP
.Vb 5
\&    while (my $line = <>) {
\&        $line = lc $line;
\&    } continue {
\&        print $line;
\&    }
.Ve
.PP
the scope of \f(CW$line\fR extends from its declaration throughout the rest of
the loop construct (including the \f(CW\*(C`continue\*(C'\fR clause), but not beyond
it.  Similarly, in the conditional
.PP
.Vb 8
\&    if ((my $answer = <STDIN>) =~ /^yes$/i) {
\&        user_agrees();
\&    } elsif ($answer =~ /^no$/i) {
\&        user_disagrees();
\&    } else {
\&        chomp $answer;
\&        die "\*(Aq$answer\*(Aq is neither \*(Aqyes\*(Aq nor \*(Aqno\*(Aq";
\&    }
.Ve
.PP
the scope of \f(CW$answer\fR extends from its declaration through the rest
of that conditional, including any \f(CW\*(C`elsif\*(C'\fR and \f(CW\*(C`else\*(C'\fR clauses, 
but not beyond it.  See \*(L"Simple statements\*(R" in perlsyn for information
on the scope of variables in statements with modifiers.
.PP
The \f(CW\*(C`foreach\*(C'\fR loop defaults to scoping its index variable dynamically
in the manner of \f(CW\*(C`local\*(C'\fR.  However, if the index variable is
prefixed with the keyword \f(CW\*(C`my\*(C'\fR, or if there is already a lexical
by that name in scope, then a new lexical is created instead.  Thus
in the loop
.IX Xref "foreach for"
.PP
.Vb 3
\&    for my $i (1, 2, 3) {
\&        some_function();
\&    }
.Ve
.PP
the scope of \f(CW$i\fR extends to the end of the loop, but not beyond it,
rendering the value of \f(CW$i\fR inaccessible within \f(CW\*(C`some_function()\*(C'\fR.
.IX Xref "foreach for"
.PP
Some users may wish to encourage the use of lexically scoped variables.
As an aid to catching implicit uses to package variables,
which are always global, if you say
.PP
.Vb 1
\&    use strict \*(Aqvars\*(Aq;
.Ve
.PP
then any variable mentioned from there to the end of the enclosing
block must either refer to a lexical variable, be predeclared via
\&\f(CW\*(C`our\*(C'\fR or \f(CW\*(C`use vars\*(C'\fR, or else must be fully qualified with the package name.
A compilation error results otherwise.  An inner block may countermand
this with \f(CW\*(C`no strict \*(Aqvars\*(Aq\*(C'\fR.
.PP
A \f(CW\*(C`my\*(C'\fR has both a compile-time and a run-time effect.  At compile
time, the compiler takes notice of it.  The principal usefulness
of this is to quiet \f(CW\*(C`use strict \*(Aqvars\*(Aq\*(C'\fR, but it is also essential
for generation of closures as detailed in perlref.  Actual
initialization is delayed until run time, though, so it gets executed
at the appropriate time, such as each time through a loop, for
example.
.PP
Variables declared with \f(CW\*(C`my\*(C'\fR are not part of any package and are therefore
never fully qualified with the package name.  In particular, you're not
allowed to try to make a package variable (or other global) lexical:
.PP
.Vb 1
\&    my $pack::var;      # ERROR!  Illegal syntax
.Ve
.PP
In fact, a dynamic variable (also known as package or global variables)
are still accessible using the fully qualified \f(CW\*(C`::\*(C'\fR notation even while a
lexical of the same name is also visible:
.PP
.Vb 4
\&    package main;
\&    local $x = 10;
\&    my    $x = 20;
\&    print "$x and $::x\en";
.Ve
.PP
That will print out \f(CW20\fR and \f(CW10\fR.
.PP
You may declare \f(CW\*(C`my\*(C'\fR variables at the outermost scope of a file
to hide any such identifiers from the world outside that file.  This
is similar in spirit to C's static variables when they are used at
the file level.  To do this with a subroutine requires the use of
a closure (an anonymous function that accesses enclosing lexicals).
If you want to create a private subroutine that cannot be called
from outside that block, it can declare a lexical variable containing
an anonymous sub reference:
.PP
.Vb 3
\&    my $secret_version = \*(Aq1.001\-beta\*(Aq;
\&    my $secret_sub = sub { print $secret_version };
\&    &$secret_sub();
.Ve
.PP
As long as the reference is never returned by any function within the
module, no outside module can see the subroutine, because its name is not in
any package's symbol table.  Remember that it's not \fI\s-1REALLY\s0\fR called
\&\f(CW$some_pack::secret_version\fR or anything; it's just \f(CW$secret_version\fR,
unqualified and unqualifiable.
.PP
This does not work with object methods, however; all object methods
have to be in the symbol table of some package to be found.  See
\&\*(L"Function Templates\*(R" in perlref for something of a work-around to
this.
.Sh "Persistent Private Variables"
.IX Xref "state state variable static variable, persistent variable, static closure"
.IX Subsection "Persistent Private Variables"
There are two ways to build persistent private variables in Perl 5.10.
First, you can simply use the \f(CW\*(C`state\*(C'\fR feature. Or, you can use closures,
if you want to stay compatible with releases older than 5.10.
.PP
\fIPersistent variables via \fIstate()\fI\fR
.IX Subsection "Persistent variables via state()"
.PP
Beginning with perl 5.9.4, you can declare variables with the \f(CW\*(C`state\*(C'\fR
keyword in place of \f(CW\*(C`my\*(C'\fR. For that to work, though, you must have
enabled that feature beforehand, either by using the \f(CW\*(C`feature\*(C'\fR pragma, or
by using \f(CW\*(C`\-E\*(C'\fR on one-liners. (see feature)
.PP
For example, the following code maintains a private counter, incremented
each time the \fIgimme_another()\fR function is called:
.PP
.Vb 2
\&    use feature \*(Aqstate\*(Aq;
\&    sub gimme_another { state $x; return ++$x }
.Ve
.PP
Also, since \f(CW$x\fR is lexical, it can't be reached or modified by any Perl
code outside.
.PP
When combined with variable declaration, simple scalar assignment to \f(CW\*(C`state\*(C'\fR
variables (as in \f(CW\*(C`state $x = 42\*(C'\fR) is executed only the first time.  When such
statements are evaluated subsequent times, the assignment is ignored.  The
behavior of this sort of assignment to non-scalar variables is undefined.
.PP
\fIPersistent variables with closures\fR
.IX Subsection "Persistent variables with closures"
.PP
Just because a lexical variable is lexically (also called statically)
scoped to its enclosing block, \f(CW\*(C`eval\*(C'\fR, or \f(CW\*(C`do\*(C'\fR \s-1FILE\s0, this doesn't mean that
within a function it works like a C static.  It normally works more
like a C auto, but with implicit garbage collection.
.PP
Unlike local variables in C or \*(C+, Perl's lexical variables don't
necessarily get recycled just because their scope has exited.
If something more permanent is still aware of the lexical, it will
stick around.  So long as something else references a lexical, that
lexical won't be freed\*(--which is as it should be.  You wouldn't want
memory being free until you were done using it, or kept around once you
were done.  Automatic garbage collection takes care of this for you.
.PP
This means that you can pass back or save away references to lexical
variables, whereas to return a pointer to a C auto is a grave error.
It also gives us a way to simulate C's function statics.  Here's a
mechanism for giving a function private variables with both lexical
scoping and a static lifetime.  If you do want to create something like
C's static variables, just enclose the whole function in an extra block,
and put the static variable outside the function but in the block.
.PP