Perldoc Search: "$|" perl-5.20.1

search official POD


13 PODs, 27 LINEs found.
perlfunc.pod
955 :         Perl attempts to flush all files opened for output before the exec, but this may not be supported on some platforms (see perlport). To be safe, you may need to set $| ($AUTOFLUSH in English) or call the "autoflush()" method of "IO::Handle" on any open handles to avoid lost output.
1066 :         Here's an example of setting a filehandle named "REMOTE" to be non-blocking at the system level. You'll have to negotiate $| on your own, though.
1147 :         Perl attempts to flush all files opened for output before forking the child process, but this may not be supported on some platforms (see perlport). To be safe, you may need to set $| ($AUTOFLUSH in English) or call the "autoflush()" method of "IO::Handle" on any open handles to avoid duplicate output.
2004 :             select STDERR; $| = 1;  # make unbuffered
2005 :             select STDOUT; $| = 1;  # make unbuffered
2084 :         Perl will attempt to flush all files opened for output before any operation that may do a fork, but this may not be supported on some platforms (see perlport). To be safe, you may need to set $| ($AUTOFLUSH in English) or call the "autoflush()" method of "IO::Handle" on any open handles.
2122 :             $oldfh = select(HANDLE); $| = 1; select($oldfh);
2602 :         Opens a pair of connected pipes like the corresponding system call. Note that if you set up a loop of piped processes, deadlock can occur unless you are very careful. In addition, note that Perl's pipes use IO buffering, so you may need to set $| to flush your WRITEHANDLE after each command, depending on the application.
3157 :             $oldfh = select(STDERR); $| = 1; select($oldfh);
4209 :         Perl will attempt to flush all files opened for output before any operation that may do a fork, but this may not be supported on some platforms (see perlport). To be safe, you may need to set $| ($AUTOFLUSH in English) or call the "autoflush()" method of "IO::Handle" on any open handles.
perlipc.pod
128 :       $| = 1;
702 :                 $| = 1;
757 :         $| = 1;
1106 :         $| = 1;
perlop.pod
1025 :             PATTERN may contain variables, which will be interpolated every time the pattern search is evaluated, except for when the delimiter is a single quote. (Note that $(, $), and $| are not interpolated because they look like end-of-string tests.) Perl will not recompile the pattern unless an interpolated variable that it contains changes. You can force Perl to skip the test and never recompile by adding a "/o" (which stands for "once") after the trailing delimiter. Once upon a time, Perl would recompile regular expressions unnecessarily, and this modifier was useful to tell it not to do so, in the interests of speed. But now, the only reasons to use "/o" are one of:
1347 :         Perl will attempt to flush all files opened for output before starting the child process, but this may not be supported on some platforms (see perlport). To be safe, you may need to set $| ($AUTOFLUSH in English) or call the "autoflush()" method of "IO::Handle" on any open handles.
1632 :             Interpolation in patterns has several quirks: $|, $(, $), "@+" and "@-" are not interpolated, and constructs $var[SOMETHING] are voted (by several different estimators) to be either an array element or $var followed by an RE alternative. This is where the notation "${arr[$bar]}" comes handy: "/${arr[0-9]}/" is interpreted as array element -9, not as a regular expression from the variable $arr followed by a digit, which would be the interpretation of "/$arr[0-9]/". Since voting among different estimators may occur, the result is not predictable.
perlvms.pod
449 :     $|  Setting $| for an I/O stream causes data to be flushed all the way to disk on each write (*i.e.* not just to the underlying RMS buffers for a file). In other words, it's equivalent to calling fflush() and fsync() from C.
perllocale.pod
299 :             s/(\d)(\d{$grouping[0]}($|$thousands_sep))/$1$thousands_sep$2/;
perlform.pod
146 :     The current format name is stored in the variable $~ ($FORMAT_NAME), and the current top of form format name is in $^ ($FORMAT_TOP_NAME). The current output page number is stored in $% ($FORMAT_PAGE_NUMBER), and the number of lines on the page is in $= ($FORMAT_LINES_PER_PAGE). Whether to autoflush output on this handle is stored in $| ($OUTPUT_AUTOFLUSH). The string output before each top of page (except the first) is stored in $^L ($FORMAT_FORMFEED). These variables are set on a per-filehandle basis, so you'll need to select() into a different one to affect them:
perlcheat.pod
64 :        4 uid    4 month-1     4 hasargs     $|    autoflush
perlvar.pod
760 :     $|      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; $| tells you only whether you've asked Perl explicitly to flush after each write). STDOUT 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 rsh and want to see the output as it's happening. This has no effect on input buffering. See "getc" in perlfunc for that. See "select" in perlfunc on how to select the output channel. See also IO::Handle.
perlretut.pod
542 :         $year =~ /^\d{4}$|^\d{2}$/; # better match; throw out 3-digit dates
perlrequick.pod
240 :         $year =~ /^\d{4}$|^\d{2}$/; # better match; throw out 3 digit dates
perlpod.pod
61 :           =item Using C<$|> to Control Buffering
perlapio.pod
157 :         This corresponds to setlinebuf(). Does not return a value. What constitutes a "line" is implementation dependent but usually means that writing "\n" flushes the buffer. What happens with things like "this\nthat" is uncertain. (Perl core uses it *only* when "dumping"; it has nothing to do with $| auto-flush.)
perldebtut.pod
529 :             $|=1;
<< Back to Perldoc Search