perlmod.1

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

\&    *dick = \e$richard;
.Ve
.PP
Which makes \f(CW$richard\fR and \f(CW$dick\fR the same variable, but leaves
\&\f(CW@richard\fR and \f(CW@dick\fR as separate arrays.  Tricky, eh?
.PP
There is one subtle difference between the following statements:
.PP
.Vb 2
\&    *foo = *bar;
\&    *foo = \e$bar;
.Ve
.PP
\&\f(CW\*(C`*foo = *bar\*(C'\fR makes the typeglobs themselves synonymous while
\&\f(CW\*(C`*foo = \e$bar\*(C'\fR makes the \s-1SCALAR\s0 portions of two distinct typeglobs
refer to the same scalar value. This means that the following code:
.PP
.Vb 2
\&    $bar = 1;
\&    *foo = \e$bar;       # Make $foo an alias for $bar
\&
\&    {
\&        local $bar = 2; # Restrict changes to block
\&        print $foo;     # Prints \*(Aq1\*(Aq!
\&    }
.Ve
.PP
Would print '1', because \f(CW$foo\fR holds a reference to the \fIoriginal\fR
\&\f(CW$bar\fR \*(-- the one that was stuffed away by \f(CW\*(C`local()\*(C'\fR and which will be
restored when the block ends. Because variables are accessed through the
typeglob, you can use \f(CW\*(C`*foo = *bar\*(C'\fR to create an alias which can be
localized. (But be aware that this means you can't have a separate
\&\f(CW@foo\fR and \f(CW@bar\fR, etc.)
.PP
What makes all of this important is that the Exporter module uses glob
aliasing as the import/export mechanism. Whether or not you can properly
localize a variable that has been exported from a module depends on how
it was exported:
.PP
.Vb 2
\&    @EXPORT = qw($FOO); # Usual form, can\*(Aqt be localized
\&    @EXPORT = qw(*FOO); # Can be localized
.Ve
.PP
You can work around the first case by using the fully qualified name
(\f(CW$Package::FOO\fR) where you need a local value, or by overriding it
by saying \f(CW\*(C`*FOO = *Package::FOO\*(C'\fR in your script.
.PP
The \f(CW\*(C`*x = \e$y\*(C'\fR mechanism may be used to pass and return cheap references
into or from subroutines if you don't want to copy the whole
thing.  It only works when assigning to dynamic variables, not
lexicals.
.PP
.Vb 9
\&    %some_hash = ();                    # can\*(Aqt be my()
\&    *some_hash = fn( \e%another_hash );
\&    sub fn {
\&        local *hashsym = shift;
\&        # now use %hashsym normally, and you
\&        # will affect the caller\*(Aqs %another_hash
\&        my %nhash = (); # do what you want
\&        return \e%nhash;
\&    }
.Ve
.PP
On return, the reference will overwrite the hash slot in the
symbol table specified by the *some_hash typeglob.  This
is a somewhat tricky way of passing around references cheaply
when you don't want to have to remember to dereference variables
explicitly.
.PP
Another use of symbol tables is for making \*(L"constant\*(R" scalars.
.IX Xref "constant scalar, constant"
.PP
.Vb 1
\&    *PI = \e3.14159265358979;
.Ve
.PP
Now you cannot alter \f(CW$PI\fR, which is probably a good thing all in all.
This isn't the same as a constant subroutine, which is subject to
optimization at compile-time.  A constant subroutine is one prototyped
to take no arguments and to return a constant expression.  See
perlsub for details on these.  The \f(CW\*(C`use constant\*(C'\fR pragma is a
convenient shorthand for these.
.PP
You can say \f(CW*foo{PACKAGE}\fR and \f(CW*foo{NAME}\fR to find out what name and
package the *foo symbol table entry comes from.  This may be useful
in a subroutine that gets passed typeglobs as arguments:
.PP
.Vb 6
\&    sub identify_typeglob {
\&        my $glob = shift;
\&        print \*(AqYou gave me \*(Aq, *{$glob}{PACKAGE}, \*(Aq::\*(Aq, *{$glob}{NAME}, "\en";
\&    }
\&    identify_typeglob *foo;
\&    identify_typeglob *bar::baz;
.Ve
.PP
This prints
.PP
.Vb 2
\&    You gave me main::foo
\&    You gave me bar::baz
.Ve
.PP
The \f(CW*foo{THING}\fR notation can also be used to obtain references to the
individual elements of *foo.  See perlref.
.PP
Subroutine definitions (and declarations, for that matter) need
not necessarily be situated in the package whose symbol table they
occupy.  You can define a subroutine outside its package by
explicitly qualifying the name of the subroutine:
.PP
.Vb 2
\&    package main;
\&    sub Some_package::foo { ... }   # &foo defined in Some_package
.Ve
.PP
This is just a shorthand for a typeglob assignment at compile time:
.PP
.Vb 1
\&    BEGIN { *Some_package::foo = sub { ... } }
.Ve
.PP
and is \fInot\fR the same as writing:
.PP
.Vb 4
\&    {
\&        package Some_package;
\&        sub foo { ... }
\&    }
.Ve
.PP
In the first two versions, the body of the subroutine is
lexically in the main package, \fInot\fR in Some_package. So
something like this:
.PP
.Vb 1
\&    package main;
\&
\&    $Some_package::name = "fred";
\&    $main::name = "barney";
\&
\&    sub Some_package::foo {
\&        print "in ", _\|_PACKAGE_\|_, ": \e$name is \*(Aq$name\*(Aq\en";
\&    }
\&
\&    Some_package::foo();
.Ve
.PP
prints:
.PP
.Vb 1
\&    in main: $name is \*(Aqbarney\*(Aq
.Ve
.PP
rather than:
.PP
.Vb 1
\&    in Some_package: $name is \*(Aqfred\*(Aq
.Ve
.PP
This also has implications for the use of the \s-1SUPER::\s0 qualifier
(see perlobj).
.Sh "\s-1BEGIN\s0, \s-1UNITCHECK\s0, \s-1CHECK\s0, \s-1INIT\s0 and \s-1END\s0"
.IX Xref "BEGIN UNITCHECK CHECK INIT END"
.IX Subsection "BEGIN, UNITCHECK, CHECK, INIT and END"
Five specially named code blocks are executed at the beginning and at
the end of a running Perl program.  These are 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 blocks.
.PP
These code blocks can be prefixed with \f(CW\*(C`sub\*(C'\fR to give the appearance of a
subroutine (although this is not considered good style).  One should note
that these code blocks don't really exist as named subroutines (despite
their appearance). The thing that gives this away is the fact that you can
have \fBmore than one\fR of these code blocks in a program, and they will get
\&\fBall\fR executed at the appropriate moment.  So you can't execute any of
these code blocks by name.
.PP
A \f(CW\*(C`BEGIN\*(C'\fR code block is executed as soon as possible, that is, the moment
it is completely defined, even before the rest of the containing file (or
string) is parsed.  You may have multiple \f(CW\*(C`BEGIN\*(C'\fR blocks within a file (or
eval'ed string) \*(-- they will execute in order of definition.  Because a \f(CW\*(C`BEGIN\*(C'\fR
code block executes immediately, it can pull in definitions of subroutines
and such from other files in time to be visible to the rest of the compile
and run time.  Once a \f(CW\*(C`BEGIN\*(C'\fR has run, it is immediately undefined and any
code it used is returned to Perl's memory pool.
.PP
It should be noted that \f(CW\*(C`BEGIN\*(C'\fR and \f(CW\*(C`UNITCHECK\*(C'\fR code blocks \fBare\fR
executed inside string \f(CW\*(C`eval()\*(C'\fR's.  The \f(CW\*(C`CHECK\*(C'\fR and \f(CW\*(C`INIT\*(C'\fR code
blocks are \fBnot\fR executed inside a string eval, which e.g. can be a
problem in a mod_perl environment.
.PP
An \f(CW\*(C`END\*(C'\fR code block is executed as late as possible, that is, after
perl has finished running the program and just before the interpreter
is being exited, even if it is exiting as a result of a \fIdie()\fR function.
(But not if it's morphing into another program via \f(CW\*(C`exec\*(C'\fR, or
being blown out of the water by a signal\*(--you have to trap that yourself
(if you can).)  You may have multiple \f(CW\*(C`END\*(C'\fR blocks within a file\*(--they
will execute in reverse order of definition; that is: last in, first
out (\s-1LIFO\s0).  \f(CW\*(C`END\*(C'\fR blocks are not executed when you run perl with the
\&\f(CW\*(C`\-c\*(C'\fR switch, or if compilation fails.
.PP
Note that \f(CW\*(C`END\*(C'\fR code blocks are \fBnot\fR executed at the end of a string
\&\f(CW\*(C`eval()\*(C'\fR: if any \f(CW\*(C`END\*(C'\fR code blocks are created in a string \f(CW\*(C`eval()\*(C'\fR,
they will be executed just as any other \f(CW\*(C`END\*(C'\fR code block of that package
in \s-1LIFO\s0 order just before the interpreter is being exited.
.PP
Inside an \f(CW\*(C`END\*(C'\fR code block, \f(CW$?\fR contains the value that the program is
going to pass to \f(CW\*(C`exit()\*(C'\fR.  You can modify \f(CW$?\fR to change the exit
value of the program.  Beware of changing \f(CW$?\fR by accident (e.g. by
running something via \f(CW\*(C`system\*(C'\fR).
.IX Xref "$?"
.PP
\&\f(CW\*(C`UNITCHECK\*(C'\fR, \f(CW\*(C`CHECK\*(C'\fR and \f(CW\*(C`INIT\*(C'\fR code blocks are useful to catch the
transition between the compilation phase and the execution phase of
the main program.
.PP
\&\f(CW\*(C`UNITCHECK\*(C'\fR blocks are run just after the unit which defined them has
been compiled.  The main program file and each module it loads are
compilation units, as are string \f(CW\*(C`eval\*(C'\fRs, code compiled using the
\&\f(CW\*(C`(?{ })\*(C'\fR construct in a regex, calls to \f(CW\*(C`do FILE\*(C'\fR, \f(CW\*(C`require FILE\*(C'\fR,
and code after the \f(CW\*(C`\-e\*(C'\fR switch on the command line.
.PP
\&\f(CW\*(C`CHECK\*(C'\fR code blocks are run just after the \fBinitial\fR Perl compile phase ends
and before the run time begins, in \s-1LIFO\s0 order.  \f(CW\*(C`CHECK\*(C'\fR code blocks are used
in the Perl compiler suite to save the compiled state of the program.
.PP
\&\f(CW\*(C`INIT\*(C'\fR blocks are run just before the Perl runtime begins execution, in
\&\*(L"first in, first out\*(R" (\s-1FIFO\s0) order.
.PP
When you use the \fB\-n\fR and \fB\-p\fR switches to Perl, \f(CW\*(C`BEGIN\*(C'\fR and
\&\f(CW\*(C`END\*(C'\fR work just as they do in \fBawk\fR, as a degenerate case.
Both \f(CW\*(C`BEGIN\*(C'\fR and \f(CW\*(C`CHECK\*(C'\fR blocks are run when you use the \fB\-c\fR
switch for a compile-only syntax check, although your main code
is not.
.PP
The \fBbegincheck\fR program makes it all clear, eventually:
.PP
.Vb 1
\&  #!/usr/bin/perl
\&
\&  # begincheck
\&
\&  print         "10. Ordinary code runs at runtime.\en";
\&
\&  END { print   "16.   So this is the end of the tale.\en" }
\&  INIT { print  " 7. INIT blocks run FIFO just before runtime.\en" }
\&  UNITCHECK {
\&    print       " 4.   And therefore before any CHECK blocks.\en"
\&  }
\&  CHECK { print " 6.   So this is the sixth line.\en" }
\&
\&  print         "11.   It runs in order, of course.\en";
\&
\&  BEGIN { print " 1. BEGIN blocks run FIFO during compilation.\en" }
\&  END { print   "15.   Read perlmod for the rest of the story.\en" }
\&  CHECK { print " 5. CHECK blocks run LIFO after all compilation.\en" }
\&  INIT { print  " 8.   Run this again, using Perl\*(Aqs \-c switch.\en" }
\&
\&  print         "12.   This is anti\-obfuscated code.\en";
\&
\&  END { print   "14. END blocks run LIFO at quitting time.\en" }