perlretut.1

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

\&\f(CW\*(C`\eb\*(C'\fR.  This matches a boundary between a word character and a non-word
character \f(CW\*(C`\ew\eW\*(C'\fR or \f(CW\*(C`\eW\ew\*(C'\fR:
.PP
.Vb 5
\&    $x = "Housecat catenates house and cat";
\&    $x =~ /cat/;    # matches cat in \*(Aqhousecat\*(Aq
\&    $x =~ /\ebcat/;  # matches cat in \*(Aqcatenates\*(Aq
\&    $x =~ /cat\eb/;  # matches cat in \*(Aqhousecat\*(Aq
\&    $x =~ /\ebcat\eb/;  # matches \*(Aqcat\*(Aq at end of string
.Ve
.PP
Note in the last example, the end of the string is considered a word
boundary.
.PP
You might wonder why \f(CW\*(Aq.\*(Aq\fR matches everything but \f(CW"\en"\fR \- why not
every character? The reason is that often one is matching against
lines and would like to ignore the newline characters.  For instance,
while the string \f(CW"\en"\fR represents one line, we would like to think
of it as empty.  Then
.PP
.Vb 2
\&    ""   =~ /^$/;    # matches
\&    "\en" =~ /^$/;    # matches, $ anchors before "\en"
\&
\&    ""   =~ /./;      # doesn\*(Aqt match; it needs a char
\&    ""   =~ /^.$/;    # doesn\*(Aqt match; it needs a char
\&    "\en" =~ /^.$/;    # doesn\*(Aqt match; it needs a char other than "\en"
\&    "a"  =~ /^.$/;    # matches
\&    "a\en"  =~ /^.$/;  # matches, $ anchors before "\en"
.Ve
.PP
This behavior is convenient, because we usually want to ignore
newlines when we count and match characters in a line.  Sometimes,
however, we want to keep track of newlines.  We might even want \f(CW\*(C`^\*(C'\fR
and \f(CW\*(C`$\*(C'\fR to anchor at the beginning and end of lines within the
string, rather than just the beginning and end of the string.  Perl
allows us to choose between ignoring and paying attention to newlines
by using the \f(CW\*(C`//s\*(C'\fR and \f(CW\*(C`//m\*(C'\fR modifiers.  \f(CW\*(C`//s\*(C'\fR and \f(CW\*(C`//m\*(C'\fR stand for
single line and multi-line and they determine whether a string is to
be treated as one continuous string, or as a set of lines.  The two
modifiers affect two aspects of how the regexp is interpreted: 1) how
the \f(CW\*(Aq.\*(Aq\fR character class is defined, and 2) where the anchors \f(CW\*(C`^\*(C'\fR
and \f(CW\*(C`$\*(C'\fR are able to match.  Here are the four possible combinations:
.IP "\(bu" 4
no modifiers (//): Default behavior.  \f(CW\*(Aq.\*(Aq\fR matches any character
except \f(CW"\en"\fR.  \f(CW\*(C`^\*(C'\fR matches only at the beginning of the string and
\&\f(CW\*(C`$\*(C'\fR matches only at the end or before a newline at the end.
.IP "\(bu" 4
s modifier (//s): Treat string as a single long line.  \f(CW\*(Aq.\*(Aq\fR matches
any character, even \f(CW"\en"\fR.  \f(CW\*(C`^\*(C'\fR matches only at the beginning of
the string and \f(CW\*(C`$\*(C'\fR matches only at the end or before a newline at the
end.
.IP "\(bu" 4
m modifier (//m): Treat string as a set of multiple lines.  \f(CW\*(Aq.\*(Aq\fR
matches any character except \f(CW"\en"\fR.  \f(CW\*(C`^\*(C'\fR and \f(CW\*(C`$\*(C'\fR are able to match
at the start or end of \fIany\fR line within the string.
.IP "\(bu" 4
both s and m modifiers (//sm): Treat string as a single long line, but
detect multiple lines.  \f(CW\*(Aq.\*(Aq\fR matches any character, even
\&\f(CW"\en"\fR.  \f(CW\*(C`^\*(C'\fR and \f(CW\*(C`$\*(C'\fR, however, are able to match at the start or end
of \fIany\fR line within the string.
.PP
Here are examples of \f(CW\*(C`//s\*(C'\fR and \f(CW\*(C`//m\*(C'\fR in action:
.PP
.Vb 1
\&    $x = "There once was a girl\enWho programmed in Perl\en";
\&
\&    $x =~ /^Who/;   # doesn\*(Aqt match, "Who" not at start of string
\&    $x =~ /^Who/s;  # doesn\*(Aqt match, "Who" not at start of string
\&    $x =~ /^Who/m;  # matches, "Who" at start of second line
\&    $x =~ /^Who/sm; # matches, "Who" at start of second line
\&
\&    $x =~ /girl.Who/;   # doesn\*(Aqt match, "." doesn\*(Aqt match "\en"
\&    $x =~ /girl.Who/s;  # matches, "." matches "\en"
\&    $x =~ /girl.Who/m;  # doesn\*(Aqt match, "." doesn\*(Aqt match "\en"
\&    $x =~ /girl.Who/sm; # matches, "." matches "\en"
.Ve
.PP
Most of the time, the default behavior is what is wanted, but \f(CW\*(C`//s\*(C'\fR and
\&\f(CW\*(C`//m\*(C'\fR are occasionally very useful.  If \f(CW\*(C`//m\*(C'\fR is being used, the start
of the string can still be matched with \f(CW\*(C`\eA\*(C'\fR and the end of the string
can still be matched with the anchors \f(CW\*(C`\eZ\*(C'\fR (matches both the end and
the newline before, like \f(CW\*(C`$\*(C'\fR), and \f(CW\*(C`\ez\*(C'\fR (matches only the end):
.PP
.Vb 2
\&    $x =~ /^Who/m;   # matches, "Who" at start of second line
\&    $x =~ /\eAWho/m;  # doesn\*(Aqt match, "Who" is not at start of string
\&
\&    $x =~ /girl$/m;  # matches, "girl" at end of first line
\&    $x =~ /girl\eZ/m; # doesn\*(Aqt match, "girl" is not at end of string
\&
\&    $x =~ /Perl\eZ/m; # matches, "Perl" is at newline before end
\&    $x =~ /Perl\ez/m; # doesn\*(Aqt match, "Perl" is not at end of string
.Ve
.PP
We now know how to create choices among classes of characters in a
regexp.  What about choices among words or character strings? Such
choices are described in the next section.
.Sh "Matching this or that"
.IX Subsection "Matching this or that"
Sometimes we would like our regexp to be able to match different
possible words or character strings.  This is accomplished by using
the \fIalternation\fR metacharacter \f(CW\*(C`|\*(C'\fR.  To match \f(CW\*(C`dog\*(C'\fR or \f(CW\*(C`cat\*(C'\fR, we
form the regexp \f(CW\*(C`dog|cat\*(C'\fR.  As before, Perl will try to match the
regexp at the earliest possible point in the string.  At each
character position, Perl will first try to match the first
alternative, \f(CW\*(C`dog\*(C'\fR.  If \f(CW\*(C`dog\*(C'\fR doesn't match, Perl will then try the
next alternative, \f(CW\*(C`cat\*(C'\fR.  If \f(CW\*(C`cat\*(C'\fR doesn't match either, then the
match fails and Perl moves to the next position in the string.  Some
examples:
.PP
.Vb 2
\&    "cats and dogs" =~ /cat|dog|bird/;  # matches "cat"
\&    "cats and dogs" =~ /dog|cat|bird/;  # matches "cat"
.Ve
.PP
Even though \f(CW\*(C`dog\*(C'\fR is the first alternative in the second regexp,
\&\f(CW\*(C`cat\*(C'\fR is able to match earlier in the string.
.PP
.Vb 2
\&    "cats"          =~ /c|ca|cat|cats/; # matches "c"
\&    "cats"          =~ /cats|cat|ca|c/; # matches "cats"
.Ve
.PP
Here, all the alternatives match at the first string position, so the
first alternative is the one that matches.  If some of the
alternatives are truncations of the others, put the longest ones first
to give them a chance to match.
.PP
.Vb 2
\&    "cab" =~ /a|b|c/ # matches "c"
\&                     # /a|b|c/ == /[abc]/
.Ve
.PP
The last example points out that character classes are like
alternations of characters.  At a given character position, the first
alternative that allows the regexp match to succeed will be the one
that matches.
.Sh "Grouping things and hierarchical matching"
.IX Subsection "Grouping things and hierarchical matching"
Alternation allows a regexp to choose among alternatives, but by
itself it is unsatisfying.  The reason is that each alternative is a whole
regexp, but sometime we want alternatives for just part of a
regexp.  For instance, suppose we want to search for housecats or
housekeepers.  The regexp \f(CW\*(C`housecat|housekeeper\*(C'\fR fits the bill, but is
inefficient because we had to type \f(CW\*(C`house\*(C'\fR twice.  It would be nice to
have parts of the regexp be constant, like \f(CW\*(C`house\*(C'\fR, and some
parts have alternatives, like \f(CW\*(C`cat|keeper\*(C'\fR.
.PP
The \fIgrouping\fR metacharacters \f(CW\*(C`()\*(C'\fR solve this problem.  Grouping
allows parts of a regexp to be treated as a single unit.  Parts of a
regexp are grouped by enclosing them in parentheses.  Thus we could solve
the \f(CW\*(C`housecat|housekeeper\*(C'\fR by forming the regexp as
\&\f(CW\*(C`house(cat|keeper)\*(C'\fR.  The regexp \f(CW\*(C`house(cat|keeper)\*(C'\fR means match
\&\f(CW\*(C`house\*(C'\fR followed by either \f(CW\*(C`cat\*(C'\fR or \f(CW\*(C`keeper\*(C'\fR.  Some more examples
are
.PP
.Vb 4
\&    /(a|b)b/;    # matches \*(Aqab\*(Aq or \*(Aqbb\*(Aq
\&    /(ac|b)b/;   # matches \*(Aqacb\*(Aq or \*(Aqbb\*(Aq
\&    /(^a|b)c/;   # matches \*(Aqac\*(Aq at start of string or \*(Aqbc\*(Aq anywhere
\&    /(a|[bc])d/; # matches \*(Aqad\*(Aq, \*(Aqbd\*(Aq, or \*(Aqcd\*(Aq
\&
\&    /house(cat|)/;  # matches either \*(Aqhousecat\*(Aq or \*(Aqhouse\*(Aq
\&    /house(cat(s|)|)/;  # matches either \*(Aqhousecats\*(Aq or \*(Aqhousecat\*(Aq or
\&                        # \*(Aqhouse\*(Aq.  Note groups can be nested.
\&
\&    /(19|20|)\ed\ed/;  # match years 19xx, 20xx, or the Y2K problem, xx
\&    "20" =~ /(19|20|)\ed\ed/;  # matches the null alternative \*(Aq()\ed\ed\*(Aq,
\&                             # because \*(Aq20\ed\ed\*(Aq can\*(Aqt match
.Ve
.PP
Alternations behave the same way in groups as out of them: at a given
string position, the leftmost alternative that allows the regexp to
match is taken.  So in the last example at the first string position,
\&\f(CW"20"\fR matches the second alternative, but there is nothing left over
to match the next two digits \f(CW\*(C`\ed\ed\*(C'\fR.  So Perl moves on to the next
alternative, which is the null alternative and that works, since
\&\f(CW"20"\fR is two digits.
.PP
The process of trying one alternative, seeing if it matches, and
moving on to the next alternative, while going back in the string
from where the previous alternative was tried, if it doesn't, is called
\&\fIbacktracking\fR.  The term 'backtracking' comes from the idea that
matching a regexp is like a walk in the woods.  Successfully matching
a regexp is like arriving at a destination.  There are many possible
trailheads, one for each string position, and each one is tried in
order, left to right.  From each trailhead there may be many paths,
some of which get you there, and some which are dead ends.  When you
walk along a trail and hit a dead end, you have to backtrack along the
trail to an earlier point to try another trail.  If you hit your
destination, you stop immediately and forget about trying all the
other trails.  You are persistent, and only if you have tried all the
trails from all the trailheads and not arrived at your destination, do
you declare failure.  To be concrete, here is a step-by-step analysis
of what Perl does when it tries to match the regexp
.PP
.Vb 1
\&    "abcde" =~ /(abd|abc)(df|d|de)/;
.Ve
.IP "0" 4
Start with the first letter in the string 'a'.
.IP "1" 4
.IX Item "1"
Try the first alternative in the first group 'abd'.
.IP "2" 4
.IX Item "2"
Match 'a' followed by 'b'. So far so good.
.IP "3" 4
.IX Item "3"
\&'d' in the regexp doesn't match 'c' in the string \- a dead
end.  So backtrack two characters and pick the second alternative in
the first group 'abc'.
.IP "4" 4
.IX Item "4"
Match 'a' followed by 'b' followed by 'c'.  We are on a roll
and have satisfied the first group. Set \f(CW$1\fR to 'abc'.
.IP "5" 4
.IX Item "5"
Move on to the second group and pick the first alternative
\&'df'.
.IP "6" 4
.IX Item "6"
Match the 'd'.
.IP "7" 4
.IX Item "7"
\&'f' in the regexp doesn't match 'e' in the string, so a dead
end.  Backtrack one character and pick the second alternative in the
second group 'd'.
.IP "8" 4
.IX Item "8"
\&'d' matches. The second grouping is satisfied, so set \f(CW$2\fR to
\&'d'.
.IP "9" 4
.IX Item "9"
We are at the end of the regexp, so we are done! We have
matched 'abcd' out of the string \*(L"abcde\*(R".
.PP
There are a couple of things to note about this analysis.  First, the
third alternative in the second group 'de' also allows a match, but we
stopped before we got to it \- at a given character position, leftmost
wins.  Second, we were able to get a match at the first character
position of the string 'a'.  If there were no matches at the first
position, Perl would move to the second character position 'b' and
attempt the match all over again.  Only when all possible paths at all
possible character positions have been exhausted does Perl give
up and declare \f(CW\*(C`$string\ =~\ /(abd|abc)(df|d|de)/;\*(C'\fR to be false.
.PP
Even with all this work, regexp matching happens remarkably fast.  To
speed things up, Perl compiles the regexp into a compact sequence of
opcodes that can often fit inside a processor cache.  When the code is
executed, these opcodes can then run at full throttle and search very
quickly.
.Sh "Extracting matches"
.IX Subsection "Extracting matches"
The grouping metacharacters \f(CW\*(C`()\*(C'\fR also serve another completely
different function: they allow the extraction of the parts of a string
that matched.  This is very useful to find out what matched and for
text processing in general.  For each grouping, the part that matched
inside goes into the special variables \f(CW$1\fR, \f(CW$2\fR, etc.  They can be
used just as ordinary variables:
.PP
.Vb 6
\&    # extract hours, minutes, seconds
\&    if ($time =~ /(\ed\ed):(\ed\ed):(\ed\ed)/) {    # match hh:mm:ss format
\&        $hours = $1;
\&        $minutes = $2;
\&        $seconds = $3;
\&    }
.Ve
.PP
Now, we know that in scalar context,
\&\f(CW\*(C`$time\ =~\ /(\ed\ed):(\ed\ed):(\ed\ed)/\*(C'\fR returns a true or false
value.  In list context, however, it returns the list of matched values
\&\f(CW\*(C`($1,$2,$3)\*(C'\fR.  So we could write the code more compactly as
.PP
.Vb 2
\&    # extract hours, minutes, seconds
\&    ($hours, $minutes, $second) = ($time =~ /(\ed\ed):(\ed\ed):(\ed\ed)/);
.Ve
.PP
If the groupings in a regexp are nested, \f(CW$1\fR gets the group with the
leftmost opening parenthesis, \f(CW$2\fR the next opening parenthesis,
etc.  Here is a regexp with nested groups:
.PP
.Vb 2
\&    /(ab(cd|ef)((gi)|j))/;
\&     1  2      34
.Ve
.PP
If this regexp matches, \f(CW$1\fR contains a string starting with
\&\f(CW\*(Aqab\*(Aq\fR, \f(CW$2\fR is either set to \f(CW\*(Aqcd\*(Aq\fR or \f(CW\*(Aqef\*(Aq\fR, \f(CW$3\fR equals either
\&\f(CW\*(Aqgi\*(Aq\fR or \f(CW\*(Aqj\*(Aq\fR, and \f(CW$4\fR is either set to \f(CW\*(Aqgi\*(Aq\fR, just like \f(CW$3\fR,
or it remains undefined.