perlop.1

来自「视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.」· 1 代码 · 共 1,599 行 · 第 1/5 页

.IX Subsection "C-style Logical Or"
Binary \*(L"||\*(R" performs a short-circuit logical \s-1OR\s0 operation.  That is,
if the left operand is true, the right operand is not even evaluated.
Scalar or list context propagates down to the right operand if it
is evaluated.
.Sh "C\-style Logical Defined-Or"
.IX Xref "operator, logical, defined-or"
.IX Subsection "C-style Logical Defined-Or"
Although it has no direct equivalent in C, Perl's \f(CW\*(C`//\*(C'\fR operator is related
to its C\-style or.  In fact, it's exactly the same as \f(CW\*(C`||\*(C'\fR, except that it
tests the left hand side's definedness instead of its truth.  Thus, \f(CW\*(C`$a // $b\*(C'\fR
is similar to \f(CW\*(C`defined($a) || $b\*(C'\fR (except that it returns the value of \f(CW$a\fR
rather than the value of \f(CW\*(C`defined($a)\*(C'\fR) and is exactly equivalent to
\&\f(CW\*(C`defined($a) ? $a : $b\*(C'\fR.  This is very useful for providing default values
for variables.  If you actually want to test if at least one of \f(CW$a\fR and
\&\f(CW$b\fR is defined, use \f(CW\*(C`defined($a // $b)\*(C'\fR.
.PP
The \f(CW\*(C`||\*(C'\fR, \f(CW\*(C`//\*(C'\fR and \f(CW\*(C`&&\*(C'\fR operators return the last value evaluated
(unlike C's \f(CW\*(C`||\*(C'\fR and \f(CW\*(C`&&\*(C'\fR, which return 0 or 1). Thus, a reasonably
portable way to find out the home directory might be:
.PP
.Vb 2
\&    $home = $ENV{\*(AqHOME\*(Aq} // $ENV{\*(AqLOGDIR\*(Aq} //
\&        (getpwuid($<))[7] // die "You\*(Aqre homeless!\en";
.Ve
.PP
In particular, this means that you shouldn't use this
for selecting between two aggregates for assignment:
.PP
.Vb 3
\&    @a = @b || @c;              # this is wrong
\&    @a = scalar(@b) || @c;      # really meant this
\&    @a = @b ? @b : @c;          # this works fine, though
.Ve
.PP
As more readable alternatives to \f(CW\*(C`&&\*(C'\fR and \f(CW\*(C`||\*(C'\fR when used for
control flow, Perl provides the \f(CW\*(C`and\*(C'\fR and \f(CW\*(C`or\*(C'\fR operators (see below).
The short-circuit behavior is identical.  The precedence of \*(L"and\*(R"
and \*(L"or\*(R" is much lower, however, so that you can safely use them after a
list operator without the need for parentheses:
.PP
.Vb 2
\&    unlink "alpha", "beta", "gamma"
\&            or gripe(), next LINE;
.Ve
.PP
With the C\-style operators that would have been written like this:
.PP
.Vb 2
\&    unlink("alpha", "beta", "gamma")
\&            || (gripe(), next LINE);
.Ve
.PP
Using \*(L"or\*(R" for assignment is unlikely to do what you want; see below.
.Sh "Range Operators"
.IX Xref "operator, range range .. ..."
.IX Subsection "Range Operators"
Binary \*(L"..\*(R" is the range operator, which is really two different
operators depending on the context.  In list context, it returns a
list of values counting (up by ones) from the left value to the right
value.  If the left value is greater than the right value then it
returns the empty list.  The range operator is useful for writing
\&\f(CW\*(C`foreach (1..10)\*(C'\fR loops and for doing slice operations on arrays. In
the current implementation, no temporary array is created when the
range operator is used as the expression in \f(CW\*(C`foreach\*(C'\fR loops, but older
versions of Perl might burn a lot of memory when you write something
like this:
.PP
.Vb 3
\&    for (1 .. 1_000_000) {
\&        # code
\&    }
.Ve
.PP
The range operator also works on strings, using the magical auto-increment,
see below.
.PP
In scalar context, \*(L"..\*(R" returns a boolean value.  The operator is
bistable, like a flip-flop, and emulates the line-range (comma) operator
of \fBsed\fR, \fBawk\fR, and various editors.  Each \*(L"..\*(R" operator maintains its
own boolean state.  It is false as long as its left operand is false.
Once the left operand is true, the range operator stays true until the
right operand is true, \fI\s-1AFTER\s0\fR which the range operator becomes false
again.  It doesn't become false till the next time the range operator is
evaluated.  It can test the right operand and become false on the same
evaluation it became true (as in \fBawk\fR), but it still returns true once.
If you don't want it to test the right operand till the next
evaluation, as in \fBsed\fR, just use three dots (\*(L"...\*(R") instead of
two.  In all other regards, \*(L"...\*(R" behaves just like \*(L"..\*(R" does.
.PP
The right operand is not evaluated while the operator is in the
\&\*(L"false\*(R" state, and the left operand is not evaluated while the
operator is in the \*(L"true\*(R" state.  The precedence is a little lower
than || and &&.  The value returned is either the empty string for
false, or a sequence number (beginning with 1) for true.  The
sequence number is reset for each range encountered.  The final
sequence number in a range has the string \*(L"E0\*(R" appended to it, which
doesn't affect its numeric value, but gives you something to search
for if you want to exclude the endpoint.  You can exclude the
beginning point by waiting for the sequence number to be greater
than 1.
.PP
If either operand of scalar \*(L"..\*(R" is a constant expression,
that operand is considered true if it is equal (\f(CW\*(C`==\*(C'\fR) to the current
input line number (the \f(CW$.\fR variable).
.PP
To be pedantic, the comparison is actually \f(CW\*(C`int(EXPR) == int(EXPR)\*(C'\fR,
but that is only an issue if you use a floating point expression; when
implicitly using \f(CW$.\fR as described in the previous paragraph, the
comparison is \f(CW\*(C`int(EXPR) == int($.)\*(C'\fR which is only an issue when \f(CW$.\fR
is set to a floating point value and you are not reading from a file.
Furthermore, \f(CW"span" .. "spat"\fR or \f(CW\*(C`2.18 .. 3.14\*(C'\fR will not do what
you want in scalar context because each of the operands are evaluated
using their integer representation.
.PP
Examples:
.PP
As a scalar operator:
.PP
.Vb 2
\&    if (101 .. 200) { print; } # print 2nd hundred lines, short for
\&                               #   if ($. == 101 .. $. == 200) ...
\&
\&    next LINE if (1 .. /^$/);  # skip header lines, short for
\&                               #   ... if ($. == 1 .. /^$/);
\&                               # (typically in a loop labeled LINE)
\&
\&    s/^/> / if (/^$/ .. eof());  # quote body
\&
\&    # parse mail messages
\&    while (<>) {
\&        $in_header =   1  .. /^$/;
\&        $in_body   = /^$/ .. eof;
\&        if ($in_header) {
\&            # ...
\&        } else { # in body
\&            # ...
\&        }
\&    } continue {
\&        close ARGV if eof;             # reset $. each file
\&    }
.Ve
.PP
Here's a simple example to illustrate the difference between
the two range operators:
.PP
.Vb 4
\&    @lines = ("   \- Foo",
\&              "01 \- Bar",
\&              "1  \- Baz",
\&              "   \- Quux");
\&
\&    foreach (@lines) {
\&        if (/0/ .. /1/) {
\&            print "$_\en";
\&        }
\&    }
.Ve
.PP
This program will print only the line containing \*(L"Bar\*(R". If
the range operator is changed to \f(CW\*(C`...\*(C'\fR, it will also print the
\&\*(L"Baz\*(R" line.
.PP
And now some examples as a list operator:
.PP
.Vb 3
\&    for (101 .. 200) { print; } # print $_ 100 times
\&    @foo = @foo[0 .. $#foo];    # an expensive no\-op
\&    @foo = @foo[$#foo\-4 .. $#foo];      # slice last 5 items
.Ve
.PP
The range operator (in list context) makes use of the magical
auto-increment algorithm if the operands are strings.  You
can say
.PP
.Vb 1
\&    @alphabet = (\*(AqA\*(Aq .. \*(AqZ\*(Aq);
.Ve
.PP
to get all normal letters of the English alphabet, or
.PP
.Vb 1
\&    $hexdigit = (0 .. 9, \*(Aqa\*(Aq .. \*(Aqf\*(Aq)[$num & 15];
.Ve
.PP
to get a hexadecimal digit, or
.PP
.Vb 1
\&    @z2 = (\*(Aq01\*(Aq .. \*(Aq31\*(Aq);  print $z2[$mday];
.Ve
.PP
to get dates with leading zeros.
.PP
If the final value specified is not in the sequence that the magical
increment would produce, the sequence goes until the next value would
be longer than the final value specified.
.PP
If the initial value specified isn't part of a magical increment
sequence (that is, a non-empty string matching \*(L"/^[a\-zA\-Z]*[0\-9]*\ez/\*(R"),
only the initial value will be returned.  So the following will only
return an alpha:
.PP
.Vb 2
\&    use charnames \*(Aqgreek\*(Aq;
\&    my @greek_small =  ("\eN{alpha}" .. "\eN{omega}");
.Ve
.PP
To get lower-case greek letters, use this instead:
.PP
.Vb 1
\&    my @greek_small =  map { chr } ( ord("\eN{alpha}") .. ord("\eN{omega}") );
.Ve
.PP
Because each operand is evaluated in integer form, \f(CW\*(C`2.18 .. 3.14\*(C'\fR will
return two elements in list context.
.PP
.Vb 1
\&    @list = (2.18 .. 3.14); # same as @list = (2 .. 3);
.Ve
.Sh "Conditional Operator"
.IX Xref "operator, conditional operator, ternary ternary ?:"
.IX Subsection "Conditional Operator"
Ternary \*(L"?:\*(R" is the conditional operator, just as in C.  It works much
like an if-then-else.  If the argument before the ? is true, the
argument before the : is returned, otherwise the argument after the :
is returned.  For example:
.PP
.Vb 2
\&    printf "I have %d dog%s.\en", $n,
\&            ($n == 1) ? \*(Aq\*(Aq : "s";
.Ve
.PP
Scalar or list context propagates downward into the 2nd
or 3rd argument, whichever is selected.
.PP
.Vb 3
\&    $a = $ok ? $b : $c;  # get a scalar
\&    @a = $ok ? @b : @c;  # get an array
\&    $a = $ok ? @b : @c;  # oops, that\*(Aqs just a count!
.Ve
.PP
The operator may be assigned to if both the 2nd and 3rd arguments are
legal lvalues (meaning that you can assign to them):
.PP
.Vb 1
\&    ($a_or_b ? $a : $b) = $c;
.Ve
.PP
Because this operator produces an assignable result, using assignments
without parentheses will get you in trouble.  For example, this:
.PP
.Vb 1
\&    $a % 2 ? $a += 10 : $a += 2
.Ve
.PP
Really means this:
.PP
.Vb 1
\&    (($a % 2) ? ($a += 10) : $a) += 2
.Ve
.PP
Rather than this:
.PP
.Vb 1
\&    ($a % 2) ? ($a += 10) : ($a += 2)
.Ve
.PP
That should probably be written more simply as:
.PP
.Vb 1
\&    $a += ($a % 2) ? 10 : 2;
.Ve
.Sh "Assignment Operators"
.IX Xref "assignment operator, assignment = **= += *= &= <<= &&= -=  = |= >>= ||=   = .= %= ^= x="
.IX Subsection "Assignment Operators"
\&\*(L"=\*(R" is the ordinary assignment operator.
.PP
Assignment operators work as in C.  That is,
.PP
.Vb 1
\&    $a += 2;
.Ve
.PP
is equivalent to
.PP
.Vb 1
\&    $a = $a + 2;
.Ve
.PP
although without duplicating any side effects that dereferencing the lvalue
might trigger, such as from \fItie()\fR.  Other assignment operators work similarly.
The following are recognized:
.PP
.Vb 4
\&    **=    +=    *=    &=    <<=    &&=
\&           \-=    /=    |=    >>=    ||=
\&           .=    %=    ^=           //=
\&                 x=
.Ve
.PP
Although these are grouped by family, they all have the precedence
of assignment.
.PP
Unlike in C, the scalar assignment operator produces a valid lvalue.
Modifying an assignment is equivalent to doing the assignment and
then modifying the variable that was assigned to.  This is useful
for modifying a copy of something, like this:
.PP
.Vb 1
\&    ($tmp = $global) =~ tr [A\-Z] [a\-z];
.Ve
.PP
Likewise,
.PP
.Vb 1
\&    ($a += 2) *= 3;
.Ve
.PP
is equivalent to
.PP