MAN page from Old RedHat 5.X perl-5.004-4.i386.rpm
PERLDATA
Section: Perl Programmers Reference Guide (1)
Updated: perl 5.004, patch 04
Index NAME
perldata - Perl data types
DESCRIPTION
Variable names
Perl has three data structures: scalars, arrays of scalars, andassociative arrays of scalars, known as ``hashes''. Normal arrays areindexed by number, starting with 0. (Negative subscripts count fromthe end.) Hash arrays are indexed by string.
Values are usually referred to by name (or through a named reference).The first character of the name tells you to what sort of datastructure it refers. The rest of the name tells you the particularvalue to which it refers. Most often, it consists of a singleidentifier, that is, a string beginning with a letter or underscore,and containing letters, underscores, and digits. In some cases, itmay be a chain of identifiers, separated by :: (or by ', butthat's deprecated); all but the last are interpreted as names ofpackages, to locate the namespace in which to lookup the final identifier (see the Packages entry in the perlmod manpage for details).It's possible to substitute for a simple identifier an expressionwhich produces a reference to the value at runtime; this isdescribed in more detail below, and in the perlref manpage.
There are also special variables whose names don't follow theserules, so that they don't accidentally collide with one of yournormal variables. Strings which match parenthesized parts of aregular expression are saved under names containing only digits afterthe $ (see the perlop manpage and the perlre manpage). In addition, several specialvariables which provide windows into the inner working of Perl have namescontaining punctuation characters (see the perlvar manpage).
Scalar values are always named with `$', even when referring to a scalarthat is part of an array. It works like the English word ``the''. Thuswe have:
$days # the simple scalar value "days" $days[28] # the 29th element of array @days $days{'Feb'} # the 'Feb' value from hash %days $#days # the last index of array @daysbut entire arrays or array slices are denoted by `@', which works much likethe word ``these'' or ``those":
@days # ($days[0], $days[1],... $days[n]) @days[3,4,5] # same as @days[3..5] @days{'a','c'} # same as ($days{'a'},$days{'c'})and entire hashes are denoted by `%':
%days # (key1, val1, key2, val2 ...)
In addition, subroutines are named with an initial `&', though this isoptional when it's otherwise unambiguous (just as ``do'' is oftenredundant in English). Symbol table entries can be named with aninitial `*', but you don't really care about that yet.
Every variable type has its own namespace. You can, without fear ofconflict, use the same name for a scalar variable, an array, or a hash(or, for that matter, a filehandle, a subroutine name, or a label).This means that $foo and @foo are two different variables. It alsomeans that $foo[1] is a part of @foo, not a part of $foo. This mayseem a bit weird, but that's okay, because it is weird.
Because variable and array references always start with `$', `@', or `%',the ``reserved'' words aren't in fact reserved with respect to variablenames. (They ARE reserved with respect to labels and filehandles,however, which don't have an initial special character. You can't havea filehandle named ``log'', for instance. Hint: you could sayopen(LOG,'logfile') rather than open(log,'logfile'). Using uppercasefilehandles also improves readability and protects you from conflictwith future reserved words.) Case IS significant---"FOO'', ``Foo'', and``foo'' are all different names. Names that start with a letter orunderscore may also contain digits and underscores.
It is possible to replace such an alphanumeric name with an expressionthat returns a reference to an object of that type. For a descriptionof this, see the perlref manpage.
Names that start with a digit may contain only more digits. Nameswhich do not start with a letter, underscore, or digit are limited toone character, e.g., $% or $$. (Most of these one character nameshave a predefined significance to Perl. For instance, $$ is thecurrent process id.)
Context
The interpretation of operations and values in Perl sometimes dependson the requirements of the context around the operation or value.There are two major contexts: scalar and list. Certain operationsreturn list values in contexts wanting a list, and scalar valuesotherwise. (If this is true of an operation it will be mentioned inthe documentation for that operation.) In other words, Perl overloadscertain operations based on whether the expected return value issingular or plural. (Some words in English work this way, like ``fish''and ``sheep''.)
In a reciprocal fashion, an operation provides either a scalar or alist context to each of its arguments. For example, if you say
int( <STDIN> )
the integer operation provides a scalar context for the <
STDIN>operator, which responds by reading one line from
STDIN and passing itback to the integer operation, which will then find the integer valueof that line and return that. If, on the other hand, you say
sort( <STDIN> )
then the sort operation provides a list context for <
STDIN>, whichwill proceed to read every line available up to the end of file, andpass that list of lines back to the sort routine, which will thensort those lines and return them as a list to whatever the contextof the sort was.
Assignment is a little bit special in that it uses its left argument todetermine the context for the right argument. Assignment to a scalarevaluates the righthand side in a scalar context, while assignment toan array or array slice evaluates the righthand side in a listcontext. Assignment to a list also evaluates the righthand side in alist context.
User defined subroutines may choose to care whether they are beingcalled in a scalar or list context, but most subroutines do notneed to care, because scalars are automatically interpolated intolists. See the wantarray entry in the perlfunc manpage.
Scalar values
All data in Perl is a scalar or an array of scalars or a hash of scalars.Scalar variables may contain various kinds of singular data, such asnumbers, strings, and references. In general, conversion from one form toanother is transparent. (A scalar may not contain multiple values, butmay contain a reference to an array or hash containing multiple values.)Because of the automatic conversion of scalars, operations, and functionsthat return scalars don't need to care (and, in fact, can't care) whetherthe context is looking for a string or a number.
Scalars aren't necessarily one thing or another. There's no place todeclare a scalar variable to be of type ``string'', or of type ``number'', ortype ``filehandle'', or anything else. Perl is a contextually polymorphiclanguage whose scalars can be strings, numbers, or references (whichincludes objects). While strings and numbers are considered prettymuch the same thing for nearly all purposes, references are strongly-typeduncastable pointers with builtin reference-counting and destructorinvocation.
A scalar value is interpreted as TRUE in the Boolean sense if it is notthe null string or the number 0 (or its string equivalent, ``0"). TheBoolean context is just a special kind of scalar context.
There are actually two varieties of null scalars: defined andundefined. Undefined null scalars are returned when there is no realvalue for something, such as when there was an error, or at end offile, or when you refer to an uninitialized variable or element of anarray. An undefined null scalar may become defined the first time youuse it as if it were defined, but prior to that you can use thedefined() operator to determine whether the value is defined or not.
To find out whether a given string is a valid nonzero number, it's usuallyenough to test it against both numeric 0 and also lexical ``0'' (althoughthis will cause -w noises). That's because strings that aren'tnumbers count as 0, just as they do in awk:
if ($str == 0 && $str ne "0") { warn "That doesn't look like a number"; }That's usually preferable because otherwise you won't treat
IEEE notationslike
NaN or
Infinity properly. At other times you might prefer touse a regular expression to check whether data is numeric. See the
perlre manpagefor details on regular expressions.
warn "has nondigits" if /\D/; warn "not a whole number" unless /^\d+$/; warn "not an integer" unless /^[+-]?\d+$/ warn "not a decimal number" unless /^[+-]?\d+\.?\d*$/ warn "not a C float" unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
The length of an array is a scalar value. You may find the length ofarray
@days by evaluating
$#days, as in
csh. (Actually, it's notthe length of the array, it's the subscript of the last element, becausethere is (ordinarily) a 0th element.) Assigning to
$#days changes thelength of the array. Shortening an array by this method destroysintervening values. Lengthening an array that was previously shortened
NO LONGER recovers the values that were in those elements. (It used toin Perl 4, but we had to break this to make sure destructors werecalled when expected.) You can also gain some measure of efficiency bypre-extending an array that is going to get big. (You can also extendan array by assigning to an element that is off the end of the array.)You can truncate an array down to nothing by assigning the null list ()to it. The following are equivalent:
@whatever = (); $#whatever = -1;
If you evaluate a named array in a scalar context, it returns the length ofthe array. (Note that this is not true of lists, which return thelast value, like the C comma operator.) The following is always true:
scalar(@whatever) == $#whatever - $[ + 1;
Version 5 of Perl changed the semantics of
$[: files that don't setthe value of
$[ no longer need to worry about whether anotherfile changed its value. (In other words, use of
$[ is deprecated.)So in general you can assume that
scalar(@whatever) == $#whatever + 1;
Some programmers choose to use an explicit conversion so nothing'sleft to doubt:
$element_count = scalar(@whatever);
If you evaluate a hash in a scalar context, it returns a value which istrue if and only if the hash contains any key/value pairs. (If thereare any key/value pairs, the value returned is a string consisting ofthe number of used buckets and the number of allocated buckets, separatedby a slash. This is pretty much useful only to find out whether Perl's(compiled in) hashing algorithm is performing poorly on your data set.For example, you stick 10,000 things in a hash, but evaluating
%HASH inscalar context reveals ``1/16'', which means only one out of sixteen bucketshas been touched, and presumably contains all 10,000 of your items. Thisisn't supposed to happen.)
Scalar value constructors
Numeric literals are specified in any of the customary floating point orinteger formats:
12345 12345.67 .23E-10 0xffff # hex 0377 # octal 4_294_967_296 # underline for legibility
String literals are usually delimited by either single or doublequotes. They work much like shell quotes: double-quoted stringliterals are subject to backslash and variable substitution;single-quoted strings are not (except for ``
\''' and ``
\\").The usual Unix backslash rules apply for making characters such asnewline, tab, etc., as well as some more exotic forms. Seethe section on
Quote and Quotelike Operators in the
perlop manpage for a list.
Octal or hex representations in string literals (e.g. `0xffff') are notautomatically converted to their integer representation. The hex() andoct() functions make these conversions for you. See the hex entry in the perlfunc manpage andthe oct entry in the perlfunc manpage for more details.
You can also embed newlines directly in your strings, i.e., they can endon a different line than they begin. This is nice, but if you forgetyour trailing quote, the error will not be reported until Perl findsanother line containing the quote character, which may be much furtheron in the script. Variable substitution inside strings is limited toscalar variables, arrays, and array slices. (In other words,names beginning with $ or @, followed by an optional bracketedexpression as a subscript.) The following code segment prints out ``Theprice is $100.''
$Price = '$100'; # not interpreted print "The price is $Price.\n"; # interpreted
As in some shells, you can put curly brackets around the name todelimit it from following alphanumerics. In fact, an identifierwithin such curlies is forced to be a string, as is any singleidentifier within a hash subscript. Our earlier example,
$days{'Feb'}can be written as
$days{Feb}and the quotes will be assumed automatically. But anything more complicatedin the subscript will be interpreted as an expression.
Note that asingle-quoted string must be separated from a preceding word by aspace, because single quote is a valid (though deprecated) character ina variable name (see the Packages entry in the perlmod manpage).
Three special literals are __FILE__, __LINE__, and __PACKAGE__, whichrepresent the current filename, line number, and package name at thatpoint in your program. They may be used only as separate tokens; theywill not be interpolated into strings. If there is no current package(due to a package; directive), __PACKAGE__ is the undefined value.
The tokens __END__ and __DATA__ may be used to indicate the logical endof the script before the actual end of file. Any following text isignored, but may be read via a DATA filehandle: main::DATA for __END__,or PACKNAME::DATA (where PACKNAME is the current package) for __DATA__.The two control characters ^D and ^Z are synonyms for __END__ (or__DATA__ in a module). See the SelfLoader manpage for more description of__DATA__, and an example of its use. Note that you cannot read from theDATA filehandle in a BEGIN block: the BEGIN block is executed as soon asit is seen (during compilation), at which point the corresponding__DATA__ (or __END__) token has not yet been seen.
A word that has no other interpretation in the grammar willbe treated as if it were a quoted string. These are known as``barewords''. As with filehandles and labels, a bareword that consistsentirely of lowercase letters risks conflict with future reservedwords, and if you use the -w switch, Perl will warn you about anysuch words. Some people may wish to outlaw barewords entirely. If yousay
use strict 'subs';
then any bareword that would
NOT be interpreted as a subroutine callproduces a compile-time error instead. The restriction lasts to theend of the enclosing block. An inner block may countermand thisby saying
no strict 'subs'.
Array variables are interpolated into double-quoted strings by joining allthe elements of the array with the delimiter specified in the $"variable ($LIST_SEPARATOR in English), space by default. The followingare equivalent:
$temp = join($",@ARGV); system "echo $temp";
system "echo @ARGV";
Within search patterns (which also undergo double-quotish substitution)there is a bad ambiguity: Is
/$foo[bar]/ to be interpreted as
/${foo}[bar]/ (where
[bar] is a character class for the regularexpression) or as
/${foo[bar]}/ (where
[bar] is the subscript to array
@foo)? If
@foo doesn't otherwise exist, then it's obviously acharacter class. If
@foo exists, Perl takes a good guess about
[bar],and is almost always right. If it does guess wrong, or if you're justplain paranoid, you can force the correct interpretation with curlybrackets as above.
A line-oriented form of quoting is based on the shell ``here-doc''syntax. Following a << you specify a string to terminatethe quoted material, and all lines following the current line down tothe terminating string are the value of the item. The terminatingstring may be either an identifier (a word), or some quoted text. Ifquoted, the type of quotes you use determines the treatment of thetext, just as in regular quoting. An unquoted identifier works likedouble quotes. There must be no space between the << andthe identifier. (If you put a space it will be treated as a nullidentifier, which is valid, and matches the first empty line.) Theterminating string must appear by itself (unquoted and with nosurrounding whitespace) on the terminating line.
print <<EOF; The price is $Price. EOF
print <<"EOF"; # same as above The price is $Price. EOF
print <<`EOC`; # execute commands echo hi there echo lo 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. THAT
Just don't forget that you have to put a semicolon on the endto finish the statement, as Perl doesn't know you're not going totry to do this:
print <<ABC 179231 ABC + 20;
List value constructors
List values are denoted by separating individual values by commas(and enclosing the list in parentheses where precedence requires it):
(LIST)
In a context not requiring a list value, the value of the listliteral is the value of the final element, as with the C comma operator.For example,
@foo = ('cc', '-E', $bar);assigns the entire list value to array foo, but
$foo = ('cc', '-E', $bar);assigns the value of variable bar to variable foo. Note that the valueof an actual array in a scalar context is the length of the array; thefollowing assigns the value 3 to
$foo: @foo = ('cc', '-E', $bar); $foo = @foo; # $foo gets 3You may have an optional comma before the closing parenthesis of alist literal, so that you can say:
@foo = ( 1, 2, 3, );
LISTs do automatic interpolation of sublists. That is, when a
LIST isevaluated, each element of the list is evaluated in a list context, andthe resulting list value is interpolated into
LIST just as if eachindividual element were a member of
LIST. Thus arrays lose theiridentity in a
LIST---the list
(@foo,@bar,&SomeSub)
contains all the elements of
@foo followed by all the elements of
@bar,followed by all the elements returned by the subroutine named SomeSub whenit's called in a list context.To make a list reference that does
NOT interpolate, see the
perlref manpage.
The null list is represented by (). Interpolating it in a listhas no effect. Thus ((),(),()) is equivalent to (). Similarly,interpolating an array with no elements is the same as if noarray had been interpolated at that point.
A list value may also be subscripted like a normal array. You mustput the list in parentheses to avoid ambiguity. For example:
# Stat returns list value. $time = (stat($file))[8];
# SYNTAX ERROR HERE. $time = stat($file)[8]; # OOPS, FORGOT PARENTHESES
# Find a hex digit. $hexdigit = ('a','b','c','d','e','f')[$digit-10]; # A "reverse comma operator". return (pop(@foo),pop(@foo))[0];
You may assign to
undef in a list. This is useful for throwingaway some of the return values of a function:
($dev, $ino, undef, undef, $uid, $gid) = stat($file);
Lists may be assigned to if and only if each element of the listis legal to assign to:
($a, $b, $c) = (1, 2, 3);
($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);Array assignment in a scalar context returns the number of elementsproduced by the expression on the right side of the assignment:
$x = (($foo,$bar) = (3,2,1)); # set $x to 3, not 2 $x = (($foo,$bar) = f()); # set $x to f()'s return count
This is very handy when you want to do a list assignment in a Booleancontext, because most list functions return a null list when finished,which when assigned produces a 0, which is interpreted as
FALSE.
The final element may be an array or a hash:
($a, $b, @rest) = split; local($a, $b, %rest) = @_;
You can actually put an array or hash anywhere in the list, but the first onein the list will soak up all the values, and anything after it will geta null value. This may be useful in a
local() or
my().
A hash literal contains pairs of values to be interpretedas a key and a value:
# same as map assignment above %map = ('red',0x00f,'blue',0x0f0,'green',0xf00);While literal lists and named arrays are usually interchangeable, that'snot the case for hashes. Just because you can subscript a list value likea normal array does not mean that you can subscript a list value as ahash. Likewise, hashes included as parts of other lists (includingparameters lists and return lists from functions) always flatten out intokey/value pairs. That's why it's good to use references sometimes.
It is often more readable to use the => operator between key/valuepairs. The => operator is mostly just a more visually distinctivesynonym for a comma, but it also arranges for its left-hand operand to beinterpreted as a string, if it's a bareword which would be a legal identifier.This makes it nice for initializing hashes:
%map = ( red => 0x00f, blue => 0x0f0, green => 0xf00, );
or for initializing hash references to be used as records:
$rec = { witch => 'Mable the Merciless', cat => 'Fluffy the Ferocious', date => '10/31/1776', };or for using call-by-named-parameter to complicated functions:
$field = $query->radio_group( name => 'group_name', values => ['eenie','meenie','minie'], default => 'meenie', linebreak => 'true', labels => \%labels );
Note that just because a hash is initialized in that order doesn'tmean that it comes out in that order. See the
sort entry in the
perlfunc manpage for examplesof how to arrange for an output ordering.
Typeglobs and Filehandles
Perl uses an internal type called a
typeglob to hold an entiresymbol table entry. The type prefix of a typeglob is a
*, becauseit represents all types. This used to be the preferred way topass arrays and hashes by reference into a function, but now thatwe have real references, this is seldom needed. It also used to be thepreferred way to pass filehandles into a function, but nowthat we have the *foo{
THING} notation it isn't often needed for that,either. It is still needed to pass new filehandles into functions(*
HANDLE{
IO} only works if
HANDLE has already been used).
If you need to use a typeglob to save away a filehandle, do it this way:
$fh = *STDOUT;
or perhaps as a real reference, like this:
$fh = \*STDOUT;
This is also a way to create a local filehandle. For example:
sub newopen { my $path = shift; local *FH; # not my! open (FH, $path) || return undef; return *FH; } $fh = newopen('/etc/passwd');Another way to create local filehandles is with
IO::Handle and its ilk,see the bottom of the
open() entry in the
perlfunc manpage.
See the perlref manpage, the perlsub manpage, and the section on Symbol Tables in the perlmod manpage for morediscussion on typeglobs.
Index
- NAME
- DESCRIPTION
- Variable names
- Context
- Scalar values
- Scalar value constructors
- List value constructors
- Typeglobs and Filehandles
This document was created byman2html,using the manual pages.
