of the special variables that you have changed. This is one of the
correct ways to read the whole file at once:
- open my $fh, "foo" or die $!;
+ open my $fh, "<", "foo" or die $!;
local $/; # enable localized slurp mode
my $content = <$fh>;
close $fh;
But the following code is quite bad:
- open my $fh, "foo" or die $!;
+ open my $fh, "<", "foo" or die $!;
undef $/; # enable slurp mode
my $content = <$fh>;
close $fh;
example:
my $content = '';
- open my $fh, "foo" or die $!;
+ open my $fh, "<", "foo" or die $!;
{
local $/;
$content = <$fh>;
=item *
-Various unary functions, including functions like ord() and int(), as well
-as the all file tests (C<-f>, C<-d>) except for C<-t>, which defaults to
-STDIN.
+The following functions:
+
+abs, alarm, chomp, chop, chr, chroot, cos, defined, eval, exp, glob,
+hex, int, lc, lcfirst, length, log, lstat, mkdir, oct, ord, pos, print,
+quotemeta, readlink, readpipe, ref, require, reverse (in scalar context only),
+rmdir, sin, split (on its second argument), sqrt, stat, study, uc, ucfirst,
+unlink, unpack.
=item *
-Various list functions like print() and unlink().
+All file tests (C<-f>, C<-d>) except for C<-t>, which defaults to STDIN.
+See L<perlfunc/-X>
+
=item *
-The pattern matching operations C<m//>, C<s///>, and C<tr///> when used
-without an C<=~> operator.
+The pattern matching operations C<m//>, C<s///> and C<tr///> (aka C<y///>)
+when used without an C<=~> operator.
=item *
=item *
+The implicit variable of given().
+
+=item *
+
The default place to put an input record when a C<< <FH> >>
operation's result is tested by itself as the sole criterion of a C<while>
test. Outside a C<while> test, this will not happen.
As C<$_> is a global variable, this may lead in some cases to unwanted
side-effects. As of perl 5.9.1, you can now use a lexical version of
C<$_> by declaring it in a file or in a block with C<my>. Moreover,
-declaring C<our $> restores the global C<$_> in the current scope.
+declaring C<our $_> restores the global C<$_> in the current scope.
(Mnemonic: underline is understood in certain operations.)
=over 8
-=item $<I<digits>>
+=item $<I<digits>> ($1, $2, ...)
X<$1> X<$2> X<$3>
Contains the subpattern from the corresponding set of capturing
-parentheses from the last pattern match, not counting patterns
+parentheses from the last successful pattern match, not counting patterns
matched in nested blocks that have been exited already. (Mnemonic:
like \digits.) These variables are all read-only and dynamically
scoped to the current BLOCK.
=item ${^MATCH}
X<${^MATCH}>
-This is similar to C<$&> (C<$POSTMATCH>) except that it does not incur the
+This is similar to C<$&> (C<$MATCH>) 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 C</p> modifier.
(Mnemonic: be positive and forward looking.)
This variable is read-only and dynamically scoped to the current BLOCK.
+=item $LAST_SUBMATCH_RESULT
+
=item $^N
X<$^N>
how many subgroups were in the last successful match. See the
examples given for the C<@-> variable.
+=item %LAST_PAREN_MATCH
+
=item %+
X<%+>
captured (and that are thus associated to defined values).
The underlying behaviour of C<%+> is provided by the
-L<re::Tie::Hash::NamedCapture> module.
+L<Tie::Hash::NamedCapture> module.
B<Note:> C<%-> and C<%+> are tied views into a common internal hash
associated with the last successful regular expression. Therefore mixing
integer. So this:
local $/ = \32768; # or \"32768", or \$var_containing_32768
- open my $fh, $myfile or die $!;
+ open my $fh, "<", $myfile or die $!;
local $_ = <$fh>;
will read a record of no more than 32768 bytes from FILE. If you're
you are outputting to a pipe or socket, such as when you are running
a Perl program under B<rsh> and want to see the output as it's
happening. This has no effect on input buffering. See L<perlfunc/getc>
-for that. (Mnemonic: when you want your pipes to be piping hot.)
+for that. See L<perldoc/select> on how to select the output channel.
+See also L<IO::Handle>. (Mnemonic: when you want your pipes to be piping hot.)
=item IO::Handle->output_field_separator EXPR
the regular expression.
The behaviour of C<%-> is implemented via the
-L<re::Tie::Hash::NamedCapture> module.
+L<Tie::Hash::NamedCapture> module.
B<Note:> C<%-> and C<%+> are tied views into a common internal hash
associated with the last successful regular expression. Therefore mixing
The I<object reference> to the Encode object that is used to convert
the source code to Unicode. Thanks to this variable your perl script
does not have to be written in UTF-8. Default is I<undef>. The direct
-manipulation of this variable is highly discouraged. See L<encoding>
-for more details.
+manipulation of this variable is highly discouraged.
=item $OS_ERROR
sets this variable. This means that the value of C<$!> is meaningful
only I<immediately> after a B<failure>:
- if (open(FH, $filename)) {
+ if (open my $fh, "<", $filename) {
# Here $! is meaningless.
...
} else {
Also see L<Error Indicators>.
+=item %OS_ERROR
+
+=item %ERRNO
+
=item %!
X<%!>
However, a value assigned to C<$(> must be a single number used to
set the real gid. So the value given by C<$(> should I<not> be assigned
-back to C<$(> without being forced numeric, such as by adding zero.
+back to C<$(> without being forced numeric, such as by adding zero. Note
+that this is different to the effective gid (C<$)>) which does take a
+list.
You can change both the real gid and the effective gid at the same
time by using POSIX::setgid(). Changes to $( require a check to $!
the view of C<$0> the other threads have will not change since they
have their own copies of it.
+If the program has been given to perl via the switches C<-e> or C<-E>,
+C<$0> will contain the string C<"-e">.
+
+On Linux as of perl 5.14 the legacy process name will be set with
+L<prctl(2)>, in addition to altering the POSIX name via C<argv[0]> as
+perl has done since version 4.000. Now system utilities that read the
+legacy process name such as ps, top and killall will recognize the
+name you set when assigning to C<$0>. The string you supply will be
+cut off at 16 bytes, this is a limitation imposed by Linux.
+
=item $[
X<$[>
As of release 5 of Perl, assignment to C<$[> is treated as a compiler
directive, and cannot influence the behavior of any other file.
-(That's why you can only assign compile-time constants to it.)
-Its use is highly discouraged.
+(That's why you can only assign compile-time constants to it.) Its
+use is deprecated, and by default will trigger a warning.
Note that, unlike other compile-time directives (such as L<strict>),
assignment to C<$[> can be seen from outer lexical scopes in the same file.
The current value of the flag associated with the B<-c> switch.
Mainly of use with B<-MO=...> to allow code to alter its behavior
when being compiled, such as for example to AUTOLOAD at compile
-time rather than normal, deferred loading. See L<perlcc>. Setting
+time rather than normal, deferred loading. Setting
C<$^C = 1> is similar to calling C<B::minus_c>.
=item $DEBUGGING
=item 0x02
-Line-by-line debugging.
+Line-by-line debugging. Causes DB::DB() subroutine to be called for each
+statement executed. Also causes saving source code lines (like 0x400).
=item 0x04
=item 0x400
-Debug assertion subroutines enter/exit.
+Save source code lines into C<@{"_<$filename"}>.
=back
Some bits may be relevant at compile-time only, some at
run-time only. This is a new mechanism and the details may change.
+See also L<perldebguts>.
=item $LAST_REGEXP_CODE_RESULT
=item ${^UTF8LOCALE}
-This variable indicates whether an UTF-8 locale was detected by perl at
+This variable indicates whether a UTF-8 locale was detected by perl at
startup. This information is used by perl when it's in
adjust-utf8ness-to-locale mode (as when run with the C<-CL> command-line
switch); see L<perlrun> for more info on this.
X<$^V> X<$PERL_VERSION>
The revision, version, and subversion of the Perl interpreter, represented
-as a string composed of characters with those ordinals. Thus in Perl v5.6.0
-it equals C<chr(5) . chr(6) . chr(0)> and will return true for
-C<$^V eq v5.6.0>. Note that the characters in this string value can
-potentially be greater than 255.
+as a C<version> object.
This variable first appeared in perl 5.6.0; earlier versions of perl will
-see an undefined value.
+see an undefined value. Before perl 5.10.0 $^V was represented as a v-string.
-This can be used to determine whether the Perl interpreter executing a
+$^V can be used to determine whether the Perl interpreter executing a
script is in the right range of versions. (Mnemonic: use ^V for Version
Control.) Example:
See the documentation of C<warnings> for more details.
=item ${^WIN32_SLOPPY_STAT}
+X<sitecustomize> X<sitecustomize.pl>
If this variable is set to a true value, then stat() on Windows will
not try to open the file. This means that the link count cannot be
This variable could be set in the F<sitecustomize.pl> file to
configure the local Perl installation to use "sloppy" stat() by
-default. See L<perlrun> for more information about site
+default. See the documentation for B<-f> in
+L<perlrun|perlrun/"Command Switches"> for more information about site
customization.
=item $EXECUTABLE_NAME
projects / p5sagit/p5-mst-13.2.git / blobdiff