perlref.1

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

address.  See \*(L"ref\*(R" in perlfunc for details and examples of its use.
.IX Xref "reference, string context"
.PP
The \fIbless()\fR operator may be used to associate the object a reference
points to with a package functioning as an object class.  See perlobj.
.PP
A typeglob may be dereferenced the same way a reference can, because
the dereference syntax always indicates the type of reference desired.
So \f(CW\*(C`${*foo}\*(C'\fR and \f(CW\*(C`${\e$foo}\*(C'\fR both indicate the same scalar variable.
.PP
Here's a trick for interpolating a subroutine call into a string:
.PP
.Vb 1
\&    print "My sub returned @{[mysub(1,2,3)]} that time.\en";
.Ve
.PP
The way it works is that when the \f(CW\*(C`@{...}\*(C'\fR 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 \f(CW\*(C`mysub(1,2,3)\*(C'\fR.  So
the whole block returns a reference to an array, which is then
dereferenced by \f(CW\*(C`@{...}\*(C'\fR and stuck into the double-quoted string. This
chicanery is also useful for arbitrary expressions:
.PP
.Vb 1
\&    print "That yields @{[$n + 5]} widgets\en";
.Ve
.PP
Similarly, an expression that returns a reference to a scalar can be
dereferenced via \f(CW\*(C`${...}\*(C'\fR. Thus, the above expression may be written
as:
.PP
.Vb 1
\&    print "That yields ${\e($n + 5)} widgets\en";
.Ve
.Sh "Symbolic references"
.IX Xref "reference, symbolic reference, soft symbolic reference soft reference"
.IX Subsection "Symbolic references"
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 \fIisn't\fR 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 \fIname\fR
of a variable, rather than a direct link to a (possibly) anonymous
value.
.PP
People frequently expect it to work like this.  So it does.
.PP
.Vb 9
\&    $name = "foo";
\&    $$name = 1;                 # Sets $foo
\&    ${$name} = 2;               # Sets $foo
\&    ${$name x 2} = 3;           # Sets $foofoo
\&    $name\->[0] = 4;             # Sets $foo[0]
\&    @$name = ();                # Clears @foo
\&    &$name();                   # Calls &foo() (as in Perl 4)
\&    $pack = "THAT";
\&    ${"${pack}::$name"} = 5;    # Sets $THAT::foo without eval
.Ve
.PP
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
.PP
.Vb 1
\&    use strict \*(Aqrefs\*(Aq;
.Ve
.PP
and then only hard references will be allowed for the rest of the enclosing
block.  An inner block may countermand that with
.PP
.Vb 1
\&    no strict \*(Aqrefs\*(Aq;
.Ve
.PP
Only package variables (globals, even if localized) are visible to
symbolic references.  Lexical variables (declared with \fImy()\fR) aren't in
a symbol table, and thus are invisible to this mechanism.  For example:
.PP
.Vb 6
\&    local $value = 10;
\&    $ref = "value";
\&    {
\&        my $value = 20;
\&        print $$ref;
\&    }
.Ve
.PP
This will still print 10, not 20.  Remember that \fIlocal()\fR affects package
variables, which are all \*(L"global\*(R" to the package.
.Sh "Not-so-symbolic references"
.IX Subsection "Not-so-symbolic references"
A new feature contributing to readability in perl version 5.001 is that the
brackets around a symbolic reference behave more like quotes, just as they
always have within a string.  That is,
.PP
.Vb 2
\&    $push = "pop on ";
\&    print "${push}over";
.Ve
.PP
has always meant to print \*(L"pop on over\*(R", even though push is
a reserved word.  This has been generalized to work the same outside
of quotes, so that
.PP
.Vb 1
\&    print ${push} . "over";
.Ve
.PP
and even
.PP
.Vb 1
\&    print ${ push } . "over";
.Ve
.PP
will have the same effect.  (This would have been a syntax error in
Perl 5.000, though Perl 4 allowed it in the spaceless form.)  This
construct is \fInot\fR considered to be a symbolic reference when you're
using strict refs:
.PP
.Vb 3
\&    use strict \*(Aqrefs\*(Aq;
\&    ${ bareword };      # Okay, means $bareword.
\&    ${ "bareword" };    # Error, symbolic reference.
.Ve
.PP
Similarly, because of all the subscripting that is done using single
words, we've applied the same rule to any bareword that is used for
subscripting a hash.  So now, instead of writing
.PP
.Vb 1
\&    $array{ "aaa" }{ "bbb" }{ "ccc" }
.Ve
.PP
you can write just
.PP
.Vb 1
\&    $array{ aaa }{ bbb }{ ccc }
.Ve
.PP
and not worry about whether the subscripts are reserved words.  In the
rare event that you do wish to do something like
.PP
.Vb 1
\&    $array{ shift }
.Ve
.PP
you can force interpretation as a reserved word by adding anything that
makes it more than a bareword:
.PP
.Vb 3
\&    $array{ shift() }
\&    $array{ +shift }
\&    $array{ shift @_ }
.Ve
.PP
The \f(CW\*(C`use warnings\*(C'\fR pragma or the \fB\-w\fR 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.
.Sh "Pseudo-hashes: Using an array as a hash"
.IX Xref "pseudo-hash pseudo hash pseudohash"
.IX Subsection "Pseudo-hashes: Using an array as a hash"
Pseudo-hashes have been removed from Perl.  The 'fields' pragma
remains available.
.Sh "Function Templates"
.IX Xref "scope, lexical closure lexical lexical scope subroutine, nested sub, nested subroutine, local sub, local"
.IX Subsection "Function Templates"
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.
.PP
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 \s-1HTML\s0 font changes for the various colors:
.PP
.Vb 1
\&    print "Be ", red("careful"), "with that ", green("light");
.Ve
.PP
The \fIred()\fR and \fIgreen()\fR 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.
.PP
.Vb 5
\&    @colors = qw(red blue green yellow orange purple violet);
\&    for my $name (@colors) {
\&        no strict \*(Aqrefs\*(Aq;       # allow symbol table manipulation
\&        *$name = *{uc $name} = sub { "<FONT COLOR=\*(Aq$name\*(Aq>@_</FONT>" };
\&    }
.Ve
.PP
Now all those different functions appear to exist independently.  You can
call \fIred()\fR, \s-1\fIRED\s0()\fR, \fIblue()\fR, \s-1\fIBLUE\s0()\fR, \fIgreen()\fR, 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 \f(CW\*(C`my\*(C'\fR on the loop iteration variable.
.PP
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:
.PP
.Vb 1
\&    *$name = sub ($) { "<FONT COLOR=\*(Aq$name\*(Aq>$_[0]</FONT>" };
.Ve
.PP
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 \s-1BEGIN\s0 block, forcing it
to occur during compilation.
.PP
Access to lexicals that change over time\*(--like those in the \f(CW\*(C`for\*(C'\fR 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.
.PP
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.
.PP
Anonymous subroutines get to capture each time you execute the \f(CW\*(C`sub\*(C'\fR
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 \*(L"will not stay
shared\*(R" due to the reasons explained above. 
For example, this won't work:
.PP
.Vb 5
\&    sub outer {
\&        my $x = $_[0] + 35;
\&        sub inner { return $x * 19 }   # WRONG
\&        return $x + inner();
\&    }
.Ve
.PP
A work-around is the following:
.PP
.Vb 5
\&    sub outer {
\&        my $x = $_[0] + 35;
\&        local *inner = sub { return $x * 19 };
\&        return $x + inner();
\&    }
.Ve
.PP
Now \fIinner()\fR can only be called from within \fIouter()\fR, because of the
temporary assignments of the anonymous subroutine. But when it does,
it has normal access to the lexical variable \f(CW$x\fR from the scope of
\&\fIouter()\fR at the time outer is invoked.
.PP
This has the interesting effect of creating a function local to another
function, something not normally supported in Perl.
.SH "WARNING"
.IX Xref "reference, string context reference, use as hash key"
.IX Header "WARNING"
You may not (usefully) use a reference as the key to a hash.  It will be
converted into a string:
.PP
.Vb 1
\&    $x{ \e$a } = $a;
.Ve
.PP
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
.PP
.Vb 2
\&    $r = \e@a;
\&    $x{ $r } = $r;
.Ve
.PP
And then at least you can use the \fIvalues()\fR, which will be
real refs, instead of the \fIkeys()\fR, which won't.
.PP
The standard Tie::RefHash module provides a convenient workaround to this.
.SH "SEE ALSO"
.IX Header "SEE ALSO"
Besides the obvious documents, source code can be instructive.
Some pathological examples of the use of references can be found
in the \fIt/op/ref.t\fR regression test in the Perl source directory.
.PP
See also perldsc and perllol for how to use references to create
complex data structures, and perltoot, perlobj, and perlbot
for how to use them to create objects.