|Perl Language Reference Manual|
by Larry Wall and others
Paperback (6"x9"), 724 pages
RRP £29.95 ($39.95)
Sales of this book support The Perl Foundation! Get a printed copy>>>
7.31 Quote-Like Operators
A single-quoted, literal string. A backslash represents a backslash
unless followed by the delimiter or another backslash, in which case
the delimiter or backslash is interpolated.
$foo = q!I said, "You said, 'She said it.'"!; $bar = q('This is it.'); $baz = '\n'; # a two-character string
A double-quoted, interpolated string.
$_ .= qq (*** The previous line contains the naughty word "$1".\n) if /\b(tcl|java|python)\b/i; # :-) $baz = "\n"; # a one-character string
A string which is (possibly) interpolated and then executed as a
system command with
/bin/shor its equivalent. Shell wildcards, pipes, and redirections will be honored. The collected standard output of the command is returned; standard error is unaffected. In scalar context, it comes back as a single (potentially multi-line) string, or undef if the command failed. In list context, returns a list of lines (however you've defined lines with $/ or $INPUT_RECORD_SEPARATOR), or an empty list if the command failed. Because backticks do not affect standard error, use shell file descriptor syntax (assuming the shell supports this) if you care to address this. To capture a command's STDERR and STDOUT together:
$output = `cmd 2>&1`;To capture a command's STDOUT but discard its STDERR:
$output = `cmd 2>/dev/null`;To capture a command's STDERR but discard its STDOUT (ordering is important here):
$output = `cmd 2>&1 1>/dev/null`;To exchange a command's STDOUT and STDERR in order to capture the STDERR but leave its STDOUT to come out the old STDERR:
$output = `cmd 3>&1 1>&2 2>&3 3>&-`;To read both a command's STDOUT and its STDERR separately, it's easiest to redirect them separately to files, and then read from those files when the program is done:
system("program args 1>program.stdout 2>program.stderr");The STDIN filehandle used by the command is inherited from Perl's STDIN. For example:
open BLAM, "blam" || die "Can't open: $!"; open STDIN, "<&BLAM"; print `sort`;will print the sorted contents of the file "blam". Using single-quote as a delimiter protects the command from Perl's double-quote interpolation, passing it on to the shell instead:
$perl_info = qx(ps $$); # that's Perl's $$ $shell_info = qx'ps $$'; # that's the new shell's $$How that string gets evaluated is entirely subject to the command interpreter on your system. On most platforms, you will have to protect shell metacharacters if you want them treated literally. This is in practice difficult to do, as it's unclear how to escape which characters. See 22 for a clean and safe example of a manual fork() and exec() to emulate backticks safely. On some platforms (notably DOS-like ones), the shell may not be capable of dealing with multiline commands, so putting newlines in the string may not get you what you want. You may be able to evaluate multiple commands in a single line by separating them with the command separator character, if your shell supports that (e.g.
;on many Unix shells;
&on the Windows NT
cmdshell). Beginning with v5.6.0, 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 28). To be safe, you may need to set
$|($AUTOFLUSH in English) or call the
IO::Handleon any open handles. Beware that some command shells may place restrictions on the length of the command line. You must ensure your strings don't exceed this limit after any necessary interpolations. See the platform-specific release notes for more details about your particular environment. Using this operator can lead to programs that are difficult to port, because the shell commands called vary between systems, and may in fact not be present at all. As one example, the
typecommand under the POSIX shell is very different from the
typecommand under DOS. That doesn't mean you should go out of your way to avoid backticks when they're the right way to get something done. Perl was made to be a glue language, and one of the things it glues together is commands. Just understand what you're getting yourself into. See 7.33 for more discussion.
Evaluates to a list of the words extracted out of STRING, using embedded
whitespace as the word delimiters. It can be understood as being roughly
split(' ', q/STRING/);the differences being that it generates a real list at compile time, and in scalar context it returns the last element in the list. So this expression:
qw(foo bar baz)is semantically equivalent to the list:
'foo', 'bar', 'baz'Some frequently seen examples:
use POSIX qw( setlocale localeconv ) @EXPORT = qw( foo bar baz );A common mistake is to try to separate the words with comma or to put comments into a multi-line
qw-string. For this reason, the
use warningspragma and the -w switch (that is, the
$^Wvariable) produces warnings if the STRING contains the "," or the "#" character.
Transliterates all occurrences of the characters found in the search list
with the corresponding character in the replacement list. It returns
the number of characters replaced or deleted. If no string is
specified via the =~ or !~ operator, the $_ string is transliterated. (The
string specified with =~ must be a scalar variable, an array element, a
hash element, or an assignment to one of those, i.e., an lvalue.)
A character range may be specified with a hyphen, so
tr/A-J/0-9/does the same replacement as
tr/ACEGIBDFHJ/0246813579/. For sed devotees,
yis provided as a synonym for
tr. If the SEARCHLIST is delimited by bracketing quotes, the REPLACEMENTLIST has its own pair of quotes, which may or may not be bracketing quotes, e.g.,
tr(+\-*/)/ABCD/. Note that
trdoes not do regular expression character classes such as
troperator is not equivalent to the tr(1) utility. If you want to map strings between lower/upper cases, see and , and in general consider using the
soperator if you need regular expressions. Note also that the whole range idea is rather unportable between character sets--and even within character sets they may cause results you probably didn't expect. A sound principle is to use only ranges that begin from and end at either alphabets of equal case (a-e, A-E), or digits (0-4). Anything else is unsafe. If in doubt, spell out the character sets in full. Options:
c Complement the SEARCHLIST. d Delete found but unreplaced characters. s Squash duplicate replaced characters.If the
/cmodifier is specified, the SEARCHLIST character set is complemented. If the
/dmodifier is specified, any characters specified by SEARCHLIST not found in REPLACEMENTLIST are deleted. (Note that this is slightly more flexible than the behavior of some tr programs, which delete anything they find in the SEARCHLIST, period.) If the
/smodifier is specified, sequences of characters that were transliterated to the same character are squashed down to a single instance of the character. If the
/dmodifier is used, the REPLACEMENTLIST is always interpreted exactly as specified. Otherwise, if the REPLACEMENTLIST is shorter than the SEARCHLIST, the final character is replicated till it is long enough. If the REPLACEMENTLIST is empty, the SEARCHLIST is replicated. This latter is useful for counting characters in a class or for squashing character sequences in a class. Examples:
$ARGV =~ tr/A-Z/a-z/; # canonicalize to lower case $cnt = tr/*/*/; # count the stars in $_ $cnt = $sky =~ tr/*/*/; # count the stars in $sky $cnt = tr/0-9//; # count the digits in $_ tr/a-zA-Z//s; # bookkeeper -> bokeper ($HOST = $host) =~ tr/a-z/A-Z/; tr/a-zA-Z/ /cs; # change non-alphas to single space tr [\200-\377] [\000-\177]; # delete 8th bitIf multiple transliterations are given for a character, only the first one is used:
tr/AAA/XYZ/will transliterate any A to X. Because the transliteration table is built at compile time, neither the SEARCHLIST nor the REPLACEMENTLIST are subjected to double quote interpolation. That means that if you want to use variables, you must use an eval():
eval "tr/$oldlist/$newlist/"; die $@ if $@; eval "tr/$oldlist/$newlist/, 1" or die $@;
A line-oriented form of quoting is based on the shell "here-document"
syntax. Following a
<<you specify a string to terminate the quoted material, and all lines following the current line down to the terminating string are the value of the item. The terminating string may be either an identifier (a word), or some quoted text. An unquoted identifier works like double quotes. There may not be a space between the
<<and the identifier, unless the identifier is explicitly quoted. (If you put a space it will be treated as a null identifier, which is valid, and matches the first empty line.) The terminating string must appear by itself (unquoted and with no surrounding whitespace) on the terminating line. If the terminating string is quoted, the type of quotes used determine the treatment of the text.
Double quotes indicate that the text will be interpolated using exactly
the same rules as normal double quoted strings.
print <<EOF; The price is $Price. EOF print << "EOF"; # same as above The price is $Price. EOF
Single quotes indicate the text is to be treated literally with no
interpolation of its content. This is similar to single quoted
strings except that backslashes have no special meaning, with
\\being treated as two backslashes and not one as they would in every other quoting construct. This is the only form of quoting in perl where there is no need to worry about escaping content, something that code generators can and do make good use of.
The content of the here doc is treated just as it would be if the
string were embedded in backticks. Thus the content is interpolated
as though it were double quoted and then executed via the shell, with
the results of the execution returned.
print << `EOC`; # execute command and get results echo hi there EOC
print <<"foo", <<"bar"; # you can stack them I said foo. foo I said bar. bar myfunc(<< "THIS", 23, <<'THAT'); Here's a line or two. THIS and here's another. THATJust don't forget that you have to put a semicolon on the end to finish the statement, as Perl doesn't know you're not going to try to do this:
print <<ABC 179231 ABC + 20;If you want to remove the line terminator from your here-docs, use
chomp($string = <<'END'); This is a string. ENDIf you want your here-docs to be indented with the rest of the code, you'll need to remove leading whitespace from each line manually:
($quote = <<'FINIS') =~ s/^\s+//gm; The Road goes ever on and on, down from the door where it began. FINISIf you use a here-doc within a delimited construct, such as in
s///eg, the quoted material must come on the lines following the final delimiter. So instead of
s/this/<<E . 'that' the other E . 'more '/eg;you have to write
s/this/<<E . 'that' . 'more '/eg; the other EIf the terminating identifier is on the last line of the program, you must be sure there is a newline after it; otherwise, Perl will give the warning Can't find string terminator "END" anywhere before EOF.... Additionally, the quoting rules for the end of string identifier are not related to Perl's quoting rules.
qq(), and the like are not supported in place of
"", and the only interpolation is for backslashing the quoting character:
print << "abc\"def"; testing... abc"defFinally, quoted strings cannot span multiple lines. The general rule is that the identifier must be a string literal. Stick with that, and you should be safe.
|ISBN 9781906966027||Perl Language Reference Manual||See the print edition|