Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! negation operator (see negation operator)
# pound sign, What’s Inside That Program?
#! line, What’s Inside That Program?, A Whirlwind Tour of Perl
#!perl, What’s Inside That Program?
$ dollar sign (see dollar sign)
$! variable, Fatal Errors with die
$& variable, The Automatic Match Variables
$' variable, The Automatic Match Variables
$0 variable, The Invocation Arguments, Fatal Errors with die
$ARGV variable, Input from the Diamond Operator
$atime (timestamp), The stat and lstat Functions
changing, Changing Timestamps
$ctime (timestamp), The stat and lstat Functions
changing, Changing Timestamps
$dev (device number), The stat and lstat Functions
$gid (see group-ID)
$ino (inode number), The stat and lstat Functions
$mode, The stat and lstat Functions
$mtime (timestamp), The stat and lstat Functions
changing, Changing Timestamps
$nlink (number of links), The stat and lstat Functions
$now variable, Using Backquotes to Capture Output
$size, The stat and lstat Functions
$uid (see user-ID, numeric)
$^I variable, Variable-length (Text) Databases
$_ default variable (see default variable)
$` variable, The Automatic Match Variables
$” variable, Interpolating Arrays into Strings
% modulus operator, Numeric Operators, Picking Items from a List with grep
% percent sign (see percent sign)
%d conversion, Formatted Output with printf
%ENV hash, The Environment Variables
%f conversion, Formatted Output with printf
%g conversion, Formatted Output with printf
%s conversion, Formatted Output with printf
& ampersand, Invoking a Subroutine, Omitting the Ampersand
&& operator, Logical Operators, Control Structures Using Partial-Evaluation Operators
&max subroutine, Arguments, A Better &max Routine
' ' single quotes, Single-Quoted String Literals
( ) parentheses (see parentheses)
* multiplication operator, Numeric Operators
* star, Simple Quantifiers
** exponentiation operator, Numeric Operators
**= raise to the power of operator, Binary Assignment Operators
+ addition operator, Numeric Operators
+ plus sign, Simple Quantifiers
++ autoincrement operator, Autoincrement and Autodecrement–The Value of Autoincrement
, comma, The Big Arrow
- hyphen, Input from the Diamond Operator, Character Classes
- subtraction operator, Numeric Operators
-- autodecrement operator, Autoincrement and Autodecrement
-> little arrow, The Big Arrow, The File::Spec Module
-e command-line option, In-place Editing from the Command Line
-eval option, find2perl command and, Converting find Command Lines to Perl
-i.bak command-line option, In-place Editing from the Command Line
-n command-line option, In-place Editing from the Command Line
-p command-line option, In-place Editing from the Command Line
-w option, Perl’s Built-in Warnings, In-place Editing from the Command Line
vs. warnings pragma, The warnings Pragma
. dot (see dot)
. operator, String Operators
. string concatenate operator, Binary Assignment Operators
.. dot-dot, Links and Files
.. range operator, List Literals
./ dot and slash, A Simple Program
.= append operator, Binary Assignment Operators
.new files, renaming from .old files, Renaming Files
.old files, renaming to .new files, Renaming Files
.plx file extension, A Simple Program
.pm files, What Are Regular Expressions?
/ division operator, Numeric Operators
/g modifier, s/// substitution operator and, Global Replacements with /g
/i modifier, Case-insensitive Matching with /i
s/// substitution operator and, Option Modifiers
/m option, Matching Multiple-line Text
/s modifier, Matching Any Character with /s
s/// substitution operator and, Option Modifiers
/usr/bin/perl, What’s Inside That Program?
/usr/local/bin/perl, What’s Inside That Program?
; semicolon (see semicolon)
< less-than sign, Opening a Filehandle
= assignment operator, Scalar Assignment
=> big arrow, The Big Arrow, Unquoted Hash Keys
=~ binding operator, The Binding Operator, =~
> greater-than sign, Opening a Filehandle
? question mark, Simple Quantifiers
?: ternary operator, The Ternary Operator, ?:
@ at-sign, List Assignment
@ARGV array, The Invocation Arguments
@lines array variable, A Whirlwind Tour of Perl
@_ array variable, Arguments–Arguments
[ ] square brackets, A Pattern Test Program, Character Classes
backslash, Single-Quoted String Literals, Backreferences
B nonword-boundary anchor, Word Anchors
 word-boundary anchor, Word Anchors
d shortcut, Character Class Shortcuts
D shortcut, Negating the Shortcuts
E shortcut, Case Shifting
L shortcut, Case Shifting
l shortcut, Case Shifting
shortcut, What’s Inside That Program?
within a single-quoted string, Single-Quoted String Literals
s shortcut, Character Class Shortcuts
S shortcut, Negating the Shortcuts
U shortcut, Case Shifting
u shortcut, Case Shifting
w characters, Word Anchors
w shortcut, Character Class Shortcuts
W shortcut, Negating the Shortcuts
^ caret anchor, Anchors
_ filehandle, Using the Special Underscore Filehandle
_ underscore, Integer Literals, The use strict Pragma
_ _FILE_ _ and _ _LINE_ _ tokens, Fatal Errors with die
__END__ marker, The last Operator
` ` backquotes/backticks, A Whirlwind Tour of Perl, Using Backquotes to Capture Output–Using Backquotes in a List Context
`Hello, world’ program, A Simple Program
`wimla,’ diamond operator and, Input from the Diamond Operator
{ } curly braces (see curly braces)
| pipe, What Is a Filehandle?, Processes as Filehandles
| vertical bar, Alternatives
|| operator (see OR operator)
~ tilde, Variable-length (Text) Databases
~ tilde-prefix, Moving Around the Directory Tree
“money numbers” (see decimals)
“short-circuit” logical operators, Logical Operators
“” double quotes (see double quotes)

A

a2p conversion program, Converting Other Languages to Perl
absolute value, Advanced Math Functions
addition operator (+), Numeric Operators
ampersand (&)
in subroutine names, Invoking a Subroutine
omitting, Omitting the Ampersand
anchors, Anchors
multiple-line text and, Matching Multiple-line Text
AND operator (&&), Logical Operators, Control Structures Using Partial-Evaluation Operators
angle brackets, A Whirlwind Tour of Perl, An Alternate Syntax for Globbing
angle brackets (), A Whirlwind Tour of Perl
filename globbing and, An Alternate Syntax for Globbing
anonymous subroutines, Anonymous Subroutines and Closures
answers to exercises in this book, Exercise Answers–Answer to Chapter 17 Exercises
AnyDBM_file manpage, DBM Files and DBM Hashes
append operator (.=), Binary Assignment Operators
argc, The Invocation Arguments
argument lists (see parameter lists)
arguments, Arguments–Arguments
array elements, Accessing Elements of an Array
array indices, Special Array Indices
arrays, Lists and Arrays –Exercises, Lists and Arrays
interpolating vs. printing, Output to Standard Output
printf function and, Arrays and printf
slices and, Array Slice
splice operator for, The splice Operator
arrows, The Big Arrow, Unquoted Hash Keys
ASCII mode, How Do I Make a Perl Program?
ASCIIbetical order, sort operator for, The sort Operator
assigning
hashes, Hash Assignment
lists, List Assignment–The shift and unshift Operators
scalars, Scalar Assignment
assignment operator (=), Scalar Assignment
associative arrays (see hashes)
associativity, Operator Precedence and Associativity–Operator Precedence and Associativity
chart of, Operator Precedence and Associativity
at-sign(@) indicating arrays, List Assignment
autodecrement operator (--), Autoincrement and Autodecrement
autoincrement operator (++), Autoincrement and Autodecrement–The Value of Autoincrement
automatic match variables, The Automatic Match Variables

B

backquotes/backticks (` `)
capturing output with, Using Backquotes to Capture Output–Using Backquotes in a List Context
enclosing external commands, A Whirlwind Tour of Perl
backreferences, Backreferences
backslash (), Single-Quoted String Literals
in backreferences, Backreferences
backslash escapes, What’s Inside That Program?, Hash Element Interpolation
list of, Double-Quoted String Literals
backup files, text databases and, Variable-length (Text) Databases
bad filehandles, Bad Filehandles
barewords, Unquoted Hash Keys
basenames, Using Simple Modules–Using Only Some Functions from a Module
File::Basename module for, The File::Basename Module–Using Only Some Functions from a Module, The File::Basename Module
BEGIN block, Syntax Extensions
big arrow (=>), The Big Arrow, Unquoted Hash Keys
binary assignment operators, Binary Assignment Operators
binary extensions, dynamic loading and, Dynamic Loading
binary mode, How Do I Make a Perl Program?
binding operator (=~), The Binding Operator, =~
s/// substitution operator and, The Binding Operator
bitstrings, Using Bitstrings
vec operator for, Bits and Pieces
bitwise operators, Bitwise Operators–Using Bitstrings
block comments, What’s Inside That Program?
block curly braces (see curly braces, block)
body of subroutine, Defining a Subroutine
Boolean values
as handled by Perl, Boolean Values
logical operators for, Logical Operators–Control Structures Using Partial-Evaluation Operators
buffer
flushing of, Output to Standard Output, Changing the Default Output Filehandle
stat, Using the Special Underscore Filehandle
buffered output, Output to Standard Output
bugs in Perl, How Can I Get Support for Perl?
reporting, What If I Find a Bug in Perl?
builtin functions
ampersand and, Omitting the Ampersand
mathematical functions and, Advanced Math Functions
builtin variables, The Automatic Match Variables, Built in Variables
bytecodes, But How Do I Compile Perl?
B::Lint module, Debugging

C

C programming language
DBM files and, Using a DBM Hash
operators and, The Ternary Operator, ?:
caller function, Fatal Errors with die
Camel book, Why Didn’t Larry Just Use Some Other Language?, Are There Any Other Kinds of Support?
capitalization
case shifting and, Case Shifting
vs. lowercase in variable names, Choosing Good Variable Names
caret anchor (^) indicating beginning of string, Anchors
case shifting, Case Shifting
case-insensitive matching, /i modifier for, Case-insensitive Matching with /i
cd command (Unix), Moving Around the Directory Tree
CGI module, The CGI and CGI_Lite Modules, The Common Gateway Interface (CGI)
CGI_Lite module, The CGI and CGI_Lite Modules, The Common Gateway Interface (CGI)
character classes, Character Classes–Negating the Shortcuts
characters, Strings
case shifting and, Case Shifting
matching with /s modifier, Matching Any Character with /s
transliterating/counting with tr/// operator, Transliteration with tr///
chdir operator, Moving Around the Directory Tree
child processes, managing, Process Management–Exercises
chmod command (Unix), A Simple Program, Modifying Permissions
chmod function (Unix), Modifying Permissions
chomp operator, The chomp Operator
chown function, Changing Ownership
chunk number, die function and, Fatal Errors with die
classes, The File::Spec Module
close operator, Closing a Filehandle
closedir operator, Directory Handles
closures, Anonymous Subroutines and Closures
cmp (three-way comparison operator), Advanced Sorting
code, The last Operator
compiling, But How Do I Compile Perl?
curly braces enclosing, The if Control Structure, The while Control Structure
dynamic loading and, Dynamic Loading
embedding, Embedding
last operator for exiting early, The last Operator
reading, Expression Modifiers
used in this book, web site for, Code Examples
while control structure for repeating blocks of, The while Control Structure
comma (,), The Big Arrow
command line, in-place editing from, In-place Editing from the Command Line
command-line options, Command-Line Options
modules for, Command-line Options in Your Programs
comments, What’s Inside That Program?
comp.lang.perl.moderated newsgroup, Are There Any Other Kinds of Support?
comparison operators, Comparison Operators, Advanced Sorting
compiling code, But How Do I Compile Perl?
complex data structures, Complex Data Structures
complex numbers, Imaginary and Complex Numbers
Comprehensive Perl Archive Network (see CPAN)
constant pragma, The constant Pragma
context, Scalar and List Context, Scalar and List Context
void, Return Values
continue block, The for Control Structure, The next Operator, Syntax Extensions
control structures, More Control Structures–Exercise
loop controls for, Loop Controls–Labeled Blocks
partial-evaluation operators for, Control Structures Using Partial-Evaluation Operators–Control Structures Using Partial-Evaluation Operators
stopping endless loops created by, The while Control Structure
conversion programs, Converting Other Languages to Perl
conversions, Formatted Output with printf
cosine, Advanced Math Functions
CPAN (Comprehensive Perl Archive Network), What Is CPAN?
inside utility available from, Finding and Installing Modules
libraries available from, Finding and Installing Modules
modules available from, Using Simple Modules, Finding and Installing Modules
curly braces ({ })
block, enclosing code, The if Control Structure, The while Control Structure
enclosing hash keys, Hash Element Access
enclosing variable names, Interpolation of Scalar Variables into Strings
following hash names, Hash Element Access
indicating quantifier, General Quantifiers
current working directory, The Cwd Module
cwd function, The Cwd Module
Cwd module, The Cwd Module

D

data
formatting with sprintf function, Formatting Data with sprintf–Using sprintf with “Money Numbers”
manipulating with pack and unpack functions, Manipulating Data with pack and unpack
data structures, complex, Complex Data Structures
data-flow analysis, Security
databases, Simple Databases–Exercises, Databases
DBI module and, Relational Database Access
files for, read/write access to, Fixed-length Random-access Databases
fixed-length random-access, Fixed-length Random-access Databases–Fixed-length Random-access Databases
hashes and, Why Use a Hash?
variable-length text, Variable-length (Text) Databases–In-place Editing from the Command Line
date command (Unix), The system Function, Variable-length (Text) Databases
capturing output and, Using Backquotes to Capture Output–Processes as Filehandles
DBI module, Relational Database Access
DBM files, DBM Files and DBM Hashes–Using a DBM Hash, Tied Variables
DBM hashes, DBM Files and DBM Hashes–Using a DBM Hash, Tied Variables
dbmclose function, Opening and Closing DBM Hashes
dbmopen function, Opening and Closing DBM Hashes
debugger for Perl, Debugging
decimal integer conversion, Formatted Output with printf
decimals
formatting for output, Transforming Items from a List with map
rounding
printf function and, Formatted Output with printf
sprintf function and, Using sprintf with “Money Numbers”–Using sprintf with “Money Numbers”
default variable ($_), Perl’s Favorite Default: $_
=~ binding operator and, The Binding Operator, =~
input stored in, Input from Standard Input
defaults, Is Perl Easy or Hard?
output filehandle, Changing the Default Output Filehandle
defined function, The defined Function, Changing Ownership
delete function, The delete Function
delimiters
changing for s/// substitution operator, Different Delimiters
in lists, The qw Shortcut
nonpaired, Matches with m//
diagnostic messages, from diamond operator\, Input from the Diamond Operator
diagnostics pragma, The diagnostics Pragma
diamond operator (see diamond operator)
diamond operator (), Input from the Diamond Operator–Input from the Diamond Operator
@ARGV array and, The Invocation Arguments
in-place editing of text files and, Variable-length (Text) Databases
die function, Fatal Errors with die–Warning Messages with warn
digits, d shortcut for, Character Class Shortcuts
directories, Links and Files
making/removing, Making and Removing Directories–Making and Removing Directories
manipulating, Directory Operations–Recursive Directory Listing
directory handles, Directory Handles–Directory Handles
dirname function, File::Basename module and, The File::Basename Module
division operator (/), Numeric Operators
documentation for Perl, Are There Any Other Kinds of Support?, Further Documentation
embedding, Embedded Documentation
dollar sign ($)
in regular text, Interpolation of Scalar Variables into Strings
in scalar variable names, Scalar Variables
indicating end of string, Anchors
preceding hash names, Hash Element Access
domain-name databases, Direct System Database Access
dot (.)
as wildcard character, About Metacharacters
/s modifier and, Matching Any Character with /s
indicating current directory, Links and Files
dot and slash (./), A Simple Program
dot-dot (..) indicating parent directory, Links and Files
double quotes (“”)
arrays and, Output to Standard Output
enclosing strings, Double-Quoted String Literals
omitting from hash keys, Unquoted Hash Keys
double-precision floating-point values, All Numbers Are the Same Format Internally
double-quote interpolation (see variable interpolation)
double-quoted string literals, Double-Quoted String Literals
arrays, interpolating into, Interpolating Arrays into Strings
hash elements, interpolating into, Hash Element Interpolation
scalar variables, interpolating into, Interpolation of Scalar Variables into Strings
variable interpolation and, Double-Quoted String Literals
downloading pattern test program, Exercises
dynamic loading, Dynamic Loading

E

each function, The each Function
DBM hashes and, Using a DBM Hash
echo command, Globbing
elements, Lists and Arrays
of an array, Accessing Elements of an Array
pop and push operators for, The pop and push Operators
else clause, using with unless control structure, The else Clause with unless
else keyword, The if Control Structure
elsif clause, The elsif Clause
emacs text editor, How Do I Make a Perl Program?
email addresses, compile time errors and, Interpolating Arrays into Strings
email, Net::SMTP module for, The Net::SMTP Module
embedding code, Embedding
end-of-file/end-of-input, <STDIN> in List Context
bad filehandles and, Bad Filehandles
endless loop, stopping, The while Control Structure
environment variables, The Environment Variables
Epoch, The stat and lstat Functions
error messages, Perl’s Built-in Warnings
printed by die function, Fatal Errors with die
sending to a file, Reopening a Standard Filehandle
standard output and, Using Backquotes to Capture Output
errors (see fatal errors)
eval block, Trapping Errors with eval–Trapping Errors with eval
caution with, Trapping Errors with eval
exec function, The exec Function
exercises in this book, What About the Exercises and Their Answers?
answers to, Exercise Answers–Answer to Chapter 17 Exercises
exists function, The exists Function
exit status, Fatal Errors with die
exponentiation operator (**), Numeric Operators
expressions
context and, Scalar and List Context–Using Scalar-Producing Expressions in List Context
modifiers for, Expression Modifiers

F

fatal errors
die function for, Fatal Errors with die–Warning Messages with warn
trapping with eval block, Trapping Errors with eval–Trapping Errors with eval
Fatal module, The Fatal Module
file extensions, A Simple Program
filehandles, What Is a Filehandle?–Reopening a Standard Filehandle
bad, Bad Filehandles
default for output, changing, Changing the Default Output Filehandle
opening/closing, Opening a Filehandle–Bad Filehandles
processes as, Processes as Filehandles–Processes as Filehandles
reading, vs. globbing, An Alternate Syntax for Globbing
reopening, Reopening a Standard Filehandle
tests for, File Tests–Using the Special Underscore Filehandle
list of, File Tests
underscore, Using the Special Underscore Filehandle
using, Using Filehandles
filename extensions, A Simple Program
filenames, File::Spec module for manipulating, The File::Spec Module
files
database, in-place editing of, Variable-length (Text) Databases
from command line, In-place Editing from the Command Line
File::Copy module for copying/moving, The File::Copy Module
image, Image::Size module for, The Image::Size Module
links to, finding with stat function, The stat and lstat Functions
manipulating, Manipulating Files and Directories–Exercises
names of, directory handles for reading, Directory Handles
ownership of, changing, Changing Ownership
removing, Removing Files
renaming, Renaming Files
size of, scalar variable for finding, The stat and lstat Functions
specifications of, File::Spec module for manipulating, The File::Spec Module, The File::Spec Module
tests for, File Tests–Using the Special Underscore Filehandle
list of, File Tests
File::Basename module, The File::Basename Module–Using Only Some Functions from a Module, The File::Basename Module
File::Copy module, The File::Copy Module
File::Find library, Recursive Directory Listing
File::Spec module, The File::Spec Module–The File::Spec Module, The File::Spec Module
find command (Unix), Processes as Filehandles, Converting find Command Lines to Perl
find2perl command, Converting find Command Lines to Perl
first found occurrence of a substring, index function for, Finding a Substring with index
fixed-length random-access databases, Fixed-length Random-access Databases–Fixed-length Random-access Databases
flags, Option Modifiers
flat-file databases, Flat-file Database Access
Flintstones
anchors and, Word Anchors
illustrating backreferences, Backreferences
illustrating hash names, Hash Element Access
illustrating Unix grep command, What Are Regular Expressions?
precedence and, Examples of Precedence
floating-point conversion, Formatted Output with printf
floating-point literals, Floating-Point Literals
flushed buffer, Output to Standard Output
footnotes in this book, Why Are There So Many Footnotes?
for control structure, The for Control Structure–The Secret Connection Between foreach and for
vs. foreach control structure, The Secret Connection Between foreach and for
foreach control structure, The foreach Control Structure
naked block control structure and, The Naked Block Control Structure
vs. for control structure, The Secret Connection Between foreach and for
foreach modifier, Expression Modifiers, Expression Modifiers
fork system call, Getting Down and Dirty with Fork
using instead of threads, Threads and Forking
format letters, Manipulating Data with pack and unpack
format strings, Manipulating Data with pack and unpack
formats, Formats
formatted output, Formatted Output with printf–Arrays and printf
forward slashes (Ú Ú)
enclosing a pattern, Using Simple Patterns
vs. m// operator, Matches with m//
Friedl, Jeffrey, Regular expressions
function calls, parentheses and, Output to Standard Output
functions
builtin, ampersand and, Omitting the Ampersand
defaults for, Is Perl Easy or Hard?

G

general numeric conversion, Formatted Output with printf
getgrnam function, Changing Ownership
Getopt::Long module, Command-line Options in Your Programs
Getopt::Std module, Command-line Options in Your Programs
getpwnam function, Changing Ownership
glob operator, Globbing
combining with unlink operator, Removing Files
global replacements, Global Replacements with /g
globbing, Globbing–An Alternate Syntax for Globbing
vs. directory handles, Directory Handles
vs. filehandle reading, An Alternate Syntax for Globbing
globs, What Are Regular Expressions?
gmtime function, The localtime Function
graphical user interfaces (GUIs), Graphical User Interfaces (GUIs)
greater-than sign (>) for creating files, Opening a Filehandle
Greenwich Mean Time, The localtime Function
grep command (Unix)
regular expressions and, What Are Regular Expressions?
writing Perl program resembling, Interpolating into Patterns
grep operator
perlfunc manpage and, map and grep
picking items from a list with, Picking Items from a List with grep
vs. map operator, Transforming Items from a List with map
vs. Unix’s grep command, Picking Items from a List with grep
group-ID ($gid), The stat and lstat Functions
changing group membership and, Changing Ownership
GUIs (graphical user interfaces), Graphical User Interfaces (GUIs)

H

hard links, Links and Files, Links and Files
hash elements, accessing, Hash Element Access–The Big Arrow
hash functions, Hash Functions–The each Function
hash keys, What Is a Hash?
delete function for removing, The delete Function
exists function for checking, The exists Function
omitting quotes from, Unquoted Hash Keys
sorting, Sorting a Hash by Value–Sorting by Multiple Keys
hashes, Hashes–Exercises
accessing elements of, Hash Element Access–The Big Arrow
assigning, Hash Assignment
autoincrements/autodecrements and, The Value of Autoincrement
elements of, interpolating into double-quoted string literals, Hash Element Interpolation
functions for, Hash Functions–The each Function
names of, Hash Element Access
reasons for using, Why Use a Hash?
slices and, Hash Slice
unwinding, The Hash as a Whole
here documents, Here documents
hexadecimal literals, Nondecimal Integer Literals
high-level programming languages, Why Didn’t Larry Just Use Some Other Language?, Is Perl Easy or Hard?
high-precision numbers, Large and High-Precision Numbers
home directory, Moving Around the Directory Tree
hostname function, The Sys::Hostname Module
hyphen (-)
indicating standard input stream, Input from the Diamond Operator
specifying range of characters, Character Classes

I

I/O (input/output), I/O Basics–Exercises, I/O Basics
filehandles and, What Is a Filehandle?
if control structure, The if Control Structure
else clause and, The else Clause with unless
unless control structure and, The unless Control Structure
if modifier, Expression Modifiers
if-then-else test, ternary operator for, The Ternary Operator, ?:
image files, Image::Size module for, The Image::Size Module
Image::Size module, The Image::Size Module
imaginary numbers, Imaginary and Complex Numbers
import lists, Using Only Some Functions from a Module
index function, Finding a Substring with index
using with substr operator, Manipulating a Substring with substr
indexing elements, Lists and Arrays
indirect filehandle read, An Alternate Syntax for Globbing
inodes, Links and Files
input, I/O Basics–The Invocation Arguments
reading with diamond operator, Input from the Diamond Operator–Input from the Diamond Operator
while control structure shortcut for, Input from Standard Input–Input from Standard Input
input/output (I/O), I/O Basics–Exercises, I/O Basics
filehandles and, What Is a Filehandle?
inside utility, Finding and Installing Modules
integer literals, Integer Literals
integer pragma, All Numbers Are the Same Format Internally
integers, All Numbers Are the Same Format Internally
internal integers, All Numbers Are the Same Format Internally
Internet (see Web)
interprocess communication, System V IPC
invocation arguments, Input from the Diamond Operator, The Invocation Arguments
invoking subroutines, Invoking a Subroutine
IP addresses, hashes and, Why Use a Hash?
IPC, Networking and IPC
iterations, next and redo operators for, The next Operator–The redo Operator

J

join function, The join Function

K

key-value pairs, What Is a Hash?
keys (see hash keys)
keys function, The keys and values Functions

L

labels, Labeled Blocks
large numbers, Large and High-Precision Numbers
Larry (see Wall, Larry)
last found occurrence of a substring, rindex function for, Finding a Substring with index
last operator, The last Operator
leading zero, Nondecimal Integer Literals
length function, Fixed-length Random-access Databases
less-than sign (<) for opening files, Opening a Filehandle
lexical variables, Private Variables in Subroutines, Notes on Lexical (my) Variables
lexical warnings, Perl’s Built-in Warnings
lib pragma, The lib Pragma
libraries, Libraries
licenses for Perl, How Can I Get Perl?
embedding code snippets and, Embedding
line number
die function and, Fatal Errors with die
warn function and, Warning Messages with warn
line-input operators, Getting User Input, Getting User Input, Input from the Diamond Operator, Using Filehandles
link count, Links and Files
link function, Links and Files
links, Links and Files–Links and Files
number of ($nlink), The stat and lstat Functions
list context, Scalar and List Context–Forcing Scalar Context
return values and, Return Values
using backquotes in, Using Backquotes in a List Context–Using Backquotes in a List Context
list literals, List Literals
lists, Lists and Arrays –Exercises, Lists and Arrays
qw shortcut for, The qw Shortcut
literal strings (see string literals)
literals, Floating-Point Literals
little arrow (->), The Big Arrow
in method names, The File::Spec Module
Llama book, Introduction, Are There Any Other Kinds of Support?
local operator, The local Operator
locales, Locales and Unicode
localtime function, The localtime Function
text databases and, Variable-length (Text) Databases
log files, filehandles and, Opening a Filehandle, Changing the Default Output Filehandle
logarithm, Advanced Math Functions
logical operators, Logical Operators–Control Structures Using Partial-Evaluation Operators
loop blocks, The last Operator, The next Operator
labels for, Labeled Blocks
loop controls, Loop Controls–Labeled Blocks
loops, The while Control Structure
endless, stopping, The while Control Structure
low-level programming languages, Why Didn’t Larry Just Use Some Other Language?
lowercase
case shifting and, Case Shifting
vs. capitalization in variable names, Choosing Good Variable Names
lstat function, The stat and lstat Functions
underscore filehandle and, Using the Special Underscore Filehandle
LWP module, Sockets

M

m// operator, Matches with m//
vs. s/// substitution operator, Substitutions with s///
mailing lists for Perl, Are There Any Other Kinds of Support?
main program, What’s Inside That Program?
maintenance programmers
partial-evaluation operators and, Control Structures Using Partial-Evaluation Operators
writing intelligible code for, Operator Precedence and Associativity, The else Clause with unless
make utility, exit status and, Fatal Errors with die
manpages, Are There Any Other Kinds of Support?
map operator, Transforming Items from a List with map
perlfunc manpage and, map and grep
match variables, The Match Variables–The Automatic Match Variables
matching
with /i modifier, Case-insensitive Matching with /i
with /s modifier, Matching Any Character with /s
with =~ binding operator, The Binding Operator, =~
with dot wildcard character, About Metacharacters
with m// operator, Matches with m//
with s/// substitution operator, Substitutions with s///–Case Shifting
mathematical functions, Advanced Math Functions
mathematics, Mathematics
Math::BigFloat module, Large and High-Precision Numbers
Math::BigInt module, Large and High-Precision Numbers
Math::Complex module, Imaginary and Complex Numbers
memory parentheses, Memory Parentheses–Memory Variables
memory variables, Memory Variables
memory, persistence of, The Persistence of Memory
metacharacters, About Metacharacters
methods, The File::Spec Module
mkdir function, Making and Removing Directories–Making and Removing Directories
modules, Omitting the Ampersand, Using Simple Modules–The File::Spec Module, Modules–The Time::Local Module, And More...
lib pragma for, The lib Pragma
using only some functions from, Using Only Some Functions from a Module
modulus operator (%), Numeric Operators
used with grep operator, Picking Items from a List with grep
mod_perl software, Embedding
money, sprintf function for, Using sprintf with “Money Numbers”–Using sprintf with “Money Numbers”
mounted volume, Links and Files
multiline string quoting, Here documents
multiplication operator (*), Numeric Operators
mv command (Unix), Renaming Files
my operator, Notes on Lexical (my) Variables
creating lexical variables with, Private Variables in Subroutines
using instead of local operator, The Difference Between local and my

N

naked block control structure, The Naked Block Control Structure
names
hashes and, Why Use a Hash?
of hashes, Hash Element Access
of variables
choosing, Choosing Good Variable Names
enclosed in curly braces, Interpolation of Scalar Variables into Strings
namespaces, packages for, Packages
negating shortcuts, Negating the Shortcuts
negation (not) operator (!), Boolean Values, The unless Control Structure, Control Structures Using Partial-Evaluation Operators
negative array indices, Special Array Indices
networking, Networking and IPC
Net::SMTP module, The Net::SMTP Module
newlines
print function and, Output to Standard Output
trailing
chomp operator for removing, The chomp Operator
die function and, Fatal Errors with die
newsgroups for Perl, Are There Any Other Kinds of Support?
next operator, The next Operator
nondecimal integer literals, Nondecimal Integer Literals
nonpaired delimiters, Matches with m//
not operator (see negation operator)
NUL character, Strings
DBM hashes and, Using a DBM Hash
numbers, Numbers–Numeric Operators, Numbers
comma-separated, General Quantifiers
comparison operators for, Comparison Operators
complex/imaginary and, Imaginary and Complex Numbers
converted automatically to strings, Automatic Conversion Between Numbers and Strings
high-precision/large, Large and High-Precision Numbers
spaceship operator for comparing, Advanced Sorting
sprintf function for, Using sprintf with “Money Numbers”–Using sprintf with “Money Numbers”
numeric comparison operators, Comparison Operators
numeric operators, Numeric Operators
numeric user-ID (see user-ID, numeric)

O

object-oriented (OO) programming, Object-Oriented Programming
octal literals, Nondecimal Integer Literals
OO (object-oriented) programming, Object-Oriented Programming
open function, Fixed-length Random-access Databases
open operator, Opening a Filehandle–Bad Filehandles
opendir operator, Directory Handles
operator, Getting User Input
context and, <STDIN> in List Context
defined function and, The defined Function
while loop shortcut and, Input from Standard Input
operator precedence (see precedence)
operators
associativity and, Operator Precedence and Associativity–Operator Precedence and Associativity
comparison, Comparison Operators, Advanced Sorting
numeric, Numeric Operators
overload module for, Operator Overloading
perlfunc manpage and, Other Operators and Functions
perlop manpage and, Other Operators and Functions
precedence and, Operator Precedence and Associativity–Operator Precedence and Associativity
option modifiers, Option Modifiers
OR operator (||), Logical Operators, Control Structures Using Partial-Evaluation Operators
die function and, Fatal Errors with die
output, Output to Standard Output–Arrays and printf
buffered, Output to Standard Output
capturing using backquotes, Using Backquotes to Capture Output–Using Backquotes in a List Context
formatted with printf function, Formatted Output with printf–Arrays and printf
overload module, Operator Overloading

P

pack function, Manipulating Data with pack and unpack
packages, Packages
parameter lists, Arguments
empty, Empty Parameter Lists
variable-length, Variable-length Parameter Lists–Empty Parameter Lists
parent processes, managing, Process Management–Exercises
parentheses
file tests and, File Tests
grouping patterns with, Grouping in Patterns
indicating precedence, Operator Precedence and Associativity
optional use of, The pop and push Operators
with print function, Output to Standard Output
with memory function, Memory Parentheses–Memory Variables
partial-evaluation operators, Control Structures Using Partial-Evaluation Operators–Control Structures Using Partial-Evaluation Operators
password databases (Unix), Direct System Database Access
PATH environment variable, The Environment Variables
pattern match operator (m//), Matches with m//
patterns, What Are Regular Expressions?, What Are Regular Expressions?, Using Simple Patterns–A Pattern Test Program
manpages for, And There’s More
split operator and, The split Operator
test program for, A Pattern Test Program
percent sign (%), Formatted Output with printf
indicating conversion, Formatted Output with printf
indicating entire hash, The Hash as a Whole
printing, Formatted Output with printf
performance, slowed by automatic match variables, The Automatic Match Variables
period (see dot)
Perl, What Does “Perl” Stand For?–A Whirlwind Tour of Perl
advanced techniques for, Some Advanced Perl Techniques–Exercise
bugs in, How Can I Get Support for Perl?
reporting, What If I Find a Bug in Perl?
converting other programming languages to, Converting Other Languages to Perl
current trends in, What’s Happening with Perl Now?
documentation for, Are There Any Other Kinds of Support?, Further Documentation
libraries and modules for, Extending Perl’s Functionality
licenses for, How Can I Get Perl?
mailing lists and newsgroups for, Are There Any Other Kinds of Support?
obtaining, How Can I Get Perl?
portability and, Why Are There So Many Footnotes?, Is Perl Easy or Hard?
reasons for using/not using, What’s Perl Really Good For?
security and, Security, The Common Gateway Interface (CGI)
support for, How Can I Get Support for Perl?–Are There Any Other Kinds of Support?
Perl identifiers, Scalar Variables
Perl Monastery, Are There Any Other Kinds of Support?
perlboot manpage, object-oriented programming and, Object-Oriented Programming
perlbug utility, What If I Find a Bug in Perl?
perldata manpage, here documents and, Here documents
perldebug manpage, Debugging
perldiag manpage, What’s Inside That Program?
errors and, Trapping Errors with eval
warnings explained in, Perl’s Built-in Warnings
perldoc command, A Whirlwind Tour of Perl
perldoc manpage, Further Documentation
perldsc manpage, data structures and, Complex Data Structures
perlfaq manpage, The elsif Clause, Further Documentation
perlfork manpage, Threads and Forking
perlform manpage, formats and, Formats
perlfunc manpage, The Naked Block Control Structure
format letters and, Manipulating Data with pack and unpack
grep operator and, map and grep
map operator and, map and grep
mathematical functions and, Advanced Math Functions
operators and, Other Operators and Functions
splice operator and, The splice Operator
System V IPC and, System V IPC
vec operator and, Bits and Pieces
perlipc manpage, Getting Down and Dirty with Fork
perlipc module, System V IPC and, System V IPC
perllexwarn manpage, Perl’s Built-in Warnings
perllocale manpage, Locales and Unicode
perllol manpage, data structures and, Complex Data Structures
perlmod manpage
syntax extensions and, Syntax Extensions
writing modules and, Writing Your Own Modules
perlmodinstall manpage, Finding and Installing Modules
perlmodlib manpage
pragmas and, Pragmas
writing modules and, Writing Your Own Modules
perlobj manpage, object-oriented programming and, Object-Oriented Programming
perlop manpage
bitwise operators and, Using Bitstrings
operators and, Other Operators and Functions
perlopentut manpage, filehandles and, More Ways to Open Filehandles
perlpod manpage, Embedded Documentation
perlport manpage, standard input/output and, What Is a Filehandle?
perlre manpage, And There’s More, Regular expressions
perlref manpage, references and, References
perlreftut manpage, references and, References
perlrequick manpage, And There’s More, Regular expressions
perlretut manpage, And There’s More, Regular expressions
perlrun manpage, command-line options and, In-place Editing from the Command Line, Command-Line Options
perlsec manpage, Security
perlsyn manpage, The for Control Structure
continue block and, The next Operator
syntax extensions and, Syntax Extensions
perlthrtut manpage, Threads and Forking
perltie manpage, tied variables and, Tied Variables
perltoc manpage, Further Documentation
perlvar manpage, builtin variables and, Built in Variables
permissions
changing, Modifying Permissions
Unix and, Removing Files
pipe (|), What Is a Filehandle?
processes and, Processes as Filehandles
plain-old documentation format, Embedded Documentation
plus sign (+), as quantifier, Simple Quantifiers
pod format, Embedded Documentation
pointers (C programming language), References
pop operator, The pop and push Operators
portability, Why Are There So Many Footnotes?, Is Perl Easy or Hard?
modules and, The File::Spec Module
POSIX module, The POSIX Module
math functions and, Advanced Math Functions
postincrements/postdecrements, The Value of Autoincrement
pound sign (#) in comments, What’s Inside That Program?
Practical Extraction and Report Language (see Perl)
pragmas, The use strict Pragma, Pragmas–The warnings Pragma
integer, All Numbers Are the Same Format Internally
precedence, Operator Precedence and Associativity–Operator Precedence and Associativity, Precedence–Examples of Precedence
partial-evaluation operators and, Control Structures Using Partial-Evaluation Operators
table of, Operator Precedence and Associativity
preincrements/predecrements, The Value of Autoincrement
print function, Output with print
databases records and, Fixed-length Random-access Databases
filehandles and, Using Filehandles
newlines and, Output to Standard Output
optional parentheses and, Output to Standard Output
output and, Output to Standard Output
printf function, Formatted Output with printf–Arrays and printf
filehandles and, Using Filehandles
private variables (see lexical variables)
processes
as filehandles, Processes as Filehandles–Processes as Filehandles
managing, Process Management–Exercises
programming, How Do I Make a Perl Program?–But How Do I Compile Perl?, The else Clause with unless
automatic match variables and, The Automatic Match Variables
text editor for, How Do I Make a Perl Program?
programming languages
C, operators and, The Ternary Operator, ?:
converting to Perl, Converting Other Languages to Perl
low-level vs. high-level, Why Didn’t Larry Just Use Some Other Language?
structured, Loop Controls
Programming Perl, Why Didn’t Larry Just Use Some Other Language?
as documentation for Perl, Are There Any Other Kinds of Support?
programs, The last Operator
example of in a nutshell, A Whirlwind Tour of Perl
exit status and, Fatal Errors with die
last operator for exiting early, The last Operator
name of
die function and, Fatal Errors with die
warn function and, Warning Messages with warn
running over the Web, But How Do I Compile Perl?
prototypes, Omitting the Ampersand
push operator, The pop and push Operators

Q

quantifiers, Simple Quantifiers, General Quantifiers
greedy/non-greedy, Non-greedy Quantifiers–Non-greedy Quantifiers
question mark (?) as quantifier, Simple Quantifiers
quick reference to Perl, Are There Any Other Kinds of Support?
quoting
multiline string, Here documents
qw shortcut form of, The qw Shortcut
qw shortcut, The qw Shortcut

R

raise to the power of operator (**=), Binary Assignment Operators
range operator (..), List Literals
read function, database records and, Fixed-length Random-access Databases
readdir operator, Directory Handles
readline operator, An Alternate Syntax for Globbing
recursive directory listing, Recursive Directory Listing
redo operator, The redo Operator
references, List Assignment, References
Registry (Windows), Direct System Database Access
regular expression engines, More Powerful Regular Expressions
resources for further information, Regular expressions
regular expression memories, Memory Parentheses
regular expressions, Concepts of Regular Expressions–A Pattern Test Program, More Powerful Regular Expressions–Matching Multiple-line Text
resources for further reading, Regular expressions
using, Using Regular Expressions–Exercises
relational databases, Relational Database Access
removing
directories, Making and Removing Directories–Making and Removing Directories
files, Removing Files
rename function, Renaming Files
reports, formats for, Formats
resources for further reading
auxiliary lock files, Using a DBM Hash
bitwise operators, Using Bitstrings
file tests, File Tests
Perl
object-oriented programming and, Object-Oriented Programming
using with the Web, The Common Gateway Interface (CGI)
Programming Perl, Why Didn’t Larry Just Use Some Other Language?
regular expressions, Non-greedy Quantifiers, Regular expressions
Tk, Graphical User Interfaces (GUIs)
restrictions, The use strict Pragma
return operator, The return Operator–Omitting the Ampersand
return values, Return Values–Return Values
reverse operator, The reverse Operator, Advanced Sorting
rindex function, Finding a Substring with index
rm command (Unix), Removing Files
rmdir operator, Making and Removing Directories
rmtree function, Making and Removing Directories
runtime, But How Do I Compile Perl?

S

s/// substitution operator, Substitutions with s///–Case Shifting
vs. m// operator, Substitutions with s///
s2p conversion program, Converting Other Languages to Perl
scalar context, Scalar and List Context–Forcing Scalar Context
forcing, Forcing Scalar Context
scalar variables
autoincrements/autodecrements for, Autoincrement and Autodecrement
stat function and, The stat and lstat Functions
scalars, What Is Scalar Data?–Exercises
values of, assigning to variables, Scalar Assignment
scope of variables, Notes on Lexical (my) Variables
naked block control structure and, The Naked Block Control Structure
scoped variables (see lexical variables)
security, Security
CGI programs and, The Common Gateway Interface (CGI)
seek function, Fixed-length Random-access Databases
select operator, Changing the Default Output Filehandle
semicolon (;)
ending expressions, What’s Inside That Program?
in for/foreach control structures, The Secret Connection Between foreach and for
return value expressions and, Private Variables in Subroutines
shell, avoiding, Avoiding the Shell
shift operator, The shift and unshift Operators
shortcuts, Is Perl Easy or Hard?
character class, Character Class Shortcuts
negating, Negating the Shortcuts
SIGINT, Sending and Receiving Signals
signals, sending/receiving, Sending and Receiving Signals–Sending and Receiving Signals
single quotes (' ') enclosing strings, Single-Quoted String Literals
single-quoted string literals, Single-Quoted String Literals
slash with dot (./), A Simple Program
slices, Slices–Hash Slice
SMTP servers, Net::SMTP module for, The Net::SMTP Module
sockets (TCP/IP), Sockets
soft links, Links and Files, Links and Files
sort subroutines (sort-definition subroutines), Advanced Sorting–Sorting by Multiple Keys
sorting
advanced, Advanced Sorting–Exercises
sort operator for, The sort Operator
spaces, Character Class Shortcuts
s shortcut for, Character Class Shortcuts
spaceship operator, Advanced Sorting
spaceship operator (), Advanced Sorting
splice operator, The splice Operator
split operator, The split Operator, Slices
vs. join function, The join Function
sports scores, sorting, Sorting a Hash by Value
sprintf function, Formatting Data with sprintf–Using sprintf with “Money Numbers”
sqrt function, The Naked Block Control Structure
square brackets ([ ])
in character classes, Character Classes
in pattern test program results, A Pattern Test Program
square root, Advanced Math Functions
stacks, The local Operator
standard error stream, What Is a Filehandle?
standard input, Getting User Input, I/O Basics
standard input stream, What Is a Filehandle?
standard output, Output to Standard Output–Output to Standard Output, Output to Standard Output
standard output stream, What Is a Filehandle?
star (*) as quantifier, Simple Quantifiers
Star Wars, spaceship operator and, Advanced Sorting
stat buffer, Using the Special Underscore Filehandle
stat function, The stat and lstat Functions
underscore filehandle and, Using the Special Underscore Filehandle
stat(2) manpage, The stat and lstat Functions
STDERR filehandle, What Is a Filehandle?, Reopening a Standard Filehandle
STDIN filehandle, What Is a Filehandle?
STDOUT filehandle, What Is a Filehandle?, Changing the Default Output Filehandle
strict pragma, The strict Pragma
string accumulator, The undef Value
string comparison operators, Comparison Operators
string concatenate operator (.), Binary Assignment Operators
string escapes (see backslash escapes)
string literals, Strings
double-quoted (see double-quoted string literals)
string repetition operator (x), String Operators, Arrays and printf
strings, Strings–Automatic Conversion Between Numbers and Strings, Strings, Strings and Sorting–Exercises
converted automatically to numbers, Automatic Conversion Between Numbers and Strings
finding substrings within, Finding a Substring with index
operators for, String Operators
comparison operators for, Comparison Operators
sub keyword, Defining a Subroutine
subroutines, System and User Functions–Exercises
anonymous, Anonymous Subroutines and Closures
calling, Invoking a Subroutine
defining, Defining a Subroutine
invoking, Invoking a Subroutine
lexical variables in, Private Variables in Subroutines
subscripts, Accessing Elements of an Array
substr operator, Manipulating a Substring with substr
substrings, Finding a Substring with index–Manipulating a Substring with substr
subtraction operator (-), Numeric Operators
support for Perl, How Can I Get Support for Perl?–Are There Any Other Kinds of Support?
symbolic links, File Tests, The stat and lstat Functions, Links and Files, Links and Files
symlink function, Links and Files
syntax extensions, Syntax Extensions
system databases, Direct System Database Access
system function, The system Function–Avoiding the Shell
using vs. exec function, The exec Function
system functions, System and User Functions
system time, The stat and lstat Functions
System V IPC, System V IPC
Sys::Hostname module, The Sys::Hostname Module

T

taint checking, Security
TCP/IP sockets, Sockets
temporary files, cleaning up, Sending and Receiving Signals, Converting find Command Lines to Perl
ternary operator (?:), The Ternary Operator, ?:
text
matching multiple lines of, Matching Multiple-line Text
regular dollar sign in, Interpolation of Scalar Variables into Strings
Text::Wrap module for, The Text::Wrap Module
text databases, Variable-length (Text) Databases–In-place Editing from the Command Line
text editors, How Do I Make a Perl Program?
text mode, How Do I Make a Perl Program?
Text::Wrap module, The Text::Wrap Module
threads, Threads and Forking
three-way comparison operator (cmp), Advanced Sorting
tie interface, Opening and Closing DBM Hashes
tied variables, Tied Variables
tilde (“~”), as value for $^I variable, Variable-length (Text) Databases
tilde-prefix (~), Moving Around the Directory Tree
time function, The localtime Function
timelocal function, The Time::Local Module
timestamps, The stat and lstat Functions
changing, Changing Timestamps
number for, converting, The localtime Function
Time::Local module, The Time::Local Module
Tk module set, Graphical User Interfaces (GUIs)
tr/// operator, Transliteration with tr///
trailing newlines (see newlines, trailing)

U

Ú Ú forward slashes, Using Simple Patterns, Matches with m//
uid (user-ID), The stat and lstat Functions
undef operator, The defined Function
slices and, Slices
undef value, The undef Value
underscore (_)
in integer literals, Integer Literals
in variable names, The use strict Pragma
underscore filehandle, Using the Special Underscore Filehandle
Unicode, Locales and Unicode
Universal Time, The localtime Function
Unix
input/output and, What Is a Filehandle?
model of files/directories and, Links and Files
portability and, Why Are There So Many Footnotes?
utilities for
diamond operator and, Input from the Diamond Operator
regular expressions and, Concepts of Regular Expressions
Unix password databases, Direct System Database Access
Unix signals, sending/receiving, Sending and Receiving Signals–Sending and Receiving Signals
unless control structure, The unless Control Structure
unless modifier, Expression Modifiers, Expression Modifiers
unlink operator, Removing Files
unpack function, Manipulating Data with pack and unpack
unquoted hash keys, Unquoted Hash Keys
unshift operator, The shift and unshift Operators
until control structure, The until Control Structure
until modifier, Expression Modifiers, Expression Modifiers
unwinding hashes, The Hash as a Whole
uppercase
case shifting and, Case Shifting
vs. lowercase in variable names, Choosing Good Variable Names
URLs
code in this book, Code Examples
CPAN, What Is CPAN?, Finding and Installing Modules
Perl Monastery, Are There Any Other Kinds of Support?
search interfaces for Perl, What Is CPAN?
use directives, Finding and Installing Modules
pragmas and, Pragmas
use strict pragma, The use strict Pragma, The strict Pragma
user functions (see subroutines)
user-ID (uid), The stat and lstat Functions
user-ID, numeric ($uid), The stat and lstat Functions
changing file ownership and, Changing Ownership
utilities
inside, Finding and Installing Modules
perlbug, What If I Find a Bug in Perl?
Unix (see Unix, utilities for)
which_dbm, DBM Files and DBM Hashes
utime function, Changing Timestamps

V

values
list, assigning to variables, List Assignment–The shift and unshift Operators
of short-circuit logical operators, The Value of a Short-Circuit Operator
saving using local operator, The local Operator
scalar, assigning to variables, Scalar Assignment
values function, The keys and values Functions
variable interpolation, Double-Quoted String Literals, Interpolation of Scalar Variables into Strings, Interpolation of Scalar Variables into Strings
variable-length parameter lists, Variable-length Parameter Lists–Empty Parameter Lists
variable-length text databases, Variable-length (Text) Databases–In-place Editing from the Command Line
variables, Scalar Variables
altering, Binary Assignment Operators
assigning list values to, List Assignment–The shift and unshift Operators
assigning scalar values to, Scalar Assignment
builtin, The Automatic Match Variables
declaring, What’s Inside That Program?
environment, The Environment Variables
match, The Match Variables–The Automatic Match Variables
names of enclosed in curly braces, Interpolation of Scalar Variables into Strings
tied, Tied Variables
undef value and, The undef Value
value of, saving, The local Operator
vars pragma, The vars Pragma
vec operator, Bits and Pieces
vertical bar (|), Alternatives
vi text editor, How Do I Make a Perl Program?
void context, Return Values
Vromans, Johan, Are There Any Other Kinds of Support?

W

waitpid function, Getting Down and Dirty with Fork
Wall, Heidi, Input from the Diamond Operator
Wall, Larry, History of This Book, What Does “Perl” Stand For?–What’s Happening with Perl Now?
wantarray function, Return Values
warn function, Warning Messages with warn
warnings, Perl’s Built-in Warnings
bad filehandles and, Bad Filehandles
warn function for, Warning Messages with warn
warnings pragma, The warnings Pragma
Web
CGI programs and, The Common Gateway Interface (CGI)
running programs over, But How Do I Compile Perl?
socket-support and, Sockets
which_dbm utility, DBM Files and DBM Hashes
while control structure, The while Control Structure
for control structure and, The for Control Structure–The for Control Structure
naked block control structure and, The Naked Block Control Structure
shortcut for, Input from Standard Input–Input from Standard Input
until control structure for reversing, The until Control Structure
using each function with, The each Function
while modifier, Expression Modifiers, Expression Modifiers, Using sprintf with “Money Numbers”
whitespace, What’s Inside That Program?, The qw Shortcut
global replacements and, Global Replacements with /g
greater-than sign and, Opening a Filehandle
in format strings, Manipulating Data with pack and unpack
split operator and, The split Operator
s shortcut for, Character Class Shortcuts
who command (Unix), Using Backquotes in a List Context
Windows Registry, Direct System Database Access
word count, hashes and, Why Use a Hash?
word processor, using instead of a text editor, How Do I Make a Perl Program?
word-boundary anchors, Word Anchors
word-wrapping, Text::Wrap module for, The Text::Wrap Module
words, w shortcut for, Character Class Shortcuts
working directory
chdir operator for changing, Moving Around the Directory Tree
current, cwd function for determining, The Cwd Module
wrap function, The Text::Wrap Module

X

x string repetition, String Operators, Arrays and printf
xor operator, Control Structures Using Partial-Evaluation Operators
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset