perlfaq7.1

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

citation of this book is given in perlfaq2.
.IP "Passing Methods" 4
.IX Item "Passing Methods"
To pass an object method into a subroutine, you can do this:
.Sp
.Vb 7
\&        call_a_lot(10, $some_obj, "methname")
\&        sub call_a_lot {
\&                my ($count, $widget, $trick) = @_;
\&                for (my $i = 0; $i < $count; $i++) {
\&                        $widget\->$trick();
\&                }
\&        }
.Ve
.Sp
Or, you can use a closure to bundle up the object, its
method call, and arguments:
.Sp
.Vb 6
\&        my $whatnot =  sub { $some_obj\->obfuscate(@args) };
\&        func($whatnot);
\&        sub func {
\&                my $code = shift;
\&                &$code();
\&        }
.Ve
.Sp
You could also investigate the \fIcan()\fR method in the \s-1UNIVERSAL\s0 class
(part of the standard perl distribution).
.Sh "How do I create a static variable?"
.IX Subsection "How do I create a static variable?"
(contributed by brian d foy)
.PP
Perl doesn't have \*(L"static\*(R" variables, which can only be accessed from
the function in which they are declared. You can get the same effect
with lexical variables, though.
.PP
You can fake a static variable by using a lexical variable which goes
out of scope. In this example, you define the subroutine \f(CW\*(C`counter\*(C'\fR, and
it uses the lexical variable \f(CW$count\fR. Since you wrap this in a \s-1BEGIN\s0
block, \f(CW$count\fR is defined at compile-time, but also goes out of
scope at the end of the \s-1BEGIN\s0 block. The \s-1BEGIN\s0 block also ensures that
the subroutine and the value it uses is defined at compile-time so the
subroutine is ready to use just like any other subroutine, and you can
put this code in the same place as other subroutines in the program
text (i.e. at the end of the code, typically). The subroutine
\&\f(CW\*(C`counter\*(C'\fR still has a reference to the data, and is the only way you
can access the value (and each time you do, you increment the value).
The data in chunk of memory defined by \f(CW$count\fR is private to
\&\f(CW\*(C`counter\*(C'\fR.
.PP
.Vb 4
\&        BEGIN {
\&                my $count = 1;
\&                sub counter { $count++ }
\&        }
\&        
\&        my $start = counter();
\&        
\&        .... # code that calls counter();
\&        
\&        my $end = counter();
.Ve
.PP
In the previous example, you created a function-private variable
because only one function remembered its reference. You could define
multiple functions while the variable is in scope, and each function
can share the \*(L"private\*(R" variable. It's not really \*(L"static\*(R" because you
can access it outside the function while the lexical variable is in
scope, and even create references to it. In this example,
\&\f(CW\*(C`increment_count\*(C'\fR and \f(CW\*(C`return_count\*(C'\fR share the variable. One
function adds to the value and the other simply returns the value.
They can both access \f(CW$count\fR, and since it has gone out of scope,
there is no other way to access it.
.PP
.Vb 5
\&        BEGIN {
\&                my $count = 1;
\&                sub increment_count { $count++ }
\&                sub return_count    { $count }
\&        }
.Ve
.PP
To declare a file-private variable, you still use a lexical variable.
A file is also a scope, so a lexical variable defined in the file
cannot be seen from any other file.
.PP
See \*(L"Persistent Private Variables\*(R" in perlsub for more information.
The discussion of closures in perlref may help you even though we
did not use anonymous subroutines in this answer. See
\&\*(L"Persistent Private Variables\*(R" in perlsub for details.
.Sh "What's the difference between dynamic and lexical (static) scoping?  Between \fIlocal()\fP and \fImy()\fP?"
.IX Subsection "What's the difference between dynamic and lexical (static) scoping?  Between local() and my()?"
\&\f(CW\*(C`local($x)\*(C'\fR saves away the old value of the global variable \f(CW$x\fR
and assigns a new value for the duration of the subroutine \fIwhich is
visible in other functions called from that subroutine\fR.  This is done
at run-time, so is called dynamic scoping.  \fIlocal()\fR always affects global
variables, also called package variables or dynamic variables.
.PP
\&\f(CW\*(C`my($x)\*(C'\fR creates a new variable that is only visible in the current
subroutine.  This is done at compile-time, so it is called lexical or
static scoping.  \fImy()\fR always affects private variables, also called
lexical variables or (improperly) static(ly scoped) variables.
.PP
For instance:
.PP
.Vb 3
\&        sub visible {
\&                print "var has value $var\en";
\&                }
\&        
\&        sub dynamic {
\&                local $var = \*(Aqlocal\*(Aq;   # new temporary value for the still\-global
\&                visible();              #   variable called $var
\&                }
\&        
\&        sub lexical {
\&                my $var = \*(Aqprivate\*(Aq;    # new private variable, $var
\&                visible();              # (invisible outside of sub scope)
\&                }
\&        
\&        $var = \*(Aqglobal\*(Aq;
\&        
\&        visible();                      # prints global
\&        dynamic();                      # prints local
\&        lexical();                      # prints global
.Ve
.PP
Notice how at no point does the value \*(L"private\*(R" get printed.  That's
because \f(CW$var\fR only has that value within the block of the \fIlexical()\fR
function, and it is hidden from called subroutine.
.PP
In summary, \fIlocal()\fR doesn't make what you think of as private, local
variables.  It gives a global variable a temporary value.  \fImy()\fR is
what you're looking for if you want private variables.
.PP
See \*(L"Private Variables via \fImy()\fR\*(R" in perlsub and
\&\*(L"Temporary Values via \fIlocal()\fR\*(R" in perlsub for excruciating details.
.Sh "How can I access a dynamic variable while a similarly named lexical is in scope?"
.IX Subsection "How can I access a dynamic variable while a similarly named lexical is in scope?"
If you know your package, you can just mention it explicitly, as in
\&\f(CW$Some_Pack::var\fR. Note that the notation \f(CW$::var\fR is \fBnot\fR the dynamic \f(CW$var\fR
in the current package, but rather the one in the \*(L"main\*(R" package, as
though you had written \f(CW$main::var\fR.
.PP
.Vb 3
\&        use vars \*(Aq$var\*(Aq;
\&        local $var = "global";
\&        my    $var = "lexical";
\&
\&        print "lexical is $var\en";
\&        print "global  is $main::var\en";
.Ve
.PP
Alternatively you can use the compiler directive \fIour()\fR to bring a
dynamic variable into the current lexical scope.
.PP
.Vb 2
\&        require 5.006; # our() did not exist before 5.6
\&        use vars \*(Aq$var\*(Aq;
\&
\&        local $var = "global";
\&        my $var    = "lexical";
\&
\&        print "lexical is $var\en";
\&
\&        {
\&                our $var;
\&                print "global  is $var\en";
\&        }
.Ve
.Sh "What's the difference between deep and shallow binding?"
.IX Subsection "What's the difference between deep and shallow binding?"
In deep binding, lexical variables mentioned in anonymous subroutines
are the same ones that were in scope when the subroutine was created.
In shallow binding, they are whichever variables with the same names
happen to be in scope when the subroutine is called.  Perl always uses
deep binding of lexical variables (i.e., those created with \fImy()\fR).
However, dynamic variables (aka global, local, or package variables)
are effectively shallowly bound.  Consider this just one more reason
not to use them.  See the answer to \*(L"What's a closure?\*(R".
.ie n .Sh "Why doesn't ""my($foo) = <\s-1FILE\s0>;"" work right?"
.el .Sh "Why doesn't ``my($foo) = <\s-1FILE\s0>;'' work right?"
.IX Subsection "Why doesn't my($foo) = <FILE>; work right?"
\&\f(CW\*(C`my()\*(C'\fR and \f(CW\*(C`local()\*(C'\fR give list context to the right hand side
of \f(CW\*(C`=\*(C'\fR.  The <\s-1FH\s0> read operation, like so many of Perl's
functions and operators, can tell which context it was called in and
behaves appropriately.  In general, the \fIscalar()\fR function can help.
This function does nothing to the data itself (contrary to popular myth)
but rather tells its argument to behave in whatever its scalar fashion is.
If that function doesn't have a defined scalar behavior, this of course
doesn't help you (such as with \fIsort()\fR).
.PP
To enforce scalar context in this particular case, however, you need
merely omit the parentheses:
.PP
.Vb 3
\&        local($foo) = <FILE>;       # WRONG
\&        local($foo) = scalar(<FILE>);   # ok
\&        local $foo  = <FILE>;       # right
.Ve
.PP
You should probably be using lexical variables anyway, although the
issue is the same here:
.PP
.Vb 2
\&        my($foo) = <FILE>;      # WRONG
\&        my $foo  = <FILE>;      # right
.Ve
.Sh "How do I redefine a builtin function, operator, or method?"
.IX Subsection "How do I redefine a builtin function, operator, or method?"
Why do you want to do that? :\-)
.PP
If you want to override a predefined function, such as \fIopen()\fR,
then you'll have to import the new definition from a different
module.  See \*(L"Overriding Built-in Functions\*(R" in perlsub.  There's
also an example in \*(L"Class::Template\*(R" in perltoot.
.PP
If you want to overload a Perl operator, such as \f(CW\*(C`+\*(C'\fR or \f(CW\*(C`**\*(C'\fR,
then you'll want to use the \f(CW\*(C`use overload\*(C'\fR pragma, documented
in overload.
.PP
If you're talking about obscuring method calls in parent classes,
see \*(L"Overridden Methods\*(R" in perltoot.
.Sh "What's the difference between calling a function as &foo and \fIfoo()\fP?"
.IX Subsection "What's the difference between calling a function as &foo and foo()?"
When you call a function as \f(CW&foo\fR, you allow that function access to
your current \f(CW@_\fR values, and you bypass prototypes.
The function doesn't get an empty \f(CW@_\fR\-\-it gets yours!  While not
strictly speaking a bug (it's documented that way in perlsub), it
would be hard to consider this a feature in most cases.
.PP
When you call your function as \f(CW\*(C`&foo()\*(C'\fR, then you \fIdo\fR get a new \f(CW@_\fR,
but prototyping is still circumvented.
.PP
Normally, you want to call a function using \f(CW\*(C`foo()\*(C'\fR.  You may only
omit the parentheses if the function is already known to the compiler
because it already saw the definition (\f(CW\*(C`use\*(C'\fR but not \f(CW\*(C`require\*(C'\fR),
or via a forward reference or \f(CW\*(C`use subs\*(C'\fR declaration.  Even in this
case, you get a clean \f(CW@_\fR without any of the old values leaking through
where they don't belong.
.Sh "How do I create a switch or case statement?"
.IX Subsection "How do I create a switch or case statement?"
If one wants to use pure Perl and to be compatible with Perl versions
prior to 5.10, the general answer is to write a construct like this:
.PP
.Vb 6
\&        for ($variable_to_test) {
\&                if    (/pat1/)  { }     # do something
\&                elsif (/pat2/)  { }     # do something else
\&                elsif (/pat3/)  { }     # do something else
\&                else            { }     # default
\&                }
.Ve
.PP
Here's a simple example of a switch based on pattern matching,
lined up in a way to make it look more like a switch statement.
We'll do a multiway conditional based on the type of reference stored
in \f(CW$whatchamacallit:\fR
.PP
.Vb 1
\&    SWITCH: for (ref $whatchamacallit) {
\&
\&        /^$/            && die "not a reference";
\&
\&        /SCALAR/        && do {
\&                                print_scalar($$ref);
\&                                last SWITCH;
\&                        };
\&
\&        /ARRAY/         && do {
\&                                print_array(@$ref);
\&                                last SWITCH;
\&                        };
\&
\&        /HASH/          && do {
\&                                print_hash(%$ref);
\&                                last SWITCH;
\&                        };
\&
\&        /CODE/          && do {
\&                                warn "can\*(Aqt print function ref";
\&                                last SWITCH;
\&                        };
\&
\&        # DEFAULT
\&
\&        warn "User defined type skipped";
\&
\&    }
.Ve
.PP
See perlsyn for other examples in this style.
.PP
Sometimes you should change the positions of the constant and the variable.
For example, let's say you wanted to test which of many answers you were
given, but in a case-insensitive way that also allows abbreviations.
You can use the following technique if the strings all start with
different characters or if you want to arrange the matches so that
one takes precedence over another, as \f(CW"SEND"\fR has precedence over
\&\f(CW"STOP"\fR here:
.PP
.Vb 6
\&        chomp($answer = <>);
\&        if    ("SEND"  =~ /^\eQ$answer/i) { print "Action is send\en"  }
\&        elsif ("STOP"  =~ /^\eQ$answer/i) { print "Action is stop\en"  }
\&        elsif ("ABORT" =~ /^\eQ$answer/i) { print "Action is abort\en" }
\&        elsif ("LIST"  =~ /^\eQ$answer/i) { print "Action is list\en"  }