perlvar.1

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

Because of this specialness \f(CW$a\fR and \f(CW$b\fR don't need to be declared
(using use vars, or \fIour()\fR) even when using the \f(CW\*(C`strict \*(Aqvars\*(Aq\*(C'\fR pragma.
Don't lexicalize them with \f(CW\*(C`my $a\*(C'\fR or \f(CW\*(C`my $b\*(C'\fR if you want to be
able to use them in the \fIsort()\fR comparison block or function.
.IP "$<\fIdigits\fR>" 8
.IX Xref "$1 $2 $3"
.IX Item "$<digits>"
Contains the subpattern from the corresponding set of capturing
parentheses from the last pattern match, not counting patterns
matched in nested blocks that have been exited already.  (Mnemonic:
like \edigits.)  These variables are all read-only and dynamically
scoped to the current \s-1BLOCK\s0.
.ie n .IP "$MATCH" 8
.el .IP "\f(CW$MATCH\fR" 8
.IX Item "$MATCH"
.PD 0
.IP "$&" 8
.IX Xref "$& $MATCH"
.PD
The string matched by the last successful pattern match (not counting
any matches hidden within a \s-1BLOCK\s0 or \fIeval()\fR enclosed by the current
\&\s-1BLOCK\s0).  (Mnemonic: like & in some editors.)  This variable is read-only
and dynamically scoped to the current \s-1BLOCK\s0.
.Sp
The use of this variable anywhere in a program imposes a considerable
performance penalty on all regular expression matches.  See \*(L"\s-1BUGS\s0\*(R".
.Sp
See \*(L"@\-\*(R" for a replacement.
.IP "${^MATCH}" 8
.IX Xref "${^MATCH}"
.IX Item "${^MATCH}"
This is similar to \f(CW$&\fR (\f(CW$POSTMATCH\fR) except that it does not incur the
performance penalty associated with that variable, and is only guaranteed
to return a defined value when the pattern was compiled or executed with
the \f(CW\*(C`/p\*(C'\fR modifier.
.ie n .IP "$PREMATCH" 8
.el .IP "\f(CW$PREMATCH\fR" 8
.IX Item "$PREMATCH"
.PD 0
.IP "$`" 8
.IX Xref "$` $PREMATCH"
.PD
The string preceding whatever was matched by the last successful
pattern match (not counting any matches hidden within a \s-1BLOCK\s0 or eval
enclosed by the current \s-1BLOCK\s0).  (Mnemonic: \f(CW\*(C`\`\*(C'\fR often precedes a quoted
string.)  This variable is read-only.
.Sp
The use of this variable anywhere in a program imposes a considerable
performance penalty on all regular expression matches.  See \*(L"\s-1BUGS\s0\*(R".
.Sp
See \*(L"@\-\*(R" for a replacement.
.IP "${^PREMATCH}" 8
.IX Xref "${^PREMATCH}"
.IX Item "${^PREMATCH}"
This is similar to \f(CW\*(C`$\`\*(C'\fR ($PREMATCH) except that it does not incur the
performance penalty associated with that variable, and is only guaranteed
to return a defined value when the pattern was compiled or executed with
the \f(CW\*(C`/p\*(C'\fR modifier.
.ie n .IP "$POSTMATCH" 8
.el .IP "\f(CW$POSTMATCH\fR" 8
.IX Item "$POSTMATCH"
.PD 0
.IP "$'" 8
.IX Xref "$' $POSTMATCH"
.PD
The string following whatever was matched by the last successful
pattern match (not counting any matches hidden within a \s-1BLOCK\s0 or \fIeval()\fR
enclosed by the current \s-1BLOCK\s0).  (Mnemonic: \f(CW\*(C`\*(Aq\*(C'\fR often follows a quoted
string.)  Example:
.Sp
.Vb 3
\&    local $_ = \*(Aqabcdefghi\*(Aq;
\&    /def/;
\&    print "$\`:$&:$\*(Aq\en";         # prints abc:def:ghi
.Ve
.Sp
This variable is read-only and dynamically scoped to the current \s-1BLOCK\s0.
.Sp
The use of this variable anywhere in a program imposes a considerable
performance penalty on all regular expression matches.  See \*(L"\s-1BUGS\s0\*(R".
.Sp
See \*(L"@\-\*(R" for a replacement.
.IP "${^POSTMATCH}" 8
.IX Xref "${^POSTMATCH}"
.IX Item "${^POSTMATCH}"
This is similar to \f(CW\*(C`$\*(Aq\*(C'\fR (\f(CW$POSTMATCH\fR) except that it does not incur the
performance penalty associated with that variable, and is only guaranteed
to return a defined value when the pattern was compiled or executed with
the \f(CW\*(C`/p\*(C'\fR modifier.
.ie n .IP "$LAST_PAREN_MATCH" 8
.el .IP "\f(CW$LAST_PAREN_MATCH\fR" 8
.IX Item "$LAST_PAREN_MATCH"
.PD 0
.IP "$+" 8
.IX Xref "$+ $LAST_PAREN_MATCH"
.PD
The text matched by the last bracket of the last successful search pattern.
This is useful if you don't know which one of a set of alternative patterns
matched. For example:
.Sp
.Vb 1
\&    /Version: (.*)|Revision: (.*)/ && ($rev = $+);
.Ve
.Sp
(Mnemonic: be positive and forward looking.)
This variable is read-only and dynamically scoped to the current \s-1BLOCK\s0.
.ie n .IP "$LAST_SUBMATCH_RESULT" 8
.el .IP "\f(CW$LAST_SUBMATCH_RESULT\fR" 8
.IX Item "$LAST_SUBMATCH_RESULT"
.PD 0
.IP "$^N" 8
.IX Xref "$^N"
.IX Item "$^N"
.PD
The text matched by the used group most-recently closed (i.e. the group
with the rightmost closing parenthesis) of the last successful search
pattern.  (Mnemonic: the (possibly) Nested parenthesis that most
recently closed.)
.Sp
This is primarily used inside \f(CW\*(C`(?{...})\*(C'\fR blocks for examining text
recently matched. For example, to effectively capture text to a variable
(in addition to \f(CW$1\fR, \f(CW$2\fR, etc.), replace \f(CW\*(C`(...)\*(C'\fR with
.Sp
.Vb 1
\&     (?:(...)(?{ $var = $^N }))
.Ve
.Sp
By setting and then using \f(CW$var\fR in this way relieves you from having to
worry about exactly which numbered set of parentheses they are.
.Sp
This variable is dynamically scoped to the current \s-1BLOCK\s0.
.ie n .IP "@LAST_MATCH_END" 8
.el .IP "\f(CW@LAST_MATCH_END\fR" 8
.IX Item "@LAST_MATCH_END"
.PD 0
.IP "@+" 8
.IX Xref "@+ @LAST_MATCH_END"
.PD
This array holds the offsets of the ends of the last successful
submatches in the currently active dynamic scope.  \f(CW$+[0]\fR is
the offset into the string of the end of the entire match.  This
is the same value as what the \f(CW\*(C`pos\*(C'\fR function returns when called
on the variable that was matched against.  The \fIn\fRth element
of this array holds the offset of the \fIn\fRth submatch, so
\&\f(CW$+[1]\fR is the offset past where \f(CW$1\fR ends, \f(CW$+[2]\fR the offset
past where \f(CW$2\fR ends, and so on.  You can use \f(CW$#+\fR to determine
how many subgroups were in the last successful match.  See the
examples given for the \f(CW\*(C`@\-\*(C'\fR variable.
.IP "%+" 8
.IX Xref "%+"
Similar to \f(CW\*(C`@+\*(C'\fR, the \f(CW\*(C`%+\*(C'\fR hash allows access to the named capture
buffers, should they exist, in the last successful match in the
currently active dynamic scope.
.Sp
For example, \f(CW$+{foo}\fR is equivalent to \f(CW$1\fR after the following match:
.Sp
.Vb 1
\&  \*(Aqfoo\*(Aq =~ /(?<foo>foo)/;
.Ve
.Sp
The keys of the \f(CW\*(C`%+\*(C'\fR hash list only the names of buffers that have
captured (and that are thus associated to defined values).
.Sp
The underlying behaviour of \f(CW\*(C`%+\*(C'\fR is provided by the
Tie::Hash::NamedCapture module.
.Sp
\&\fBNote:\fR \f(CW\*(C`%\-\*(C'\fR and \f(CW\*(C`%+\*(C'\fR are tied views into a common internal hash
associated with the last successful regular expression. Therefore mixing
iterative access to them via \f(CW\*(C`each\*(C'\fR may have unpredictable results.
Likewise, if the last successful match changes, then the results may be
surprising.
.IP "\s-1HANDLE\-\s0>input_line_number(\s-1EXPR\s0)" 8
.IX Item "HANDLE->input_line_number(EXPR)"
.PD 0
.ie n .IP "$INPUT_LINE_NUMBER" 8
.el .IP "\f(CW$INPUT_LINE_NUMBER\fR" 8
.IX Item "$INPUT_LINE_NUMBER"
.ie n .IP "$NR" 8
.el .IP "\f(CW$NR\fR" 8
.IX Item "$NR"
.IP "$." 8
.IX Xref "$. $NR $INPUT_LINE_NUMBER line number"
.PD
Current line number for the last filehandle accessed.
.Sp
Each filehandle in Perl counts the number of lines that have been read
from it.  (Depending on the value of \f(CW$/\fR, Perl's idea of what
constitutes a line may not match yours.)  When a line is read from a
filehandle (via \fIreadline()\fR or \f(CW\*(C`<>\*(C'\fR), or when \fItell()\fR or \fIseek()\fR is
called on it, \f(CW$.\fR becomes an alias to the line counter for that
filehandle.
.Sp
You can adjust the counter by assigning to \f(CW$.\fR, but this will not
actually move the seek pointer.  \fILocalizing \f(CI$.\fI will not localize
the filehandle's line count\fR.  Instead, it will localize perl's notion
of which filehandle \f(CW$.\fR is currently aliased to.
.Sp
\&\f(CW$.\fR is reset when the filehandle is closed, but \fBnot\fR when an open
filehandle is reopened without an intervening \fIclose()\fR.  For more
details, see \*(L"I/O Operators\*(R" in perlop.  Because \f(CW\*(C`<>\*(C'\fR never does
an explicit close, line numbers increase across \s-1ARGV\s0 files (but see
examples in \*(L"eof\*(R" in perlfunc).
.Sp
You can also use \f(CW\*(C`HANDLE\->input_line_number(EXPR)\*(C'\fR to access the
line counter for a given filehandle without having to worry about
which handle you last accessed.
.Sp
(Mnemonic: many programs use \*(L".\*(R" to mean the current line number.)
.IP "IO::Handle\->input_record_separator(\s-1EXPR\s0)" 8
.IX Item "IO::Handle->input_record_separator(EXPR)"
.PD 0
.ie n .IP "$INPUT_RECORD_SEPARATOR" 8
.el .IP "\f(CW$INPUT_RECORD_SEPARATOR\fR" 8
.IX Item "$INPUT_RECORD_SEPARATOR"
.ie n .IP "$RS" 8
.el .IP "\f(CW$RS\fR" 8
.IX Item "$RS"
.IP "$/" 8
.IX Xref "$ $RS $INPUT_RECORD_SEPARATOR"
.PD
The input record separator, newline by default.  This 
influences Perl's idea of what a \*(L"line\*(R" is.  Works like \fBawk\fR's \s-1RS\s0
variable, including treating empty lines as a terminator if set to
the null string.  (An empty line cannot contain any spaces
or tabs.)  You may set it to a multi-character string to match a
multi-character terminator, or to \f(CW\*(C`undef\*(C'\fR to read through the end
of file.  Setting it to \f(CW"\en\en"\fR means something slightly
different than setting to \f(CW""\fR, if the file contains consecutive
empty lines.  Setting to \f(CW""\fR will treat two or more consecutive
empty lines as a single empty line.  Setting to \f(CW"\en\en"\fR will
blindly assume that the next input character belongs to the next
paragraph, even if it's a newline.  (Mnemonic: / delimits
line boundaries when quoting poetry.)
.Sp
.Vb 3
\&    local $/;           # enable "slurp" mode
\&    local $_ = <FH>;    # whole file now here
\&    s/\en[ \et]+/ /g;
.Ve
.Sp
Remember: the value of \f(CW$/\fR is a string, not a regex.  \fBawk\fR has to be
better for something. :\-)
.Sp
Setting \f(CW$/\fR to a reference to an integer, scalar containing an integer, or
scalar that's convertible to an integer will attempt to read records
instead of lines, with the maximum record size being the referenced
integer.  So this:
.Sp
.Vb 3
\&    local $/ = \e32768; # or \e"32768", or \e$var_containing_32768
\&    open my $fh, $myfile or die $!;
\&    local $_ = <$fh>;
.Ve
.Sp
will read a record of no more than 32768 bytes from \s-1FILE\s0.  If you're
not reading from a record-oriented file (or your \s-1OS\s0 doesn't have
record-oriented files), then you'll likely get a full chunk of data
with every read.  If a record is larger than the record size you've
set, you'll get the record back in pieces.  Trying to set the record
size to zero or less will cause reading in the (rest of the) whole file.
.Sp
On \s-1VMS\s0, record reads are done with the equivalent of \f(CW\*(C`sysread\*(C'\fR,
so it's best not to mix record and non-record reads on the same
file.  (This is unlikely to be a problem, because any file you'd
want to read in record mode is probably unusable in line mode.)
Non-VMS systems do normal I/O, so it's safe to mix record and
non-record reads of a file.
.Sp
See also \*(L"Newlines\*(R" in perlport.  Also see \f(CW$.\fR.
.IP "\s-1HANDLE\-\s0>autoflush(\s-1EXPR\s0)" 8
.IX Item "HANDLE->autoflush(EXPR)"
.PD 0
.ie n .IP "$OUTPUT_AUTOFLUSH" 8
.el .IP "\f(CW$OUTPUT_AUTOFLUSH\fR" 8
.IX Item "$OUTPUT_AUTOFLUSH"
.IP "$|" 8
.IX Xref "$| autoflush flush $OUTPUT_AUTOFLUSH"
.PD
If set to nonzero, forces a flush right away and after every write
or print on the currently selected output channel.  Default is 0
(regardless of whether the channel is really buffered by the
system or not; \f(CW$|\fR tells you only whether you've asked Perl
explicitly to flush after each write).  \s-1STDOUT\s0 will
typically be line buffered if output is to the terminal and block
buffered otherwise.  Setting this variable is useful primarily when
you are outputting to a pipe or socket, such as when you are running
a Perl program under \fBrsh\fR and want to see the output as it's
happening.  This has no effect on input buffering.  See \*(L"getc\*(R" in perlfunc
for that.  (Mnemonic: when you want your pipes to be piping hot.)
.IP "IO::Handle\->output_field_separator \s-1EXPR\s0" 8
.IX Item "IO::Handle->output_field_separator EXPR"
.PD 0
.ie n .IP "$OUTPUT_FIELD_SEPARATOR" 8
.el .IP "\f(CW$OUTPUT_FIELD_SEPARATOR\fR" 8
.IX Item "$OUTPUT_FIELD_SEPARATOR"
.ie n .IP "$OFS" 8
.el .IP "\f(CW$OFS\fR" 8
.IX Item "$OFS"
.IP "$," 8
.IX Xref "$, $OFS $OUTPUT_FIELD_SEPARATOR"
.PD
The output field separator for the print operator.  If defined, this
value is printed between each of print's arguments.  Default is \f(CW\*(C`undef\*(C'\fR.
(Mnemonic: what is printed when there is a \*(L",\*(R" in your print statement.)
.IP "IO::Handle\->output_record_separator \s-1EXPR\s0" 8
.IX Item "IO::Handle->output_record_separator EXPR"
.PD 0
.ie n .IP "$OUTPUT_RECORD_SEPARATOR" 8
.el .IP "\f(CW$OUTPUT_RECORD_SEPARATOR\fR" 8
.IX Item "$OUTPUT_RECORD_SEPARATOR"
.ie n .IP "$ORS" 8
.el .IP "\f(CW$ORS\fR" 8
.IX Item "$ORS"
.IP "$\e" 8
.IX Xref "$\e $ORS $OUTPUT_RECORD_SEPARATOR"
.IX Item "$"
.PD
The output record separator for the print operator.  If defined, this
value is printed after the last of print's arguments.  Default is \f(CW\*(C`undef\*(C'\fR.
(Mnemonic: you set \f(CW\*(C`$\e\*(C'\fR instead of adding \*(L"\en\*(R" at the end of the print.
Also, it's just like \f(CW$/\fR, but it's what you get \*(L"back\*(R" from Perl.)
.ie n .IP "$LIST_SEPARATOR" 8
.el .IP "\f(CW$LIST_SEPARATOR\fR" 8
.IX Item "$LIST_SEPARATOR"
.PD 0
.IP "$""" 8
.IX Xref "$"" $LIST_SEPARATOR"
.PD
This is like \f(CW$,\fR except that it applies to array and slice values
interpolated into a double-quoted string (or similar interpreted
string).  Default is a space.  (Mnemonic: obvious, I think.)
.ie n .IP "$SUBSCRIPT_SEPARATOR" 8
.el .IP "\f(CW$SUBSCRIPT_SEPARATOR\fR" 8
.IX Item "$SUBSCRIPT_SEPARATOR"
.PD 0
.ie n .IP "$SUBSEP" 8
.el .IP "\f(CW$SUBSEP\fR" 8
.IX Item "$SUBSEP"
.IP "$;" 8
.IX Xref "$; $SUBSEP SUBSCRIPT_SEPARATOR"
.PD
The subscript separator for multidimensional array emulation.  If you
refer to a hash element as
.Sp
.Vb 1
\&    $foo{$a,$b,$c}
.Ve
.Sp