International English version Traditional Chinese version
Domain Registration with Web HostingWeb site Hosting with Various supportRegistrar Transfer with Web Hosting

Data types and objects in PERL

Perl has three data types: scalars, arrays of scalars, and associative arrays of scalars. Normal arrays are indexed by number, and associative arrays by string.

The interpretation of operations and values in perl sometimes depends on the requirements of the context around the operation or value. There are three major contexts: string, numeric and array. Certain operations return array values in contexts wanting an array, and scalar values otherwise. (If this is true of an operation it will be mentioned in the documentation for that operation.) Operations which return scalars don't care whether the context is looking for a string or a number, but scalar variables and values are interpreted as strings or numbers as appropriate to the context. A scalar is interpreted as TRUE in the boolean sense if it is not the null string or 0. Booleans returned by operators are 1 for true and 0 or '' (the null string) for false.

There are actually two varieties of null string: defined and undefined. Undefined null strings are returned when there is no real value for something, such as when there was an error, or at end of file, or when you refer to an uninitialized variable or element of an array. An undefined null string may become defined the first time you access it, but prior to that you can use the defined() operator to determine whether the value is defined or not.

References to scalar variables always begin with '$', even when referring to a scalar that is part of an array. Thus:

    $days		# a simple scalar variable
    $days[28]		# 29th element of array @days
    $days{'Feb'}	# one value from an associative array
    $#days		# last index of array @days
but entire arrays or array slices are denoted by '@':
    @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 associative arrays are denoted by '%':
    %days		# (key1, val1, key2, val2 ...)
Any of these eight constructs may serve as an lvalue, that is, may be assigned to. (It also turns out that an assignment is itself an lvalue in certain contexts -- see examples under s, tr and chop.) Assignment to a scalar evaluates the righthand side in a scalar context, while assignment to an array or array slice evaluates the righthand side in an array context.

You may find the length of array @days by evaluating "$#days", as in csh. (Actually, it's not the length of the array, it's the subscript of the last element, since there is (ordinarily) a 0th element.) Assigning to $#days changes the length of the array. Shortening an array by this method does not actually destroy any values. Lengthening an array that was previously shortened recovers the values that were in those elements. You can also gain some measure of efficiency by preextending an array that is going to get big. (You can also extend an array by assigning to an element that is off the end of the array. This differs from assigning to $#whatever in that intervening values are set to null rather than recovered.) You can truncate an array down to nothing by assigning the null list () to it. The following are exactly equivalent

   @whatever = ();
   $#whatever = $[ - 1;
If you evaluate an array in a scalar context, it returns the length of the array. The following is always true:
   scalar(@whatever) == $#whatever - $[ + 1;
If you evaluate an associative array in a scalar context, it returns a value which is true if and only if the array contains any elements. (If there are any elements, the value returned is a string consisting of the number of used buckets and the number of allocated buckets, separated by a slash.)

Multi-dimensional arrays are not directly supported, but see the discussion of the $; variable later for a means of emulating multiple subscripts with an associative array. You could also write a subroutine to turn multiple subscripts into a single subscript.

Every data type has its own namespace. You can, without fear of conflict, use the same name for a scalar variable, an array, an associative array, a filehandle, a subroutine name, and/or a label. Since variable and array references always start with '$', '@', or '%', the "reserved" words aren't in fact reserved with respect to variable names. (They ARE reserved with respect to labels and filehandles, however, which don't have an initial special character. Hint: you could say open(LOG,'logfile') rather than open(log,'logfile'). Using uppercase filehandles also improves readability and protects you from conflict with future reserved words.) Case IS significant--"FOO", "Foo" and "foo" are all different names. Names which start with a letter may also contain digits and underscores. Names which do not start with a letter are limited to one character, e.g. "$%" or "$$". (Most of the one character names have a predefined significance to perl. More later.)

Numeric literals are specified in any of the usual floating point or integer formats:

   0xffff		# hexidecimal number
   0377		# octal number
