If any list operator (print(), etc.) or any unary operator (chdir(), etc.)
is followed by a left parenthesis as the next token, the operator and
arguments within parentheses are taken to be of highest precedence,
-just like a normal function call. Examples:
+just like a normal function call. For example,
+because named unary operators are higher precedence than ||:
chdir $foo || die; # (chdir $foo) || die
chdir($foo) || die; # (chdir $foo) || die
chdir ($foo) || die; # (chdir $foo) || die
chdir +($foo) || die; # (chdir $foo) || die
-but, because * is higher precedence than ||:
+but, because * is higher precedence than named operators:
chdir $foo * 20; # chdir ($foo * 20)
chdir($foo) * 20; # (chdir $foo) * 20
reset if eof; # clear ?? status for next file
}
-This usage is vaguely depreciated, which means it just might possibly
+This usage is vaguely deprecated, which means it just might possibly
be removed in some distant future version of Perl, perhaps somewhere
around the year 2168.
A string enclosed by backticks (grave accents) first undergoes
double-quote interpolation. It is then interpreted as an external
command, and the output of that command is the value of the
-pseudo-literal, j
-string consisting of all output is returned. In list context, a
-list of values is returned, one per line of output. (You can set
-C<$/> to use a different line terminator.) The command is executed
-each time the pseudo-literal is evaluated. The status value of the
-command is returned in C<$?> (see L<perlvar> for the interpretation
-of C<$?>). Unlike in B<csh>, no translation is done on the return
-data--newlines remain newlines. Unlike in any of the shells, single
-quotes do not hide variable names in the command from interpretation.
-To pass a literal dollar-sign through to the shell you need to hide
-it with a backslash. The generalized form of backticks is C<qx//>.
-(Because backticks always undergo shell expansion as well, see
-L<perlsec> for security concerns.)
+backtick string, like in a shell. In scalar context, a single string
+consisting of all output is returned. In list context, a list of
+values is returned, one per line of output. (You can set C<$/> to use
+a different line terminator.) The command is executed each time the
+pseudo-literal is evaluated. The status value of the command is
+returned in C<$?> (see L<perlvar> for the interpretation of C<$?>).
+Unlike in B<csh>, no translation is done on the return data--newlines
+remain newlines. Unlike in any of the shells, single quotes do not
+hide variable names in the command from interpretation. To pass a
+literal dollar-sign through to the shell you need to hide it with a
+backslash. The generalized form of backticks is C<qx//>. (Because
+backticks always undergo shell expansion as well, see L<perlsec> for
+security concerns.)
In scalar context, evaluating a filehandle in angle brackets yields
the next line from that file (the newline, if any, included), or
the value is automatically assigned to the global variable $_,
destroying whatever was there previously. (This may seem like an
odd thing to you, but you'll use the construct in almost every Perl
-script you write.) The $_ variables is not implicitly localized.
+script you write.) The $_ variable is not implicitly localized.
You'll have to put a C<local $_;> before the loop if you want that
to happen.
open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
while (<FOO>) {
- chop;
+ chomp;
chmod 0644, $_;
}
The standard Math::BigInt and Math::BigFloat modules provide
variable-precision arithmetic and overloaded operators, although
-they're currently pretty slow. At the cost of some space and
+they're currently pretty slow. At the cost of some space and
considerable speed, they avoid the normal pitfalls associated with
limited-precision representations.
# prints +15241578780673678515622620750190521
-The non-standard modules SSLeay::BN and Math::Pari provide
-equivalent functionality (and much more) with a substantial
-performance savings.
+There are several modules that let you calculate with (bound only by
+memory and cpu-time) unlimited or fixed precision. There are also
+some non-standard modules that provide faster implementations via
+external C libraries.
+
+Here is a short, but incomplete summary:
+
+ Math::Fraction big, unlimited fractions like 9973 / 12967
+ Math::String treat string sequences like numbers
+ Math::FixedPrecision calculate with a fixed precision
+ Math::Currency for currency calculations
+ Bit::Vector manipulate bit vectors fast (uses C)
+ Math::BigIntFast Bit::Vector wrapper for big numbers
+ Math::Pari provides access to the Pari C library
+ Math::BigInteger uses an external C library
+ Math::Cephes uses external Cephes C library (no big numbers)
+ Math::Cephes::Fraction fractions via the Cephes library
+ Math::GMP another one using an external C library
+
+Choose wisely.
=cut
projects / p5sagit/p5-mst-13.2.git / blobdiff