perlfaq7.1

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

just such situations as the one above.
.PP
Another operator with surprising precedence is exponentiation.  It
binds more tightly even than unary minus, making \f(CW\*(C`\-2**2\*(C'\fR product a
negative not a positive four.  It is also right-associating, meaning
that \f(CW\*(C`2**3**2\*(C'\fR is two raised to the ninth power, not eight squared.
.PP
Although it has the same precedence as in C, Perl's \f(CW\*(C`?:\*(C'\fR operator
produces an lvalue.  This assigns \f(CW$x\fR to either \f(CW$a\fR or \f(CW$b\fR, depending
on the trueness of \f(CW$maybe:\fR
.PP
.Vb 1
\&        ($maybe ? $a : $b) = $x;
.Ve
.Sh "How do I declare/create a structure?"
.IX Subsection "How do I declare/create a structure?"
In general, you don't \*(L"declare\*(R" a structure.  Just use a (probably
anonymous) hash reference.  See perlref and perldsc for details.
Here's an example:
.PP
.Vb 3
\&        $person = {};                   # new anonymous hash
\&        $person\->{AGE}  = 24;           # set field AGE to 24
\&        $person\->{NAME} = "Nat";        # set field NAME to "Nat"
.Ve
.PP
If you're looking for something a bit more rigorous, try perltoot.
.Sh "How do I create a module?"
.IX Subsection "How do I create a module?"
(contributed by brian d foy)
.PP
perlmod, perlmodlib, perlmodstyle explain modules
in all the gory details. perlnewmod gives a brief
overview of the process along with a couple of suggestions
about style.
.PP
If you need to include C code or C library interfaces in
your module, you'll need h2xs.  h2xs will create the module
distribution structure and the initial interface files
you'll need.  perlxs and perlxstut explain the details.
.PP
If you don't need to use C code, other tools such as
ExtUtils::ModuleMaker and Module::Starter, can help you
create a skeleton module distribution.
.PP
You may also want to see Sam Tregar's \*(L"Writing Perl Modules
for \s-1CPAN\s0\*(R" ( http://apress.com/book/bookDisplay.html?bID=14 )
which is the best hands-on guide to creating module
distributions.
.Sh "How do I adopt or take over a module already on \s-1CPAN\s0?"
.IX Subsection "How do I adopt or take over a module already on CPAN?"
(contributed by brian d foy)
.PP
The easiest way to take over a module is to have the current
module maintainer either make you a co-maintainer or transfer
the module to you.
.PP
If you can't reach the author for some reason (e.g. email bounces),
the \s-1PAUSE\s0 admins at [e-mail] can help. The \s-1PAUSE\s0 admins
treat each case individually.
.IP "\(bu" 4
Get a login for the Perl Authors Upload Server (\s-1PAUSE\s0) if you don't
already have one: http://pause.perl.org
.IP "\(bu" 4
Write to [e-mail] explaining what you did to contact the
current maintainer. The \s-1PAUSE\s0 admins will also try to reach the
maintainer.
.IP "\(bu" 4
Post a public message in a heavily trafficked site announcing your
intention to take over the module.
.IP "\(bu" 4
Wait a bit. The \s-1PAUSE\s0 admins don't want to act too quickly in case
the current maintainer is on holiday. If there's no response to 
private communication or the public post, a \s-1PAUSE\s0 admin can transfer
it to you.
.Sh "How do I create a class?"
.IX Subsection "How do I create a class?"
See perltoot for an introduction to classes and objects, as well as
perlobj and perlbot.
.Sh "How can I tell if a variable is tainted?"
.IX Subsection "How can I tell if a variable is tainted?"
You can use the \fItainted()\fR function of the Scalar::Util module, available
from \s-1CPAN\s0 (or included with Perl since release 5.8.0).
See also \*(L"Laundering and Detecting Tainted Data\*(R" in perlsec.
.Sh "What's a closure?"
.IX Subsection "What's a closure?"
Closures are documented in perlref.
.PP
\&\fIClosure\fR is a computer science term with a precise but
hard-to-explain meaning. Usually, closures are implemented in Perl as
anonymous subroutines with lasting references to lexical variables
outside their own scopes. These lexicals magically refer to the
variables that were around when the subroutine was defined (deep 
binding).
.PP
Closures are most often used in programming languages where you can
have the return value of a function be itself a function, as you can
in Perl. Note that some languages provide anonymous functions but are
not capable of providing proper closures: the Python language, for
example.  For more information on closures, check out any textbook on
functional programming.  Scheme is a language that not only supports
but encourages closures.
.PP
Here's a classic non-closure function-generating function:
.PP
.Vb 3
\&        sub add_function_generator {
\&                return sub { shift() + shift() };
\&                }
\&
\&        $add_sub = add_function_generator();
\&        $sum = $add_sub\->(4,5);                # $sum is 9 now.
.Ve
.PP
The anonymous subroutine returned by \fIadd_function_generator()\fR isn't
technically a closure because it refers to no lexicals outside its own
scope.  Using a closure gives you a \fIfunction template\fR with some
customization slots left out to be filled later.
.PP
Contrast this with the following \fImake_adder()\fR function, in which the
returned anonymous function contains a reference to a lexical variable
outside the scope of that function itself.  Such a reference requires
that Perl return a proper closure, thus locking in for all time the
value that the lexical had when the function was created.
.PP
.Vb 4
\&        sub make_adder {
\&                my $addpiece = shift;
\&                return sub { shift() + $addpiece };
\&        }
\&        
\&        $f1 = make_adder(20);
\&        $f2 = make_adder(555);
.Ve
.PP
Now \f(CW\*(C`&$f1($n)\*(C'\fR is always 20 plus whatever \f(CW$n\fR you pass in, whereas
\&\f(CW\*(C`&$f2($n)\*(C'\fR is always 555 plus whatever \f(CW$n\fR you pass in.  The \f(CW$addpiece\fR
in the closure sticks around.
.PP
Closures are often used for less esoteric purposes.  For example, when
you want to pass in a bit of code into a function:
.PP
.Vb 2
\&        my $line;
\&        timeout( 30, sub { $line = <STDIN> } );
.Ve
.PP
If the code to execute had been passed in as a string,
\&\f(CW\*(Aq$line = <STDIN>\*(Aq\fR, there would have been no way for the
hypothetical \fItimeout()\fR function to access the lexical variable
\&\f(CW$line\fR back in its caller's scope.
.PP
Another use for a closure is to make a variable \fIprivate\fR to a
named subroutine, e.g. a counter that gets initialized at creation
time of the sub and can only be modified from within the sub.
This is sometimes used with a \s-1BEGIN\s0 block in package files to make
sure a variable doesn't get meddled with during the lifetime of the
package:
.PP
.Vb 4
\&        BEGIN {
\&                my $id = 0;
\&                sub next_id { ++$id }
\&        }
.Ve
.PP
This is discussed in more detail in perlsub, see the entry on
\&\fIPersistent Private Variables\fR.
.Sh "What is variable suicide and how can I prevent it?"
.IX Subsection "What is variable suicide and how can I prevent it?"
This problem was fixed in perl 5.004_05, so preventing it means upgrading
your version of perl. ;)
.PP
Variable suicide is when you (temporarily or permanently) lose the value
of a variable.  It is caused by scoping through \fImy()\fR and \fIlocal()\fR
interacting with either closures or aliased \fIforeach()\fR iterator variables
and subroutine arguments.  It used to be easy to inadvertently lose a
variable's value this way, but now it's much harder.  Take this code:
.PP
.Vb 4
\&        my $f = \*(Aqfoo\*(Aq;
\&        sub T {
\&                while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\en" }
\&                }
\&
\&        T;
\&        print "Finally $f\en";
.Ve
.PP
If you are experiencing variable suicide, that \f(CW\*(C`my $f\*(C'\fR in the subroutine
doesn't pick up a fresh copy of the \f(CW$f\fR whose value is <foo>. The output
shows that inside the subroutine the value of \f(CW$f\fR leaks through when it
shouldn't, as in this output:
.PP
.Vb 4
\&        foobar
\&        foobarbar
\&        foobarbarbar
\&        Finally foo
.Ve
.PP
The \f(CW$f\fR that has \*(L"bar\*(R" added to it three times should be a new \f(CW$f\fR
\&\f(CW\*(C`my $f\*(C'\fR should create a new lexical variable each time through the loop.
The expected output is:
.PP
.Vb 4
\&        foobar
\&        foobar
\&        foobar
\&        Finally foo
.Ve
.Sh "How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?"
.IX Subsection "How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?"
With the exception of regexes, you need to pass references to these
objects.  See \*(L"Pass by Reference\*(R" in perlsub for this particular
question, and perlref for information on references.
.PP
See \*(L"Passing Regexes\*(R", later in perlfaq7, for information on
passing regular expressions.
.IP "Passing Variables and Functions" 4
.IX Item "Passing Variables and Functions"
Regular variables and functions are quite easy to pass: just pass in a
reference to an existing or anonymous variable or function:
.Sp
.Vb 1
\&        func( \e$some_scalar );
\&
\&        func( \e@some_array  );
\&        func( [ 1 .. 10 ]   );
\&
\&        func( \e%some_hash   );
\&        func( { this => 10, that => 20 }   );
\&
\&        func( \e&some_func   );
\&        func( sub { $_[0] ** $_[1] }   );
.Ve
.IP "Passing Filehandles" 4
.IX Item "Passing Filehandles"
As of Perl 5.6, you can represent filehandles with scalar variables
which you treat as any other scalar.
.Sp
.Vb 2
\&        open my $fh, $filename or die "Cannot open $filename! $!";
\&        func( $fh );
\&
\&        sub func {
\&                my $passed_fh = shift;
\&
\&                my $line = <$passed_fh>;
\&                }
.Ve
.Sp
Before Perl 5.6, you had to use the \f(CW*FH\fR or \f(CW\*(C`\e*FH\*(C'\fR notations.
These are \*(L"typeglobs\*(R"\-\-see \*(L"Typeglobs and Filehandles\*(R" in perldata
and especially \*(L"Pass by Reference\*(R" in perlsub for more information.
.IP "Passing Regexes" 4
.IX Item "Passing Regexes"
To pass regexes around, you'll need to be using a release of Perl
sufficiently recent as to support the \f(CW\*(C`qr//\*(C'\fR construct, pass around
strings and use an exception-trapping eval, or else be very, very clever.
.Sp
Here's an example of how to pass in a string to be regex compared
using \f(CW\*(C`qr//\*(C'\fR:
.Sp
.Vb 6
\&        sub compare($$) {
\&                my ($val1, $regex) = @_;
\&                my $retval = $val1 =~ /$regex/;
\&        return $retval;
\&        }
\&        $match = compare("old McDonald", qr/d.*D/i);
.Ve
.Sp
Notice how \f(CW\*(C`qr//\*(C'\fR allows flags at the end.  That pattern was compiled
at compile time, although it was executed later.  The nifty \f(CW\*(C`qr//\*(C'\fR
notation wasn't introduced until the 5.005 release.  Before that, you
had to approach this problem much less intuitively.  For example, here
it is again if you don't have \f(CW\*(C`qr//\*(C'\fR:
.Sp
.Vb 6
\&        sub compare($$) {
\&                my ($val1, $regex) = @_;
\&                my $retval = eval { $val1 =~ /$regex/ };
\&        die if $@;
\&        return $retval;
\&        }
\&
\&        $match = compare("old McDonald", q/($?i)d.*D/);
.Ve
.Sp
Make sure you never say something like this:
.Sp
.Vb 1
\&        return eval "\e$val =~ /$regex/";   # WRONG
.Ve
.Sp
or someone can sneak shell escapes into the regex due to the double
interpolation of the eval and the double-quoted string.  For example:
.Sp
.Vb 1
\&        $pattern_of_evil = \*(Aqdanger ${ system("rm \-rf * &") } danger\*(Aq;
\&
\&        eval "\e$string =~ /$pattern_of_evil/";
.Ve
.Sp
Those preferring to be very, very clever might see the O'Reilly book,
\&\fIMastering Regular Expressions\fR, by Jeffrey Friedl.  Page 273's
\&\fIBuild_MatchMany_Function()\fR is particularly interesting.  A complete