String literals are delimited by either single or double quotes. They work much like shell quotes: double-quoted string literals are subject to backslash and variable substitution; single-quoted strings are not (except for \' and \e). The usual backslash rules apply for making characters such as newline, tab, etc., as well as some more exotic forms:
   \t	tab
   \n	newline
   \r	return
   \f	form feed
   \b	backspace
   \a	alarm (bell)
   \e	escape
   \033	octal char
   \x1b	hex char
   \c[	control char
   \l	lowercase next char
   \u	uppercase next char
   \L	lowercase till \E
   \U	uppercase till \E
   \E	end case modification
You can also embed newlines directly in your strings, i.e. they can end on a different line than they begin. This is nice, but if you forget your trailing quote, the error will not be reported until perl finds another line containing the quote character, which may be much further on in the script. Variable substitution inside strings is limited to scalar variables, normal array values, and array slices. (In other words, identifiers beginning with $ or @, followed by an optional bracketed expression as a subscript.) The following code segment prints out "The price is $100."
    $Price = '$100';		# not interpreted
    print "The price is $Price.\n";	# interpreted
Note that you can put curly brackets around the identifier to delimit it from following alphanumerics. Also note that a single quoted string must be separated from a preceding word by a space, since single quote is a valid character in an identifier (see packages).

Two special literals are __LINE__ and __FILE__, which represent the current line number and filename at that point in your program. They may only be used as separate tokens; they will not be interpolated into strings. In addition, the token __END__ may be used to indicate the logical end of the script before the actual end of file. Any following text is ignored, but may be read via the DATA filehandle. (The DATA filehandle may read data only from the main script, but not from any required file or evaluated string.) The two control characters ^D and ^Z are synonyms for __END__.

A word that doesn't have any other interpretation in the grammar will be treated as if it had single quotes around it. For this purpose, a word consists only of alphanumeric characters and underline, and must start with an alphabetic character. As with filehandles and labels, a bare word that consists entirely of lowercase letters risks conflict with future reserved words, and if you use the -w switch, perl will warn you about any such words.

Array values are interpolated into double-quoted strings by joining all the elements of the array with the delimiter specified in the $" variable, space by default. (Since in versions of perl prior to 3.0 the @ character was not a metacharacter in double-quoted strings, the interpolation of @array, $array[EXPR], @array[LIST], $array{EXPR}, or @array{LIST} only happens if array is referenced elsewhere in the program or is predefined.) The following are 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 regular expression) or as /${foo[bar]}/ (where [bar] is the subscript to array @foo)? If @foo doesn't otherwise exist, then it's obviously a character 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 just plain paranoid, you can force the correct interpretation with curly brackets as above.

A line-oriented form of quoting is based on the shell here-is 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. If quoted, the type of quotes you use determines the treatment of the text, just as in regular quoting. An unquoted identifier works like double quotes. There must be no space between the << and the identifier. (If you put a space it will be treated as a null identifier, which is valid, and matches the first blank line--see Merry Christmas example below.) The terminating string must appear by itself (unquoted and with no surrounding whitespace) on the terminating line.

   print <<EOF;  # same as above
The price is $Price.

   print <<"EOF";  # same as above
The price is $Price.

   print << x 10;  # null identifier is delimiter
Merry Christmas!

   print <<`EOC`;  # execute commands
echo hi there
echo lo there

   print <<foo, <<bar;   # you can stack them
I said foo.
I said bar.
Array literals are denoted by separating individual values by commas, and enclosing the list in parentheses:
In a context not requiring an array value, the value of the array literal is the value of the final element, as in the C comma operator. For example,
    @foo = ('cc', '-E', $bar);
assigns the entire array value to array foo, but
    $foo = ('cc', '-E', $bar);
assigns the value of variable bar to variable foo. Note that the value of an actual array in a scalar context is the length of the array; the following assigns to $foo the value 3:
    @foo = ('cc', '-E', $bar);
    $foo = @foo;		# $foo gets 3
You may have an optional comma before the closing parenthesis of an array literal, so that you can say:
    @foo = (
When a LIST is evaluated, each element of the list is evaluated in an array context, and the resulting array value is interpolated into LIST just as if each individual element were a member of LIST. Thus arrays lose their identity in a LIST--the list
contains all the elements of @foo followed by all the elements of @bar, followed by all the elements returned by the subroutine named SomeSub.

A list value may also be subscripted like a normal array. For example,

   $time = (stat($file))[8]; # stat returns array value
   $digit = ('a','b','c','d','e','f')[$digit-10];
   return (pop(@foo),pop(@foo))[0];
Array lists may be assigned to if and only if each element of the list is an lvalue:
   ($a, $b, $c) = (1, 2, 3);
   ($map{'red'}, $map{'blue'}, $map{'green'}) =
        (0x00f, 0x0f0, 0xf00);
The final element may be an array or an associative array,
   ($a, $b, @rest) = split;
   local($a, $b, %rest) = @_;
You can actually put an array anywhere in the list, but the first array in the list will soak up all the values, and anything after it will get a null value. This may be useful in a local().

An associative array literal contains pairs of values to be interpreted as a key and a value:

   # same as map assignment above
   %map = ('red',0x00f,'blue',0x0f0,'green',0xf00);
Array assignment in a scalar context returns the number of elements produced by the expression on the right side of the assignment:
   $x = (($foo,$bar) = (3,2,1)); # set $x to 3, not 2
There are several other pseudo-literals that you should know about. If a string is enclosed by backticks (grave accents), it first undergoes variable substitution just like a double quoted string. It is then interpreted as a command, and the output of that command is the value of the pseudo-literal, like in a shell. In a scalar context, a single string consisting of all the output is returned. In an array context, an array of values is returned, one for each line of output. (You can set $/ 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 $? (see predefined names for the interpretation of $?). Unlike in 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 $ through to the shell you need to hide it with a backslash.

Evaluating a filehandle in angle brackets yields the next line from that file (newline included, so it's never false until EOF, at which time an undefined value is returned). Ordinarily you must assign that value to a variable, but there is one situation where an automatic assignment happens. If (and only if) the input symbol is the only thing inside the conditional of a while-loop, the value is automatically assigned to the variable "$_". (This may seem like an odd thing to you, but you'll use the construct in almost every perl script you write.) Anyway, the following lines are equivalent to each other,

   while ($_ = <STDIN>) { print; }
   while (<STDIN>) { print; }
   for (;<STDIN>;) { print; }
   print while $_ = <STDIN>;
   print while <STDIN>;
The filehandles STDIN, STDOUT and STDERR are predefined. (The filehandles stdin, stdout and stderr will also work except in packages, where they would be interpreted as local identifiers rather than global.) Additional filehandles may be created with the open function.

If a <FILEHANDLE> is used in a context that is looking for an array, an array consisting of all the input lines is returned, one line per array element. It's easy to make a LARGE data space this way, so use with care.

The null filehandle <> is special and can be used to emulate the behavior of sed and awk. Input from <> comes either from standard input, or from each file listed on the command line. Here's how it works: the first time <> is evaluated, the ARGV array is checked, and if it is null, $ARGV[0] is set to '-', which when opened gives you standard input. The ARGV array is then processed as a list of filenames. The loop

   while (<>) {
   ...			# code for each line
is equivalent to the following Perl-like pseudo code:
   unshift(@ARGV, '-') if $#ARGV < $[;
   while ($ARGV = shift) {
      open(ARGV, $ARGV);
      while (<ARGV>) {
         ...	# code for each line
except that it isn't as cumbersome to say, and will actually work. It really does shift array ARGV and put the current filename into variable ARGV. It also uses filehandle ARGV internally--<> is just a synonym for <ARGV>, which is magical. (The pseudo code above doesn't work because it treats <ARGV> as non-magical.)

You can modify @ARGV before the first <> as long as the array ends up containing the list of filenames you really want. Line numbers ($.) continue as if the input was one big happy file. (But see example under eof for how to reset line numbers on each file.)

If you want to set @ARGV to your own list of files, go right ahead. If you want to pass switches into your script, you can put a loop on the front like this:

   while ($_ = $ARGV[0], /^-/) {
      last if /^--$/;
      /^-D(.*)/ && ($debug = $1);
      /^-v/ && $verbose++;
      ...		# other switches
   while (<>) {
      ...		# code for each line
The <> symbol will return FALSE only once. If you call it again after this it will assume you are processing another @ARGV list, and if you haven't set @ARGV, will input from STDIN.

If the string inside the angle brackets is a reference to a scalar variable (e.g. <$foo>), then that variable contains the name of the filehandle to input from.

If the string inside angle brackets is not a filehandle, it is interpreted as a filename pattern to be globbed, and either an array of filenames or the next filename in the list is returned, depending on context. One level of $ interpretation is done first, but you can't say <$foo> because that's an indirect filehandle as explained in the previous paragraph. You could insert curly brackets to force interpretation as a filename glob: <${foo}>.

For example

   while (<*.c>) {
      chmod 0644, $_;
is equivalent to
      "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'");
   while (<foo>) {
      chmod 0644, $_;
In fact, it's currently implemented that way, and we do have /bin/csh on our servers. Of course, the shortest way to do the above is:
   chmod 0644, <*.c>;

Click here to go back to the Perl index

Home | Support | Check | Host | Transfer | Whois | More Technology Services

© 1996-2008 Wyith Ltd dba All rights reserved.

Canada | USA | UK | Belgium | Italy | Hongkong | Singapore