0% found this document useful (0 votes)

146 views

Introduction To Perl Scripting

it contains details regarding PERL language.

Uploaded by

Ashis Kumar Mishra

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

146 views

Introduction To Perl Scripting

it contains details regarding PERL language.

Uploaded by

Ashis Kumar Mishra

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 209

N

E T W O R K

Q U I P M E N T

E C H N O L O G I E S

P I

A N A

U E

A N A G E M E N T T O

P S

L A T F O R M C R I P T I N G

N T R O D U C T I O N

E R L

E L E A S E

2 . 0

..........................................................
Issued September 1998
NETWORK EQUIPMENT TECHNOLOGIES, INC., (N.E.T.) PROVIDES THIS DOCUMENT AS IS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. This document constitutes the sole Specications referred to in N.E.T.'s Product Warranty for the products or services described herein. N.E.T.'s Product Warranty is subject to all the conditions, restrictions, and limitations contained herein and in the applicable contract. N.E.T. has made reasonable efforts to verify that the information in this document is accurate, but N.E.T. reserves the right to correct typographical errors or technical inaccuracies. N.E.T. assumes no responsibility for any use of the use of the information contained in this document or for any infringement of patents or other rights of third parties that may result. Networking products cannot be tested in all possible uses, congurations or implementations, and interoperability with other products cannot be guaranteed. The customer is solely responsible for verifying the suitability of N.E.T.'s products for use in its network. Local market variations may apply. This document is subject to change by N.E.T. without notice as additional information is incorporated by N.E.T. or as changes are made by N.E.T. to hardware or software. Copyright 1998 Network Equipment Technologies, Inc. All rights reserved. No part of this publication may be stored in a retrieval system, transmitted or reproduced in any way, including, but not limited to, photocopy, photograph, magnetic, or other record, without the prior written permission of N.E.T.

Restricted Rights U.S. Government Rights

The software accompanying this documentation is furnished under a license and may only be used in accordance with the terms of such license. This documentation is commercial computer software documentation as that term is used in 48 CFR 12.212. Unless otherwise agreed, use, duplication, or disclosure of this documentation and any related software by U.S. Government civilian agencies is subject to restrictions as set forth in 48 CFR 52.227-14 (ALT III) and 48 CFR 52.227-19, and use, duplication, or disclosure by DoD is subject to restrictions as set forth in 48 CFR 227.7202-1(a) and 48 CFR 227.7202-3(a) or, if applicable, 48 CFR 252.227-7013(c)(1)(ii) (OCT 1988). Unpublished-rights reserved under the copyright laws of the United States. Network Equipment Technologies, Inc./N.E.T. Federal, Inc. 6500 Paseo Padre Parkway Fremont, CA 94555

Introduction to Perl Scripting, Release 2.0

..........................................................
Trademarks IDNX, ADNX, and the N.E.T. logo are registered trademarks, and CellXpress, FrameXpress, Frame Relay Exchange,
ISDNX, LAN/WAN Exchange, Network Equipment Technologies, NetOpen, N.E.T., PanaVue, PortExtender, PrimeSwitch, PrimeVideo, PrimeVoice, Promina, SONET Transmission Manager, STM, and SPX are trademarks of Network Equipment Technologies, Inc. All other trademarks are the sole property of their respective companies. Apache Server source, binaries, and documentation copyright 1995,1996, 1997, 1998 The Apache Group. All rights reserved. This product includes software developed by the Apache Group for use in the Apache HTTP server project (http://www.apache.org/). SunOS and Solaris software copyright held by Sun Microsystems, Inc. Sun Microsystems is a registered trademark and Sun, SunOS, OpenWindows, Solaris, and Ultra are trademarks of Sun Microsystems, Inc. SPARC is a registered trademark of SPARC Internal, Inc. SPARCstation is a registered trademark of SPARC International, Inc. licensed exclusively to Sun Microsystems, Inc. ORACLE and SQL*Plus are trademarks of Oracle Corporation. X-Window System software copyright held by Massachusetts Institute of Technology. Openview, HP, and the HP logo are trademarks of Hewlett-Packard Company. OpenSoftware Foundation, OSF, the OSF logo, OSF/MOTIF, and MOTIF are trademarks of the Open Software Foundation. All other trademarks are the sole property of their respective companies.

Note: In this manual, any reference to PanaVue refers to the PanaVue Management Platform product line, unless specied differently.

Introduction to Perl Scripting, Release 2.0

iii

..........................................................

Introduction to Perl Scripting, Release 2.0

Preface .......................................................... About This Document

This document provides an introduction and short tutorial to the Perl scripting language, as it is used on the PanaVue workstation. It assumes that the user has a working knowledge of how scripting languages have been implemented on the PanaVue workstation; see the PanaVue Scripting Guide for more information on this topic.

Document Organization
The document contains the following sections:
Title Description Provides an overview to the Perl language, what this guide covers, and other resources. Provides an introduction to the syntax of Perl scripts and advice for programmers who are new to Perl. Describes how Perl implements scalar variables, arrays, and associative arrays. Describes the commands used to output information to STDOUT, STDERR, and les.

Introduction to Programming in Perl Basics of the Perl Programming Language Using Variables in Perl Perl Output Commands

Introduction to Perl Scripting

..........................................................
Title Description Describes Perls built-in arithmetic, logical, and relational operators. Describes the Perl control structures: if, unless, while, for, foreach. Describes Perls built-in arithmetic, timekeeping, and string functions. Describes Perls commands for accessing les and directories. Describes how to perform matchings and substitutions on strings using Perls regular expressions. Describes how to write and use procedures (subroutines) in Perl.

Preface

Operators in the Perl Language Control Structures and Loops Perls Built-In Functions File Access in Perl Using Regular Expressions in Perl

Using Subroutines in Perl

Introduction to Perl Scripting

.......................................................... Document Conventions

The following conventions are used in this document:
Convention Promina Example Congure the Promina SNMP agent. Install the Promina 800 Series node. Congure the Promina 4000 switch. The node can be queried using SNMP GET requests. Description Refers either to a Promina 800 Series node or to a Promina 4000 ATM switch, depending on the context. Refers generally to the Promina 100, 200, 400, and 800 Multiservice Access Platform. Refers generally to the Promina 4000 ATM switch. Refers generally to any SNMP-aware network device. Depending on the context, this term can also refer specically to Promina 800 Series nodes or Promina 4000 switches. Refers to the Promina 4000 ATM switch, unless specied differently. Refers to non-printing keys on the keyboard that you press. Refers to non-printing keys on the keyboard that need to be pressed simultaneously.

Preface

Promina 800 Series Promina 4000 node

switch Key name Simultaneous Key

The switch generates SNMPv2 traps. Press the Delete key. Press Shift+F1.

Introduction to Perl Scripting

vii

..........................................................
Convention bold Enter Example Install Card. Enter Install Card. The Alarms Pending message displays on the screen. A gateway node is any node that connects to a domain. For more information, see the Hardware Description manual. Description Indicates a command to be typed. Also used for emphasis. Indicates that after typing the information, press the Return or Enter key. Refers to parameter options and other information displayed by the software. Refers to a new term that is dened.

Preface

italic

Refers to a document or book title.

The following icons are used in this document to provide important information:
Icon Description Warning Denition Provides information on how to avoid a potentially hazardous situation that, if not avoided, could result in death or serious injury.

viii

..........................................................

Preface

xii

Introduction to Perl Scripting

Contents ..........................................................
I n tro d u ct i o n to P r ogra mming in Perl Topics Not Covered in This Manual .............................................................................................................3 What is Perl? .................................................................................................................................................4 Basic Features of Perl ...................................................................................................................................5 For More Information ...................................................................................................................................7 B as i c s o f t h e P e rl P rogra mming Language Using the Perl Interpreter ..............................................................................................................................9 Specifying a #! Line ..............................................................................................................................10 Command Line Options ........................................................................................................................10 -c (check) ........................................................................................................................................11 -d (debugger) ...................................................................................................................................11 -D (Debugger) .................................................................................................................................11 -e (execute) ......................................................................................................................................12 -n (next/loop) ..................................................................................................................................13 -p (print and loop) ...........................................................................................................................13 -s (switches) ....................................................................................................................................13 -S (Search) ......................................................................................................................................14 -T (Taint checking) .........................................................................................................................14

Introduction to Perl Scripting

xiii

..........................................................
-v (version) ......................................................................................................................................15 -w (warnings) ..................................................................................................................................15 -x (extract) .......................................................................................................................................16 Perl Basics ...................................................................................................................................................17 Perl Syntax ............................................................................................................................................17 Naming Conventions ............................................................................................................................20 U si n g V a ri a b l es in P e rl Scalar Variables ..........................................................................................................................................25 Arrays ..........................................................................................................................................................31 Associative Arrays ......................................................................................................................................38 Avoiding Confusion with Perls Variables .................................................................................................46 Special and Predefined Variables ...............................................................................................................48 P e rl O u t p u t C o mm a nds Using the print Command ...........................................................................................................................52 Using the printf Command ..........................................................................................................................55 Using the write Command ..........................................................................................................................59 Writing to Multiple Lines .....................................................................................................................63 Outputting Variables Containing Multiple Lines ................................................................................. 66 Adding Page Headers to a Report .........................................................................................................67

Introduction to Perl Scripting

xiv

..........................................................
Problems with Buffering of Output ............................................................................................................69 O p era t o rs i n th e P e rl La ngua ge Assignment .................................................................................................................................................73 Common Shortcuts ...............................................................................................................................75 Autoincrement and Autodecrement ......................................................................................................76 Relational ....................................................................................................................................................79 Logical ........................................................................................................................................................82 C o n t ro l S t ru ctu re s a nd Loops if/else Command .........................................................................................................................................84 unless/else Command ..................................................................................................................................86 while Command ..........................................................................................................................................88 for Command ..............................................................................................................................................90 foreach Command .......................................................................................................................................93 P e rl s B u i l t - I n F unc t ions Arithmetic Functions ..................................................................................................................................97 abs .........................................................................................................................................................97 atan ........................................................................................................................................................97 cos .........................................................................................................................................................97

Introduction to Perl Scripting

..........................................................
exp .........................................................................................................................................................97 hex .........................................................................................................................................................97 int ..........................................................................................................................................................98 log .........................................................................................................................................................98 oct ..........................................................................................................................................................98 rand .......................................................................................................................................................99 sin ..........................................................................................................................................................99 sqrt .........................................................................................................................................................99 srand ......................................................................................................................................................99 Timekeeping Functions .............................................................................................................................100 time .....................................................................................................................................................100 localtime ..............................................................................................................................................100 gmtime ................................................................................................................................................100 String Functions ........................................................................................................................................101 chomp ..................................................................................................................................................101 chop .....................................................................................................................................................101 chr .......................................................................................................................................................101 index ....................................................................................................................................................102 length ...................................................................................................................................................102 lc ..........................................................................................................................................................102

Introduction to Perl Scripting

xvi

..........................................................
lcfirst ...................................................................................................................................................102 ord .......................................................................................................................................................102 rindex ..................................................................................................................................................103 substr ...................................................................................................................................................103 uc .........................................................................................................................................................103 ucfirst ..................................................................................................................................................103 undef ...................................................................................................................................................104 F i l e A cc e s s i n P erl Using Filehandles ......................................................................................................................................106 Using STDIN, STDOUT, and STDERR ..................................................................................................107 Using STDIN to Read One Line .........................................................................................................108 Using STDIN to Read An Entire File .................................................................................................110 Using STDOUT and STDERR ...........................................................................................................110 Reading Input From the Diamond Operator (<>) .....................................................................................112 Changing the File List .........................................................................................................................112 Finding the Current Filename .............................................................................................................114 Accessing Files on the Command Line ....................................................................................................117 Using Filehandles ......................................................................................................................................119 Opening a File for Read-Only Access ................................................................................................119

Introduction to Perl Scripting

xvii

..........................................................
Opening a File for Write Access .........................................................................................................120 Closing a Filehandle ...........................................................................................................................122 Directory Operations .................................................................................................................................124 Changing the Working Directory ........................................................................................................124 Listing the Files in a Directory ...........................................................................................................125 Reading a Directory Entry Directly ....................................................................................................126 Deleting Files ......................................................................................................................................128 Renaming Files ...................................................................................................................................129 Creating and Removing Directories ....................................................................................................130 File Test Operators ....................................................................................................................................132 U si n g R eg u l a r E x pre s s ions in P erl Defining Regular Expressions ..................................................................................................................138 Rules in Using Regular Expressions .........................................................................................................140 Simple Matching and Replacing ...............................................................................................................144 Using Wildcards in Regular Expressions .................................................................................................155 Wildcards are Greedy ......................................................................................................................157 Using WildCards for Matching ...........................................................................................................159 Using Wildcards for Substitutions ......................................................................................................161 Using Subroutines in Perl

Introduction to Perl Scripting

xviii

..........................................................
Defining Subroutines ................................................................................................................................167 Using a Subroutines Return Value ..........................................................................................................169 Defining Local Variables ..........................................................................................................................174 Passing Arguments ....................................................................................................................................178

Introduction to Perl Scripting

xix

..........................................................

Introduction to Programming in Perl

This document provides an introduction to the Perl language and should be sufcient to allow anyone with any previous programming experience (shell scripts, Basic, C) to begin using and modifying the template scripts that are shipped with the PanaVue Network Management System. This section can also be useful if you do not have any programming experience, but you are strongly advised to also read some of the other Perl resources listed in For More Information on page 7. In particular, the book Learning Perl by Randal L. Schwartz, OReilly and Associates is recommended; this book is useful to all newcomers to the Perl language but especially to beginning programmers. This introduction to Perl is divided into the following sections, each of which describes a major feature of the Perl language: Basics of the Perl Programming Language provides an overview to the structure and common conventions of Perl programs. Using Variables in Perl describes the types of variables and data structures most commonly used in Perl programs. Perl Output Commands describes Perls print, printf, and write commands. Operators in the Perl Language describes the basic arithmetic and string operators that are built-in to Perl.

Introduction to Perl Scripting

..........................................................
Control Structures and Loops describes the control structures and loops most commonly used in Perl programs. Perls Built-In Functions briey lists the basic built-in functions of the Perl language. File Access in Perl describes the use of lenames and lehandles in reading, writing, creating, and deleting les. Using Regular Expressions in Perl describes the use of regular expressions, one of the major features of the Perl language. Using Subroutines in Perl describes how to declare and use subroutines.

Introduction to Programming in Perl

See the following sections for a list of topics that are not covered in this document, as well as a description of Perls basic features and a list of other references about Perl.
Note: This chapter provides only a basic introduction to the Perl language and how it can be used on the PanaVue workstation. It assumes you have some working knowledge of basic programming concepts such as variables, control loops, and subroutines. For a complete reference to these topics and to the Perl language, see the books and online references listed in For More Information on page 7.

Introduction to Perl Scripting

.......................................................... Topics Not Covered in This Manual

This manual does not cover the following features of Perl version 5: Accessing the Unix-style socket interface for network communications Do/while and do/until control structures Managing and accessing database (DBM) les Object-oriented programming and variables Operators that change the operation of loops and control structures (continue, goto, last, next, redo, return) The Perl built-in debugger Reading les in binary mode (binmode) Running external programs using the system and exec functions, and system-level functions such as fork, getppid, and syscall Simplifying control structures by using &&, ||, and ? in a more C-like syntax. The more arcane and sophisticated aspects of regular expressions Using and creating Perl modules (packages) Using pack to store more than one value in each element of an associative array

Introduction to Programming in Perl

Topics Not Covered in This Manual

For more information about these topics, see the online Perl documentation or any of the Perl reference works listed in For More Information on page 7.

Introduction to Perl Scripting

.......................................................... What is Perl?

Perl is the Practical Extension and Report Language, a scripting language written by Larry Wall to produce reports for an early Unix system. Since its rst incarnation as version 1.0, Perl has become increasingly popular, particularly because it is well suited for writing CGI scripts to be used on the World Wide Web (WWW). Perls most recent release, version 5, has also encouraged its use by being accessible to both beginning and experienced programmers. Beginning programmers usually nd Perl is relatively easy to learn and that they can begin writing useful scripts with only a basic knowledge of the language. They can then gradually expand their knowledge of Perl by learning bits and pieces as needed. One of Perls most attractive features is that it usually offers more than one way to do any particular task. Beginning programmers can therefore start off using the simpler approaches that are possible, and then as their experience grows, they can use the more sophisticated techniques. Perl is also attractive to experienced programmers because it is derived from existing utilities and languages such as the Unix shell and the C programming language. Thus, many of the concepts and techniques used in Perl are very familiar to experienced programmers. Also, because Perl scripts are interpreted and does not have to be compiled into a binary program before being run, programmers do not have to endure lengthy compile and link cycles before running their programs. However, the Perl interpreter does do a quick internal compile of each program before it is run, so that any syntax errors can be found and corrected beforehand.

Introduction to Programming in Perl

What is Perl?

Introduction to Perl Scripting

.......................................................... Basic Features of Perl

Larry Wall has called Perl a shell for C programmers, and he intended it to be a free-form language that programmers could use to quickly write programs that would be too simple or tedious for a fully structured language such as C. He kept many of the best features of C, while adding in the strengths of other tools, such as sed and awk, that are used in Unix systems to manipulate text les and databases. Perl was an overnight success with experienced programmers, but Larry Wall has continued to rene the language over the years, broadening its appeal, so that version 5 now offers the following features and capabilities: Perl combines the best features of interpreted and compiled languages. Perl programs are interpreted, so you do not need to perform a manual compile and link before running your programs. However, the Perl interpreter does do a quick internal compile of each script that is run, which not only nds any syntax errors in your program but also increases the speed of your programs execution. Perl is not as structured as the C language, but contains the ow control and array structures that are used most often in C programming. Perl has no built-in limitations. The only limitations as to data size and le size are those of the host system. Perl uses sophisticated regular expressions that simplify text manipulation, pattern matching, and text substitution. Perl often can do in a few lines what it would take a complicated C language program to do. Perls variables can accept both text and binary data without the programmer having to declare the data type in advance.

Introduction to Programming in Perl

Basic Features of Perl

Introduction to Perl Scripting

..........................................................
In addition to scalar data types and standard arrays, Perl offers an associative array that can be used for quick database access and management. Since Perl was originally written to generate reports, it contains many features to help in creating and formatting reports. Perl is easily extensible, so options such as SNMP communication can be incorporated into your programs as if they were part of the Perl language.

Introduction to Programming in Perl

Basic Features of Perl

Introduction to Perl Scripting

.......................................................... For More Information

In addition to this document and the PanaVue Scripting Manual, you can nd more information on Perl from the following online sources: The online man pages, which are accessible through your PanaVue workstation and web browser at http:/idDocs/scripts/perl/htmldocs. You can also access the man pages at the Solaris command line by entering the command man perl. If you have internet access, you can visit the Perl home page at http://www.perl.com/perl, which has links to many other Perl sites, including the Comprehensive Perl Archive Network (CPAN), whose home base is in Finland but which has mirrored archives throughout the world. news:comp.lang.perl.announce a Usenet newsgroup that contains announcements of new releases of Perl and Perl extensions. news:comp.lang.perl.misc a Usenet newsgroup for general discussions about Perl. It is a good place to ask questions about specic programming problems when you cannot nd an answer on your own. news:comp.lang.perl.modules a Usenet newsgroup devoted to discussion of Perl extensions, libraries, and other modules that are not part of the standard Perl package.

Introduction to Programming in Perl

For More Information

The following books are recommended as reference guides and tutorials for the Perl language:

Introduction to Perl Scripting

..........................................................
Learning Perl, second edition, by Randal L. Schwartz and Tom Christiansen, OReilly & Associates, Inc. Sebastopol, CA. July, 1997 (http://www.oreilly.com) a short introduction to Perl that introduces the major concepts and commands. Perl 5 Desktop Reference, by Johan Vromans, OReilly and Associates, Inc. 1996 a pocket-sized quick reference to the Perl programming language. Programming Perl, second edition, by Larry Wall and Randal Schwartz, OReilly and Associates, Inc. 1996 the denitive reference to Perl version 5 by its author. It includes many complete programs that can either be used as is or as templates for your own programs. CGI Programming on the World Wide Web, by Shishir Gundavaram, OReilly & Associates, Inc. Sebastopol, CA. 1996. ISBN: 1-56592-168-2. Web Client Programming with Perl, by Clinton Wong, OReilly & Associates, Inc. Sebastopol, CA. 1996. ISBN: 1-56592-214-X.

Introduction to Programming in Perl

For More Information

The following books describe Perls use for writing web-based CGI scripts:

Introduction to Perl Scripting

..........................................................

Basics of the Perl Programming Language

Using the Perl Interpreter

Basics of the Perl Programming Language

This section describes how to use the Perl interpreter and what command line options can be used with it. It also describes the Perl programming languages basic syntax rules and naming conventions.

Using the Perl Interpreter

On the PanaVue workstation, the Perl interpreter (/usr/thirdParty/perl/bin/perl) is run using a command line similar to the following:
/usr/thirdParty/perl/bin/perl options script.pl command-line-args

where options are the options for the Perl interpreter, script.pl is the Perl script being run, and command-line-args are the arguments that should be passed to the script. As a general habit, you should also include the -w option for all your scripts since that it warns you of many potential problems, such as misspelling a variable name:
/usr/thirdParty/perl/bin/perl -w script.pl command-line-args

See Command Line Options on page 10 for more information about this and other options.

Introduction to Perl Scripting

..........................................................
Specifying a #! Line If the rst line of a script begins with the #! characters, the Perl interpreter rst veries that it should be running the script by looking at this line. If the interpreter does not nd the word perl anywhere on this line, it does not execute the script; instead, it calls whatever program is specied and passes the script to it. For example, if script.sh is a shell script that begins with the line #!/bin/sh, and you give the command perl script.sh, the Perl interpreter executes the command /bin/sh script.sh so that the shell program runs the script itself. This is a quick way of running other scripts if you are not sure which shell or program they belong to, but it is not recommended since it takes several seconds for the Perl interpreter to load, to examine the script le, and to execute the proper command. Command Line Options Perls command line options can be specied either on the command line or as part of the rst line of a standalone script. For example, the -w option instructs the interpreter to print a warning about possible typographical errors and anything else it considers to be a bad programming practice. If you invoke the Perl interpreter directly, specify this option on the command line as follows:
/usr/thirdParty/perl/bin/perl -w script.pl command-line-args

Basics of the Perl Programming Language

Using the Perl Interpreter

If, on the other hand, your scripts are run as standalone commands, add the -w option at the end of the rst line of each script:
#!/usr/thirdParty/perl/bin/perl -w

Introduction to Perl Scripting

..........................................................
Note: It is strongly recommended you use the -w option for all your scripts because it is a way of highlighting potential problems and typographical errors.

Basics of the Perl Programming Language

Using the Perl Interpreter

The following are the most useful command line options for the Perl interpreter. See the online documentation for a complete listing: -c (check) The -c option checks the syntax of a Perl script without actually executing it. This option is especially useful in verifying that the scripts opening and closing braces match, and that all of the library les referenced by use statements actually exist. For example:
perl -c myscript.pl

-d (debugger) The -d option turns on the interactive Perl debugger and it should be used only when running scripts at the command-line. See the online documentation for the Perl debugger for information on using it. For example:
perl -d myscript.pl

-D (Debugger) The -D option customizes the debugger so as to focus on specic operations within your scripts. This option is not enabled in the Perl interpreter that is shipped with PanaVue because including it can signicantly slow down regular operations. To use

Introduction to Perl Scripting

..........................................................
this feature you must recompile the Perl source code with the -DDEBUGGING ag turned on. If you recompile Perl, be certain that you do not overwrite the Perl interpreter that is shipped with the PanaVue system. Instead, put the debugger version of Perl in a separate directory. -e (execute) The -e option executes Perl statements that are given on the command line instead of executing a Perl script. This option is most commonly used with the -n and -p options (see below) to create shell aliases. For example, to create a command named print-old that lists the lenames of all les in the /opt/Panavue/reports directory that are more than 14 days old, dene the following alias in your .cshrc le:
alias print-old "nd /opt/Panavue/reports -mtime +14 -print | perl -ne print; | more"

Basics of the Perl Programming Language

Using the Perl Interpreter

This is a trivial example since the nd command can also print out the lenames, but Perl could be used to delete the old les by modifying the alias as follows:
alias remove-old "nd /opt/Panavue/reports -mtime +14 -print | perl -ne chop; unlink;"

Be careful when using Perl to delete or modify les in this manner. Before using a script that can modify or delete les, you should rst test your Perl script by having it print out the lenames as shown in the rst example. When you are satised that only the proper les are being specied, then modify the alias so that it actually deletes or changes the les.

Introduction to Perl Scripting

..........................................................
-n (next/loop) The -n option instructs the Perl interpreter to continuously loop your script until the end of input (from STDIN or a specied le). This option is commonly used with the -e option (see above). -p (print and loop) The -p option, like the -n option (see above), instructs the Perl interpreter to continuously loop your script until the end of input (from STDIN or a specied le). However, unlike -n, this option prints each line of input after it has been processed. If this option is used with the print-old alias shown above, you do not need Perls print statement:
alias print-old "nd /opt/Panavue/reports -mtime +14 -print | perl -pe | more"

Basics of the Perl Programming Language

Perl Basics

It is strongly recommended you comment your scripts thoroughly, explaining what the script is attempting to do, the logic it is using, and how it is implemented. Doing so makes it easier for others to understand your scripts and helps you when you want to update a script later on. Perl denes true and false slightly differently than other programming languages such as C. When control structures such as if and while and logical operators such as && and || evaluate an expression, true is any nonzero or non-null value. False is the undened value, which in Perl is a null string ("") when used in a string context or the number zero ("0") when used in a numerical context. In practice, the dual denition of the undened value is very convenient, but it can cause some problems in isolated cases when you are converting programs originally written in other languages to Perl. In these cases you should evaluate all test expressions to ensure that they interpret the undened value properly. If Perl has any single distinguishing characteristic, it is that you can accomplish the same task more than one way. For example, there are three obvious ways to read a list of les specied on the command line and many more not so obvious methods. If you look at the various Perl scripts available on the internet, you will see that different programmers routinely use different techniques to accomplish

Introduction to Perl Scripting

..........................................................
the same tasks, and for the most part which one you choose is a matter of personal preference. However, sometimes these different methods have slightly differently requirements and side-effects, so if you nd a method of doing something that works, be cautious about changing it until you have thoroughly tested the alternatives. If Perl has any secondary distinguishing characteristic, it is that a default exists for most operations. Using these defaults where applicable can simplify your scripts but also make them more difcult for others to read. This, though, is also a matter of personal preference.

Basics of the Perl Programming Language

Perl Basics

Naming Conventions

Perl uses the same naming conventions for variables, subroutines, and lehandles: A name can use only word characters, which are dened in Perl as being letters (both uppercase and lowercase), numbers (0 through 9), and the underscore (_) character. If the name does not start with a letter, it can be only one character long. Typically this is not signicant because most variables of this type have predened meanings (see Special and Predened Variables). Names are case-sensitive, so variable refers to a different object than Variable or VARIABLE. As a general rule, lowercase names refer to variables and subroutines, while uppercase names refer to lehandles, but this is only a matter of custom and convention, not a requirement of Perl.

Introduction to Perl Scripting

..........................................................
With the exception of lehandles, an objects name is preceded by a single character that denes what it refers to. See Table 1:
Naming Conventions Identies scalar variable or array element array associative array subroutine Examples $string, $input_line, $number, $answer $array[1], $namelist[22], $months[3] $cards{"prc"}, $days_in_month{"oct"} @array, @namelist, @months %cards, %phone_numbers, %days_in_month &toupper, &get_input, &output_line

Basics of the Perl Programming Language

Perl Basics

Table 1 Symbol $

@ % &

Programmers familiar with other languages often get confused by Perls use of symbols to differentiate between different variable types, especially when accessing elements of an array. This confusion is increased by the fact that Perl allows you to use the same name for scalar variables, array variables, and subroutines. For example, $name, @name, and %name all refer to different variables with different values and structures. Furthermore, $name[0] (a single element of the @name array) and $name{0} (a single element of the %name array) are different from each other and from $name. Furthermore, &name refers to a subroutine, not a variable of any type.

Introduction to Perl Scripting

..........................................................
Until you become comfortable with Perls naming conventions and use of variables, it is highly recommended that you use unique names for each variable and subroutine in your scripts. See Special and Predened Variables on page 48 for more information on the different types of variables and how to use them. See Using Subroutines in Perl on page 166 for information on dening and using subroutines.

Basics of the Perl Programming Language

Perl Basics

Introduction to Perl Scripting

..........................................................

Using Variables in Perl

Unlike other languages that use a dozen or more different data types for variables, Perl has only three basic variable types: Scalar Variables scalar variables have a dollar sign ($) prex and contain either a number or a string. Perl uses the context of a scalar variables use to determine whether it contains numeric or string data. Examples of scalar variables are $string, $number, $day_of_week. See Scalar Variables on page 25 for more information. Arrays an array is an ordered list of one or more scalar variables, each of which could contain either numeric or string data. Arrays have an at-sign (@) prex and their elements are accessed by an index number that starts with 0 and ends with the last number of the array. Examples of arrays are @array, @lines, and @last_names. See Arrays on page 31 for more information. Associative Arrays an associative array is a special type of array, one that contains only pairs of scalar variables. The rst variable of each pair is the key and the keys are used instead of numerical indexes to access the arrays data. Associative arrays have a percent-sign (%) prex. Examples of arrays are %passwords, %days_of_the_week, and %daily_schedule. See Associative Arrays on page 38 for more information.

Unlike other programming languages, Perl does not require you to declare your variables in advance. Instead, the Perl interpreter scans your program to determine

Introduction to Perl Scripting

..........................................................
what variables are used so it can allocate and deallocate variable space as needed. Because of this approach, Perl has no way of knowing when you have mistyped a variables name; if you mistype $datf instead of $date, Perl does not complain but instead assumes you want to use a new variable. (You can catch many of these errors, though, by using the -w command line option; see Command Line Options on page 10 for more information.) Perl also features a number of predened and special variables that your programs can access to get information such as the scripts name, the version of Perl that is being run, and so forth. See Special and Predened Variables on page 48.
Note: Filehandles are a specialized data type; see File Access in Perl for their use. Perl 5 also supports object-oriented programming and data types, but their use is beyond the scope of this manual. See the Perl reference manual (online the PanaVue workstation at http:/idDocs/scripts/perl) for more information.

Using Variables in Perl

Introduction to Perl Scripting

.......................................................... Arrays
Perl supports arrays in much the same manner as other programming languages, except that you do not have to declare the array and its size in advance. Perl automatically grows and shrinks the array as elements are added and taken from it. Perls arrays have the following additional characteristics: An array variable starts with an at-sign (@) but other than that, it can use any combination of word characters (letters, numbers, and the underscore) as part of its name. Variable names are case-sensitive, so @var, @VAR, and @Var are all different arrays. Elements of the array are referenced by putting a dollar sign ($) to the front and a subscript within square brackets ([]) to the back of the variable name, creating a new form of scalar variable. The rst element of any array is always numbered 0 (zero), so the rst elements of the above arrays are $var[0], $VAR[0], and $Var[0].

Using Variables in Perl

Arrays

Note: Do not confuse the scalar variables used to access arrays with other scalar variables that have the same name. The scalar $var is totally independent of $var[0] or $var[1], which are used to access elements in the @var array. To avoid such confusion, it is recommended that you use different names for scalar variables and arrays.

Like scalar variables, elements of an array can contain either numeric or string data. The elements in an array do not have to have the same type of data; some elements can contain numeric data, other elements can contain strings.

Introduction to Perl Scripting

..........................................................
The easiest way to assign values to an array is with a list, which can be either another array, a set of scalars (literals or variables) within parentheses, or a function or command that returns a list of values. See Example 3 for examples of each method:
Using a List to Add Elements to an Array

Using Variables in Perl

while ($input = <STDIN>) { # get new line from STDIN $length = @array; # get current length of array $array[$length] = $line; # put input at end of array } # do this until input ends

Note: See Control Structures and Loops for an explanation of loops such as the while loop shown above. See File Access in Perl for an explanation about using STDIN.

The routine shown in Example 9 reads a line of input from the standard input device (STDIN, usually the users keyboard) and then adds the line to the end of an array. Each time an element is added to the array, its length increases, so each time the while loop executes, the value of the $length variable increases by one.
Note: Elements can also be added to (or removed from) an array using the array operators listed in Table 4, below.

Introduction to Perl Scripting

..........................................................
A number of operators can be used on arrays. The most common ones are shown in Table 4:
Array Operators (1 of 2) Description Removes the last character from each element in the array: @array = ("one","two","three"); chop(@array); # @array now = ("on","tw","thre") Adds one or more new entries to the end of an array: @array = (1,2,3); push(@array,4,5,6); # @array now = (1,2,3,4,5,6) Removes and returns the last entry at the end of an array: @array = (1,2,3,4,5,6); $last_element = pop(@array); # $last_element = 6 # @array = (1,2,3,4,5) Returns an array in reverse order, leaving the original array unchanged: @array1 = (1,2,3,4,5,6); @array2 = reverse(@array1); # @array1 is unchanged # @array2 = (6,5,4,3,2,1)

Using Variables in Perl

Arrays

Table 4 Operator chop

Using Variables in Perl

Associative Arrays

# Adding elements to an associative array using another associative array %array1 = %array2; # %array1 becomes an exact copy of %array2 # Adding elements to an associative array using a list of ordered scalar values # (the list must be composed of key/value pairs) %array1 = (1,2,3,4); # %array1 contains 2 elements # $array{1} = 2, $array{3} = 4 %array2 = (1,"two",3,"four");# %array2 contains 2 elements # $array{1} = "two", $array{3} = "four" %array3 = ($a, $b, $c, $d); # %array3 contains 2 elements # $array{$a} = $b, $array{$c} = $d # Adding elements to an array using the output of a function (in this case, # the split command, which takes a line of input and breaks it into individual # words that are returned in a list) $input = "john x7990 jill x5917 joan x6134"; # typical input line %extens = split($line); # %extens now contains three elements: # $extens{"john"} = "x7990" # $extens{"jill"} = "x5917" # $extens{"joan"} = "x6134"

To assign scalar values to an individual elements of an associative array, use the appropriate key. If you specify a new key, a new element is added to the array; if you specify a previously used key, that elements previous value is replaced. See Example 11:

Introduction to Perl Scripting

..........................................................
Example 11 Adding and Modifying Elements of an Associative Array

Using Variables in Perl

Associative Arrays

#!/usr/thirdParty/perl/bin/perl -w # Initialize array with two elements %computers = ("robert","pc","judy","mac"); # Add new elements and modify existing ones $computers{"jerry"} = "sparc5"; $computers{"linda"} = "sparc20"; $computers{"robert"} = "sparc20"; $computers{"judy"} = "powerbook"; print %computers; # # # # add new element add new element modify element modify element

# print out all keys and element values

Note: Perl orders associative arrays in the most efcient internal format for the given keys and computer system. If you print out an associative array as shown in Example 11, you cannot easily predict which elements will be printed rst.

To delete an element from an associative array, use the delete operator on the element to be deleted:
delete $computers{"robert"}; # this entry no longer exists

Using a previously unknown key with an associative array returns the undened value. If you were to take the array dened in Example 11 and access $computers{"william"}, you would get an undened value. No indication is given that you have used a previously unknown key, which is inconvenient if you want to access only current elements of the array.

Introduction to Perl Scripting

..........................................................
Perl offers a way around this with its keys operator, which returns all of the keys used for a particular associative array, which you can then use to access all of the elements in that associative array. The keys operator returns the keys in the same order that they are used in the associative array at that time, so there is no guarantee as to how the keys are ordered. However, since the keys operator returns the keys as a regular array, you can access all of the elements in the associative array by manipulating the regular array created to hold all of the keys. See Example 12 for one way to do this:
Example 12 Printing the Contents of an Associative Array

Using Variables in Perl

Associative Arrays

%cars = ("alan","ford","jill","toyota","jack","chrysler"); @keys = foreach print } # end keys(%cars); # @keys now = ("alan","jill","jack") $key (@keys) { "$key drives a $cars{$key}\n"; foreach

Note: See Control Structures and Loops for an explanation of loops such as the foreach loop shown above.

The code shown in Example 12 can be shortened by eliminating the use of the @keys array, as shown in Example 13:

Introduction to Perl Scripting

..........................................................
Example 13 Printing the Contents of an Associative Array (modied)

Using Variables in Perl

Associative Arrays

%cars = ("alan","ford","jill","toyota","jack","chrysler"); foreach $key ( keys(%cars) ) { print "$key drives a $cars{$key}\n"; } # end foreach

When the keys operator is used in a scalar context, it returns the number of keys found, which gives you the number of elements in an associative array:
Finding the Number of Elements in an Associative Array

Example 14

%cars = ("alan","ford","jill","toyota","jack","chrysler"); print "The number of cars is ",$length=keys(%cars),"\n";

The counterpart to the keys operator is the values operator, which returns a list of element values found in an associative array. The list provided by values operator is in the same order as the one provided by the keys operator, so you could use both to print the associative array. See Example 15:
Printing the Values of an Associative Array

Example 15

%cars = ("alan","ford","jill","toyota","jack","chrysler"); @car_type = values(%cars); # create array of values @driver = keys(%cars); # create array of keys $index = 0;

Introduction to Perl Scripting

..........................................................
while ($car_type[$index]) { print "$driver[$index] drives a $car_type[$index++]\n"; } # end while

Using Variables in Perl

Associative Arrays

The most efcient method to loop through an associative array is to use the each operator, which returns key/value pair each time it is used. When each reaches the end of the associative array, it returns the undened value, which makes it a perfect match for use with the while command.
Printing the Values of an Associative Array Using each

Example 16 %cars = while ( print } # end

("alan","ford","jill","toyota","jack","chrysler"); ($driver, $car_type) = each(%cars) ) { "$driver drives a $car_type\n"; while

You can convert between an associative array and a regular array by assigning the one to another.
Converting Between Associative and Regular Arrays

Example 17

# Converting Associative Array to a Regular Array %cars = ("alan","ford","jill","toyota","jack","chrysler"); @cars = %cars; # @cars has six separate elements # Converting Regular Array to an Associative Array @books = ("camel","Programming Perl", "llama","Learning Perl",

Introduction to Perl Scripting

..........................................................
"rhino","Javascript", "koala","HTML, the Definitive Guide"); %books = @books; # %books now has four elements, indexed # by the type of animal on the cover

Using Variables in Perl

Associative Arrays

$] $! $|

Introduction to Perl Scripting

..........................................................
Table 6 Variable Commonly Used Special and Predefined Variables (2 of 3) Description

Using Variables in Perl

Special and Predefined Variables

Variables used for operating system access $0 $$ $< $> $( $) The name of the currently executing Perl script. The Unix process ID of the currently executing Perl program. The real user ID (uid) of the currently executing process. The effective user ID of the currently executing process. The real group ID (gid) of the currently executing process. The effective group ID of the currently executing process.

Variables used for file access (see File Access in Perl) $ARGV @ARGV The name of the current le when using the diamond operator (<>) for input. An array containing the scripts command line arguments.

Variables used for regular expressions (see Using Regular Expressions in Perl) $& $ The string matched by the last successful match. The string preceding the string that was last matched.

Introduction to Perl Scripting

..........................................................
Table 6 Variable $ $1 ... $9 Commonly Used Special and Predefined Variables (3 of 3) Description The string following the string that was last matched. Represents the appropriate subpatterns when matching and substituting regular expressions.

Using Variables in Perl

Special and Predefined Variables

Note: Table 6 shows the shortcut form of these special variables. Most of these variables also have an English name that is more descriptive. For example, $_ can also be referred to as $ARG. See the Perl documentation (http:/idDocs/scripts/perl) for these alternative names.

Introduction to Perl Scripting

..........................................................

Perl Output Commands

Perl uses three main commands for output of text-based information: print outputs a list of variables, strings, and numbers with no modication or formatting. By default the output goes to STDOUT, but you can also print to any le you have previously opened for writing. printf outputs a formatted list of variables, strings, and numbers to either STDOUT or an output le. This command is almost identical to the printf command that is used in the C programming language. write outputs one or more lines of variables, strings, and numbers to either STDOUT or an output le, using a previously dened report format. The write command can output the output data over multiple lines, depending on the dened format, and keeps track of how many lines have been printed so that the appropriate page numbers can be printed.

Note: Perl offers a number of ways to read and write binary information to les. See the descriptions of the read, seek, sysread, and syswrite commands in the online Perl documentation (http:/idDocs/scripts/perl).

If you are writing CGI scripts, also see Problems with Buffering of Output on page 69 for information on a potential problem with how Perl buffers its output for such scripts.

Introduction to Perl Scripting

.......................................................... Using the print Command

The print command outputs a list to the specied lehandle, and its format is the following:
print FILEHANDLE list

Perl Output Commands

Using the print Command

The FILEHANDLE must have been previously opened for writing; if not, print returns "0" to indicate it failed to output the list. If FILEHANDLE is not given, print uses the default output device (which is STDOUT, unless changed by the select command).
Note: See File Access in Perl for a discussion of both lehandles and STDOUT.

The list can contain any or all of the following: literals, scalar variables, arrays, associative arrays, and the output from functions, commands, and expressions. Strictly speaking, all items in the list should be separated by Perls list operators (commas), as shown in Example 18:
Example 18 Using the print Statement (strict style)

$name = "Roger"; $car = "Ford"; $color = "blue"; print "\n",$name," owns a ",$color," ",$car,"\n"; # prints Roger owns a blue Ford

Introduction to Perl Scripting

..........................................................
This example prints a new line and then the text Roger owns a blue Ford, followed by another new line. Fortunately, Perl allows variables to be placed inside the quotes, so this print statement could be more easily written as follows:
Example 19 Using the print Statement

Perl Output Commands

Using the print Command

$name = "Roger"; $car = "Ford"; $color = "blue"; print "\n$name owns a $color $car\n"; # prints Roger owns a blue Ford

The only time you must use commas is if you put a function or expression in the print statement that must be evaluated before being printed. For example, if you wanted to print the value of from within a Perl program, you might think you can use the statement shown in Example 20:
Example 20 Printing the Value of (incorrect)

print "The value of pi is atan2(1,1)*4\n";

However, this statement just prints The value of pi is atan2(1,1)*4, without evaluating the expression but just treating it as a string of characters. To force Perl to evaluate the expression, move it out of the double quotes and delimit it with commas. See Example 21:

Introduction to Perl Scripting

..........................................................
Example 21 Printing the Value of (correct)

Perl Output Commands

Using the print Command

print "The value of pi is ",atan2(1,1)*4,"\n";

This line correctly prints The value of pi is 3.14159265358979. With few exceptions, if you want the print statement to display the output of a command or expression, you must move the command or expression outside double quotes and separate it from the rest of the list using commas. Since arrays are just another type of list, you can specify them in the print command. Each element of the array is then printed in sequence, without any separation. See Example 22:
Example 22 Printing an Array

@names = ("john","jill","bob","bruce","jean"); print "@names\n";

The code in Example 22 prints out the following line:

johnjillbobbrucejean

Introduction to Perl Scripting

.......................................................... Using the printf Command

Perls printf command is almost identical to that used in the C programming language; it prints out a list of data that is formatted according to a set of format specications. The printf command has the following format:
printf FILEHANDLE formats, list

Perl Output Commands

Introduction to Perl Scripting

..........................................................
incorrect format is given (such as an exponential format for string data), Perl tries its best to interpret the list item in that format, with unpredictable results.

Perl Output Commands

Using the printf Command

Introduction to Perl Scripting

.......................................................... Using the write Command

Perl is the Practical Extension and Report Language, so it is not surprising that it includes an easy way to generate formatted reports. Perl uses the write command for this purpose, which has the following format:
write FILEHANDLE;

Perl Output Commands

Using the write Command

where FILEHANDLE is a lehandle for a le that has been previously opened for writing; if no FILEHANDLE is listed, write uses the default output device (which is STDOUT, unless changed by the select command).
Note: See File Access in Perl for an explanation of lehandles and the STDOUT device.

The write command does not take a list of items to be printed, as the print and printf commands do. Instead, the write command outputs one or more lines in a predened format. This format must have the same name as the FILEHANDLE being used and includes the list of variables and expressions to be printed. A format is dened with the format command, as shown in Example 24:
Example 24 Dening a Format for the write Command # # # # # formatname must = filehandle name contains formatting information contains list to use in above line contains formatting information contains list to use in above line

format formatname = fieldline variable-list fieldline variable-list .

# last line for the format must

Introduction to Perl Scripting

..........................................................
# begin with a period and have # nothing else on the line

Perl Output Commands

Using the write Command

Each eldline describes one line of output, and there can be as many eldlines as desired. A eldline can contain literals, variables, or both. A variable-list must follow each eldline that prints variables. The last line of the format must contain only a single period as its rst and only character. Each eldline can contain spaceholders, eldholders, or both. A spaceholder is text that is reproduced exactly as it appears and can include anything except the special characters used in eldholders. A eldholder represents the space taken up by a variable and determines the output format of that variable. The number of eldholders in a eldline must match the number of variables in a variable-list on the next line. The eldholders can be surrounded by any number of spaceholders, but there must be a one-to-one correspondence between the eldholders on one line and the variables on the next. The eldholder determines the output format of its corresponding variable, using the basic set of format types given in Table 8:

Introduction to Perl Scripting

..........................................................
Table 8 Format @<<<<< Fieldholder Formats Description Left-justified fixed-length field. The length of output is determined by the number of less-than signs (<) plus 1 for that at-sign (@). If the variable requires less space, the output is padded on the right with space; if the variable requires more space, its output is truncated. Right-justified fixed-length field. The length of output is determined by the number of greater-than signs (>) plus 1 for that at-sign (@). If the variable requires less space, the output is padded on the left with spaces; if the variable requires more space, its output is truncated. Center-justified fixed-length field.The length of output is determined by the number of pipe signs (|) plus 1 for that at-sign (@). If the variable requires less space, the output is padded on both sides to ll out the eld and keep it center; if the variable requires more space, its output is truncated. Fixed-precision numeric field. The minimum number of digits before the decimal point is determined by the at-sign (@) and the number of number signs (#) before the decimal point. If the number has more digits, they are still printed; if the number has fewer digits, the number is padded on the left with spaces. The number signs (#) after the decimal point determines the precision of output. If the number has more digits than this after the decimal point, the number is rounded up or down. If the number has fewer digits, it is padded with zeroes on the right.

Perl Output Commands

Using the write Command

@>>>>>

@|||||

@####.##

Introduction to Perl Scripting

..........................................................
For example, Example 25 shows a script that writes a very simple report to a le named phone.lst (see File Access in Perl for information about opening and closing les). A format named PHONES is dened for this report, and it species that each line in the report contains a name and the corresponding phone number; the name of each person is allocated 11 spaces and the phone number is allocated eight spaces. Spaceholders include the text Name: and Extension: , which precede the two eldholders.
Example 25 Sample Report

Perl Output Commands

Using the write Command

%phones = ("Alan","5990","Betty","4301", "Bob","6100","Cathy","7132", "Doris","2395","Edith","6175", "Frank","5986","Geena","5810", "Harry","6323","Jane","7788"); open(PHONES,">phone.lst") || die("Could not open phone.lst for writing.\n"); foreach $name (sort(keys %phones)) { write PHONES; } close(PHONES); format PHONES = Name: @<<<<<<<<<< $name, . Extension: @<<<<<<< $phones{$name}

Introduction to Perl Scripting

..........................................................
Note: As shown in Example 25, the last line of a format denition must contain only a single period. No other characters can appear on this line, including comments; otherwise, Perl generates an error message.

Perl Output Commands

Using the write Command

When the program in Example 25 is run, it generates the following output:

Example 26 Name: Name: Name: Name: Name: Name: Name: Name: Name: Name: Sample Report Output Alan Betty Bob Cathy Doris Edith Frank Geena Harry Jane Extension: Extension: Extension: Extension: Extension: Extension: Extension: Extension: Extension: Extension: 5990 4301 6100 7132 2395 6175 5986 5810 6323 7788

Writing to Multiple Lines

The simple script shown in Example 25 used an array dened within the script as its data source. Typically, though, reports involve reading a data le of some type and extracting the desired information from it, putting that information into the proper variables, and using the write command to generate a formatted report. Although sometimes the data from a le can t on just one line, it often must be split across multiple lines. You can accommodate this data by using a caret (^) instead of an at-sign (@) when specifying your formats; repeat the format specication on as many lines as needed.

Introduction to Perl Scripting

..........................................................
For example, to update the PHONES report shown in Example 25 so it includes a persons home address, you could rewrite the PHONES format as follows:
Example 27 Format Specication that Accommodates Multiline Information

Perl Output Commands

Using the write Command

format PHONES = Name: @<<<<<<<<<< Extension: @<<<<<<< $name, $phones{$name} Address: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $address ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $address ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $address .

When Perl uses this format, it tries to t the entire $address variable in the rst eldline set aside for it. If the address cannot t, Perl ts as much of it as possible and then splits the address at the closest word break and tries to t it in the second line. If the address is still too long, this process is repeated with the third line. If the address is still too long for all three lines, it is truncated. If the address does not take up all of the lines set aside for it, Perl prints out the remaining lines as blank lines.
Note: In addition to the left-justied (<) operator shown above, you can also use the centering (|) and right-justied (>) operators when using the caret (^) operator.

Introduction to Perl Scripting

..........................................................
If the above formatting were used for the PHONES report, typical output could be the following:
Example 28 Sample Multiline Report Output

Perl Output Commands

Using the write Command

Name: Jane Extension: 7788 Address: 400 Apple Tree Lane #220, Fremont, CA 94555 (this line is actually a blank line in the report)

To suppress any extra blank lines, put the tilde (~) anywhere in the eldline. For example, the following format prints out a second and third line for the address only if the address actually requires them:
Example 29 Format Specication that Suppresses Blank Lines

format PHONES = Name: @<<<<<<<<<< Extension: @<<<<<<< $name, $phones{$name} Address: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $address ~^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $address ~^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $address .

Introduction to Perl Scripting

..........................................................
Outputting Variables Containing Multiple Lines The caret (^) operator uses whitespace characters (the space, tab, newline, carriage return, and formfeed characters) to determine where to break a variables text into words so it can be split across lines. In doing so, all newline characters, except those that actually end lines of the formatted output, are converted into spaces. To preserve the newline characters in your input text, use the multiline operator (@*) in your formats. This operator should be the last eldholder in its line, and the next line must contain the scalar variable or array that contains the multiline data. For example, to preserve the formatting of the $address variable used above, you could rewrite the PHONES format as follows:
Example 30 Multiline Format that Preserves Newline Characters

Perl Output Commands

Using the write Command

format PHONES = Name: @<<<<<<<<<< $name, Address: @* $address .

Extension: @<<<<<<< $phones{$name}

..........................................................
Example 34 Script with Buffering Problems

Perl Output Commands

Problems with Buffering of Output

#!/usr/bin/perl print print print print "Content-type: text/html\n\n"; "<HTML><HEAD><TITLE>Current Date and Time</TITLE></HEAD>\n"; "<BODY>\n"; "<PRE>\n";

system("/usr/bin/date"); print "</PRE>\n"; print "</BODY></HTML>\n";

You can simulate what happens with this CGI script by running it as part of a pipe from the command line. For example, if this script is named show_date.pl, give the following command at the command line:
show_date.pl | cat

Ths produces output similar to that shown in Example 35 (note that the output from the date command is shown before that of the print commands, even though the print commands are run rst in the script).
Example 35 Simulating a CGI Scripts Pipe Behavior

% ./test.flush.pl | cat Mon Jun 15 10:43:13 PDT 1998 Content-type: text/html <HTML><HEAD><TITLE>The Current Date and Time</TITLE></HEAD>

Introduction to Perl Scripting

..........................................................
<BODY> <PRE> </PRE> </BODY></HTML>

Perl Output Commands

Problems with Buffering of Output

This problem can be solved by setting a special variable ($| or $OUTPUT_AUTOFLUSH) to any non-zero value to force line-buffering of the print, printf, and write commands. Example 36 shows the same script, but now because $| is set to a nonzero value it will work as a CGI script.
Example 36 Script without Buffering Problems

#!/usr/bin/perl $| = 1; # force line-buffering of print commands # You could also use $OUTPUT_AUTOFLUSH = 1 print print print print "Content-type: text/html\n\n"; "<HTML><HEAD><TITLE>Current Date and Time</TITLE></HEAD>\n"; "<BODY>\n"; "<PRE>\n";

system("/usr/bin/date"); print "</PRE>\n"; print "</BODY></HTML>\n";

Introduction to Perl Scripting

..........................................................

Operators in the Perl Language

Perl has borrowed operators from every major programming language, so they should be familiar to anyone with previous programming experience. Unless otherwise noted, these operators work on all variable types and data types, but there are different sets of operators that should be used only on numeric data and on string data.
Note: This section can give only a brief description of these operators. For complete information see the online Perl documentation (http:/idDocs/scripts/perl).

Introduction to Perl Scripting

.......................................................... Assignment
The basic assignment operator is the equal sign (=). In a simple assignment, the variable that is on the left side is assigned the value of whatever is on the right (which can be a numerical literal, a string literal, a set of values, another variable, or the output of a subroutine):
Example 37 Simple Assignments

Operators in the Perl Language

Assignment

$number = 4; $string = "Hello, world"; @array = (1,2,3,4); $var1 = $var2; $answer = &get_answer;

Typically, the equal sign is combined with one of the operators shown in Table 9. The examples given in the table use numeric and string literals (such as 1 and "dog"), but variables can be used as well.
Table 9 Operator Assignment Operators (1 of 3) Description Examples

Basic Arithmetic Operators + * addition subtraction multiplication $a = 2 + 3; # $a becomes 5 $a = 6 - 2; # $a is now 4 $a = 3 * 4; # $a is now 12

Introduction to Perl Scripting

..........................................................
Table 9 Operator / ** % Assignment Operators (2 of 3) Description division exponentiation modulo division Examples $a = 12/4; # $a is now 3 $a = 3**4; # $a is 81 (3 to the fourth power) $a = 10%3; # $a is 1 (the remainder of 10/3)

Operators in the Perl Language

Assignment

Binary (Bitwise) Operators (you should be familiar with binary numbers and binary logic to use these operators) & | ^ ~ >> << bitwise AND (binary AND) bitwise OR (binary OR) bitwise XOR (binary XOR) bitwise NOT (binary negation) bitwise shift right (binary shift right) bitwise shift left (binary shift left) $a = 8 & 2; # $a is 0 $a = 20 & 4; # $a is 4 $a = 8 | 2; # $a is 10 $a = 20 | 4; # $a is 20 $a = 8 ^ 2; # $a is 10 $a = 20 ^ 4; # $a is 16 $a = ~8; # $a is 4294967287 (the 32-bit ones complement of 8) $a = 15>>2; # $a is 3 $a = 4>>3; # $a is 0 $a = 15<<2; # $a is 60 $a = 4<<3; # $a is 32

Introduction to Perl Scripting

..........................................................
Table 9 Operator Assignment Operators (3 of 3) Description Examples

Operators in the Perl Language

Assignment

String Operators . x string concatenation string multiplication $a = "dog" . "cow"; # $a is now "dogcow" $a = "a" . "b" . "c"; # $a is now "abc" $a = "abc" x 4; # $a is now "abcabcabcabc" $a = "moof" x 2; # $a is now "moofmoof"

Note: A common mistake in Perl programming is to use arithmetic operators on string data. Although this is allowed, it usually produces unpredictable results; at best, the string is treated as the number 0 (zero), but this is not guaranteed in all cases.

Common Shortcuts

The operators shown in Table 9 are most commonly used to modify the existing value of a variable, as is shown in Example 38:
Example 38 $number $string $var1 = $bits = Standard Assignment Notation

= $number + 4; = $string . "Hello, world"; $var1/$var2; $bits << 2;

Because this is such a common use of these operators, Perl supports a shortcut notation for it, by appending the equal sign (=) to the operator and eliminating the second instance of the variable being changed. See Example 39:

Introduction to Perl Scripting

..........................................................
Example 39 Shortcut Assignment Notation

Operators in the Perl Language

Assignment

$number += 4; $string .= "Hello, world"; $var1 /= $var2; $bits <<= 2;

Autoincrement and Autodecrement

One further shortcut is with the autoincrement and autodecrement operators (++ and --), which are shorthand for the following common operations:
$a = $a + 1; $a = $a - 1;

Using the autoincrement and autodecrement operators, these commands become:

Introduction to Perl Scripting

..........................................................
Table 10 Operator le cmp Relational Operators (3 of 3) Description string greater than or equal string compare Examples if ($name1 le $name2) { print "$name1 is less than or equal to $name2"); } $name1 cmp $name2 returns 0 if $name1 eq $name2 1 if $name1 gt $name2, -1 if $name1 lt $name2

Operators in the Perl Language

if (some-expression) { one-or-more-statements; } # end of if else { one-or-more-statements; } # end of else

The if statement evaluates the expression within the parentheses and if it evaluates to a true value (non-zero and non-null), the rst block of statements is executed. If the expression evaluates to the undened value (either "" or "0"), the second block of statements (the else statement) is executed. For example, the if/else clause in Example 44 determines which line to print on the basis of whether two variables are equal or not:
Example 44 Sample if/else Statement

if ($a == $b) { print "The two variables are equal.\n"; } else { print "The two variables are NOT equal.\n"; }

Introduction to Perl Scripting

..........................................................
The else statement is optional; if it does not exist, the if statement simply falls through to the rest of the script if the expression inside its parentheses is not true. Because you sometimes have to test for more than one possible value, the else statement can also have the form elsif, which is shorthand for else if. Example 45 shows an if statement that has two elsif clauses and one else clause:
Example 45 Sample if/else Statement

Control Structures and Loops

if/else Command

.......................................................... foreach Command

Perls foreach statement is written almost identically as in the C language:
Example 53 Syntax of the foreach Statement

Control Structures and Loops

foreach Command

foreach $element (@list) { block-of-statements-to-do-for-each-element; } # end foreach

The $element variable is any scalar variable, and it becomes a placeholder for each element in the given @list, which can be an array, a literal list, or anything that evaluates to a list. The foreach statement executes the block of statements within the loop for each element of the list, substituting the actual element of the array for the $element variable. For example, Example 54 shows a script that reads in a series of lines from STDIN and uses two foreach loops; the rst foreach loop uses the tr (translate) function to convert each line to uppercase, and the second loop prints out the entire array.
Example 54 Typical foreach Loop

#!/usr/thirdParty/perl/bin/perl -w @array = <STDIN>; # read all of the lines at once foreach $string (@array) { $string =~ tr/a-z/A-Z/; } # end foreach foreach $string (@array) { # converts array to uppercase # one line at a time # array is now in uppercase

Introduction to Perl Scripting

..........................................................
print "$string"; } # end foreach

Control Structures and Loops

foreach Command

The code in Example 54 is equivalent to the following two for loops:

Example 55 Using for Instead of foreach

#!/usr/thirdParty/perl/bin/perl -w @array = <STDIN>; for ($i=0; $array[$i]; $i++) { $array[$i] =~ tr/a-z/A-Z/; # convert to uppercase } # end for for ($i=0; $array[$i]; $i++) { print "$array[$i]"; } # end for

It might appear that the foreach loop is redundant and unnecessary, but it offers two major advantages over for: The foreach loop can access any list, including lists that are not in predened arrays. Example 56 shows foreach being used to convert a line to uppercase on a word-by-word basis, without having to rst put the words in an array:
Using foreach on a Non-Array List

Example 56

#!/usr/thirdParty/perl/bin/perl -w while (<>) { foreach $word (split()) { # split line into words $word =~ tr/a-z/A-z/; # convert to uppercase print "$word\n";

Introduction to Perl Scripting

..........................................................
} # end foreach } # end while

Control Structures and Loops

foreach Command

The technique shown in Example 56 is often used when creating lters, which are programs that accept lines of input, usually from STDIN, process each line in some way, and output the lines, usually to STDOUT. The second advantage of foreach loops is that the @list array in a foreach loop can be processed by an array function before being used. The most common functions used in this way are the reverse and sort commands. For example, the script in Example 56 could be easily modied so that the words in each line are sorted before they are converted to uppercase and printed. See Example 57:

Example 57

Using foreach on a Sorted Array

#!/usr/thirdParty/perl/bin/perl -w while (<>) { foreach $word (sort split()) { # split and sort words $word =~ tr/a-z/A-z/; # convert to uppercase print "$word\n"; } # end foreach } # end while

To reverse the order of the words, use the reverse command instead of sort in the third line of the above script.

Introduction to Perl Scripting

..........................................................

Perls Built-In Functions

Perl contains a great many built-in functions for the convenience of the programmer. The most commonly used functions are shown in this chapter, divided up into the following categories: arithmetic functions perform the standard mathematical and trigonometric functions timekeeping functions return and process the time and date values string functions process strings in some way

See the Perl reference guide that is online the PanaVue workstation at http:/idDocs/scripts/perl/htmldocs for more information on using these functions and for a list of the other, less commonly used functions.

Introduction to Perl Scripting

.......................................................... Arithmetic Functions

The following arithmetic expressions should be used only on numeric data, as using them on string values can produce unpredictable results. Unless otherwise specied, expression must be a scalar variable or expression that evaluates to a numeric value. abs abs(expression) Returns the absolute value of expression:
$a = 1; $a = abs($a); # $a = 1 $a = -1; $a = abs($a); # $a = 1

Perls Built-In Functions

Arithmetic Functions

atan

atan2(y,x) Returns the arctangent of X/Y in the range of - to :

$pi = atan2(1,1)*4; # get the value of pi

cos

cos(expression) Returns the cosine, in radians, of expression:

$a = cos(3.14159); # $a is (approximately) -1

exp

exp(expression) Returns e to the power of expression.

.......................................................... String Functions

undef

undef(expression) Returns the undened value (either a null string ("") or a zero ("0")), and initializes the specied expression to the undened value. The expression can be either a scalar variable (either numeric or a string) or an array (in which case all of its elements are set to the undened value). If expression is omitted, returns the undened value, which can be useful for certain tests.
$a = undef(b); # both $a and $b = ""

Introduction to Perl Scripting

104

..........................................................

File Access in Perl

One of Perls strongest points is its ease in reading and writing les, particularly the les that are specied as arguments on the command line. As with everything else, Perl offers many ways to accomplish this task: Reading and writing the standard lehandles of STDIN (standard input), STDOUT (standard output), and STDERR (standard error). Using the diamond operator (<>), which automatically reads input from the set of les specied on the command line, or if no les were specied, from STDIN. Accessing the les specied on the command line using the predened @ARGV array. Opening les and using the resulting lehandles to read from and write to those les.

In addition to reading and writing les, Perls directory operators allow you to read directories to nd the lenames in them. Perls le test operators also allow you to test les for various characteristics.

Introduction to Perl Scripting

105

.......................................................... Using Filehandles

As is typical with Unix-style programs, Perl scripts access les using lehandles, which are a special type of variable used for le access. Unlike other variables, lehandles do not have any special prex such as $ or @, but otherwise they follow the same rules: they can be composed of any word characters (letters, numbers, or the underscore), they are case-sensitive, and they can have the same name as another variable of another type. Thus le, FILE, File, and FIL_E are all valid lehandles, even if other variables have these same names. Perl treats all of these lehandles as separate objects and does not confuse them with other variables of different types. However, it is highly recommended that you use the standard Perl convention for lehandles, which is to use only capital letters. This makes it immediately obvious which variables are lehandles and helps avoid confusion when others read your programs.
Note: In addition to the above le techniques, Perl includes functions to open, read, and write database (DBM) les. See the online Perl reference guide (http:/idDocs/scripts/perl) for details.

File Access in Perl

Using Filehandles

Introduction to Perl Scripting

106

.......................................................... Using STDIN, STDOUT, and STDERR

The Solaris operating system automatically assigns three standard input/output devices to every program, including Perl scripts: STDIN (standard input) used for input from the user. The default assignment is to the users terminal (keyboard). STDOUT (standard output) used for output to the user. The default assignment is to the users console (screen). STDERR (standard error) used to output error messages to the user. The default assignment is to the to the users console (screen).

File Access in Perl

Using STDIN, STDOUT, and STDERR

Note: Your Perl scripts can change the assignments of the standard lehandles by closing them and reopening them so they refer to les or other devices.

Normally when STDIN is used, it reads a line of input from the users keyboard. Similarly, when STDOUT and STDERR are used, they output to the users screen. These default assignments, though, can be changed on the Solaris command line, using the standard I/O redirection operators (< and >). For example, to set STDIN to be a le, enter a command similar to the following:
/usr/thirdParty/perl/bin/perl myscript.pl < input-le

If myscript.pl is run like this, whenever it reads a line from STDIN, it actually reads a line from input-le. Similarly, to redirect STDOUT to a le, enter a command similar to the following:

Introduction to Perl Scripting

107

..........................................................
/usr/thirdParty/perl/bin/perl myscript.pl > output-le

File Access in Perl

Using STDIN, STDOUT, and STDERR

Both redirection operators can be combined on the same command line:

/usr/thirdParty/perl/bin/perl myscript.pl < input-le > output-le

When this command is run, input from STDIN comes from input-le and output sent to STDOUT is saved in output-le.
Note: STDERR can be redirected as well, but the exact syntax depends on the type of shell you are using. This normally is not done, though, since messages to STDERR are usually intended to inform the user of an immediate problem.

print "This line goes to STDOUT by default.\n";

Note: You can change the default lehandle for the print, printf, and write commands using the select command. See the online Perl reference guide (http:/idDocs/scripts/perl) for details.

Introduction to Perl Scripting

111

.......................................................... Reading Input From the Diamond Operator (<>)

File Access in Perl

Accessing Files on the Command Line

The script shown in Example 67 displays the scripts name and all of the scripts command line arguments:
Example 67 Displaying all Command Line Arguments

#!/usr/thirdParty/perl/bin/perl -w $i = 0; print "This script is named $0.\n\n"; while ($ARGV[$i]) { print "This is command line arg # $i: $ARGV[$i++].\n"; }

Introduction to Perl Scripting

117

..........................................................
The arguments on the command line can be anything that the user typed, including switches (such as -x and -y), directory names, commands, and lenames. Your script should therefore parse this information and verify it before use. See File Test Operators on page 132 for ways you can test a string to see if it is a valid le.

File Access in Perl

Accessing Files on the Command Line

Introduction to Perl Scripting

118

.......................................................... Using Filehandles

As explained at the start of this section, lehandles are a special type of variable that is used for le access. The STDIN, STDOUT, and STDERR variables are really nothing more than lehandles that are automatically opened by the Perl interpreter when it runs your script; if you want to use any other lehandles, your script must specically create them. Opening a File for Read-Only Access Use the open command to create a lehandle for a le you want to read:
open(FILEHANDLE,"lename");

File Access in Perl

Using Filehandles

where FILEHANDLE is the name of your lehandle and lename is the name of the le you want to open (you can either use a literal such as "myle.txt" or a scalar variable such as $lename). The open command returns true if it was successful in opening the le and the undened value if not. Perl allows you to read undened lehandles, so you should test the results of the open command before attempting to use a lehandle:
Example 68 Testing for a Valid Open Operation

if (open(FILEHANDLE,"filename")) { print "The open successfully created the filehandle.\n"; } else { print "Could not open the file.\n"; } or unless (open(FILEHANDLE,$filename)) {

Introduction to Perl Scripting

119

..........................................................
print "Could not open $filename.\n"; } else { print "The open successfully created the filehandle.\n"; }

File Access in Perl

Using Filehandles

Being unable to open a le usually means your script has encountered a fatal error and should exit. Perl offers a quick way of doing this by using the die command, which prints a user-dened message to STDERR and then exits. See Example 69:
Example 69 Using the die Operator

open(FILEHANDLE,$filename) || die("$0:Could not open $filename - exiting.\n");

If being unable to open a le is not a fatal error but is something the user should be notied about, you can use the warn operator. See Example 70:
Example 70 Using the die Operator

open(FILEHANDLE,$filename) || warn("$0:Could not open $filename - continuing...\n"); program continues here;

Opening a File for Write Access

To open a new le for writing, add a greater-than sign (>) to the front of the les name:

Introduction to Perl Scripting

120

..........................................................
Example 71 Opening a New File for Writing

File Access in Perl

Using Filehandles

open(FILEHANDLE,">filename"); or open(FILEHANDLE,">$filename");

Note: You must use double quotation marks when opening a le for writing, both when specifying a literal for the lename (such as ">lename") and when you specify a scalar variable (such as ">$lename"). You can also use the die or warn operator, as shown in Example 69, when opening les for writing.

The commands shown in Example 71 automatically delete, without any warning, any existing le that has the same name as the le you are attempting to open. If this is not what you want, you should open the le using the append operator (>>). This species that the le should be opened for writing, but that all output should be appended to the end of the currently existing le. See Example 72:
Example 72 Opening a New File for Appending

open(FILEHANDLE,">>filename"); or open(FILEHANDLE,">>$filename");

Note: You can also test for a les presence before opening it. See File Test Operators on page 132.

Introduction to Perl Scripting

121

..........................................................
To write to an opened lehandle, specify the lehandle when using the print command:
Example 73 Writing to a Filehandle

File Access in Perl

Using Filehandles

$logfile = "/opt/Panavue/logs/perl.log"; open(LOGFILE,">>$logfile") || die("$0:Could not open $logfile.\n\n"); print LOGFILE "This line is being written to $logfile\n";

Since writing to a le after it has been opened can fail for a number of reasons, such as running out of disk space, consider testing the result of any print commands that write to les. For example, Example 74 shows the OR operator (||) being used with the print command; if the print to the LOGFILE lehandle is unsuccessful, the second print statement sends an error message to STDERR.
Example 74 Writing to a Filehandle

$logfile = "/opt/Panavue/logs/perl.log"; open(LOGFILE,">>$logfile") || die("$0:Could not open $logfile.\n\n"); print LOGFILE "This line is being written to $logfile.\n" || print STDERR "$0:Could not write to $logfile\n";

Closing a Filehandle

Use the close command to close a lehandle:

Introduction to Perl Scripting

122

..........................................................
close(FILEHANDLE);

File Access in Perl

Using Filehandles

Perl automatically closes any open les when your script terminates, but closing les when they are no longer needed is still a good habit to get into since it ensures that any data that was cached by the operating system is written to the le, which might not happen if a user abnormally terminates the program with a CTRL-C. Closing the le also frees up any memory structures that were used for the lehandle and its buffers.

Introduction to Perl Scripting

123

.......................................................... Directory Operations

Perl includes a set of directory operators to allow you to perform such functions as listing the les that are in a given directory, moving between directories, and removing a le from a directory. Changing the Working Directory The chdir command changes the working directory to whatever string is specied. The working directory is the default directory for reading and writing les whose lenames do not include a full path, so changing the working directory is advised when you plan to read or write a lot of les in a certain directory. See Example 75:
Example 75 Changing the Working Directory

File Access in Perl

Directory Operations

Note: Use the closedir command to close a directory lehandle after use.

Deleting Files

The unlink command deletes a le and it operates on lenames, not lehandles, so you do not need to open a le before using this function. The unlink command can delete either a single le or a list of les, and it has the following formats:
Example 83 unlink Command Formats # file is specified as a literal # file is specified as a scalar var # list of files specified as an array # list of files specified as glob

unlink("filename"); or unlink($filename); or unlink(@files); or unlink(<*>);

The unlink command attempts to delete all of the specied les and then returns the number of les that have been successfully deleted. If you want to verify that all les

Introduction to Perl Scripting

128

..........................................................
have been deleted, you must either count the number of les in advance or test for the supposedly deleted les presence (see File Test Operators on page 132).
Note: The unlink command deletes les without warning, so use it very carefully, particularly when specifying a list of les or when using wildcards.

File Access in Perl

Directory Operations

Renaming Files

The rename command renames a le and it operates on lenames, not lehandles, so you do not need to open a le before using this function. Example 84 shows the format of the rename command:
Example 84 Renaming a File

rename("oldfile","newfile"); # using literals rename($oldfile,$newfile); # using scalar variables

If the specied lenames do not have complete pathnames, they are assumed to be in the current working directory. If rename does successfully rename the given le, it returns true; otherwise, it returns the undened value. See Example 85:
Example 85 Example of Renaming a File

if (rename($oldfile,$newfile)) { print "Successfully renamed $oldfile to $newfile\n"; } else { print "Could not rename $oldfile to $newfile\n"; } # end if

Introduction to Perl Scripting

129

..........................................................
Note: Perl scripts can rename or delete les only if the scripts are run by a user who has the permissions needed to change those les at the command line.

File Access in Perl

Directory Operations

Creating and Removing Directories

Perl has its own versions of the Unix mkdir and rmdir commands to create and remove directories. The mkdir function takes two arguments, the name of the directory and its set of permissions:
mkdir("dirname",chmod-value); or mkdir($dirname,$chmod-value);

The directory name can be either a literal string or a scalar variable that species either a full or partial pathname. The permissions must be in the octal format used by the Unix chmod program (see the chmod manpage for details). The mkdir function returns true if successful and the undened value if not. If the directory could not be created, the special variable $! is also set with the appropriate error code. Example 86 attempts to create a directory named tmp in the current working directory, giving all users complete read, write, and execute permissions to the directory:
Example 86 Creating a Directory

if ( mkdir("tmp",0777) ) { print "Successfully created the tmp directory\n"; } else { print "$0:Unable to create directory because of:\n";

Introduction to Perl Scripting

130

..........................................................
print "\t$!, error number ",$!+0,"\n"; }

File Access in Perl

Directory Operations

The rmdir command removes a current directory, assuming the directory has no les in it and the scripts user ID has the proper permissions. The rmdir command removes one directory at a time, and like mkdir, it sets the $! variable if it fails. See Example 87:
Example 87 Removing a Directory

if ( rmdir("tmp") ) { print "Successfully removed the tmp directory\n"; } else { print "$0:Unable to remove directory because of:\n"; print "\t$!, error number ",$!+0,"\n"; }

Introduction to Perl Scripting

131

.......................................................... File Test Operators

Because you often need to know something about a le before using it, Perl offers a number of le test operators that can tell you almost anything you need to know about a le.Table 12 lists the available operators according to category; unless otherwise specied, each operator returns true (non-zero) if the test succeeds. Where appropriate, the le tests also work with directories as well as les.
Table 12 Operator File Test Operators Description Information about the File and Its Contents -B -b -c -d -e -f -l -p File is a binary le (opposite of -T) File is a block special le File is a character special le File is a directory, so it must be opened with the opendir function and read using the readdir function. File exists it could be of any size, though, including zero bytes, so use either -s or -z, below, to test it further. File is a plain le File is a symbolic link File is a named pipe (FIFO)

File Access in Perl

File Test Operators

Introduction to Perl Scripting

132

..........................................................
Table 12 Operator -S -s -T -t -z File is a socket Returns the size of the le (a non-zero size evaluates to true, a zero size evaluates to false). Also see -z below. File is a text le Filehandle is opened to a tty File has zero size Information about the File or Directorys Timestamp -A -C -M Returns the time that the le or directory was last accessed in days (including fraction for the part that is less than 24 hours). Returns the time that the le or directory was created in days (including fraction for the part that is less than 24 hours). Returns the time since the le or directory was last modied in days (including fraction for the part that is less than 24 hours). Information about the File or Directorys Permissions -O -R -W File is owned by real user ID File is readable by real user ID/group ID File is writable by real user ID/group ID File Test Operators Description

One of the reasons Perl has become so popular is the power and exibility of its regular expressions (commonly referred to as regexp). Programmers familiar with the type of regular expressions used in Unix commands such as awk, grep, sed, and vi nd Perls regular expressions to be similar, but Perl includes a number of features that are not available in these other programs. At their simplest, regular expressions embody the same principle as the Find and Replace features of the typical word processor. The user of a word processor enters one or more words to nd, and the word processor searches the le to nd every place this word appears. When the desired word is found, the word processor can either replace it with another word of the users choosing or continue searching for the next occurrence. Regular expressions in Perl are used in much the same manner to do the following: To nd a particular pattern of characters To delete a particular pattern of characters To replace one pattern of characters with another

Unlike most word processors, though, regular expressions can use very complex patterns that check for many different words, phrases, or sets of characters at the

Introduction to Perl Scripting

136

..........................................................
same time. For example, if you have a report that lists all of the alarms in a Promina 800 Series network, you might want to print out only the trunk and link alarms. This would be difcult to do with a typical word processor because you would have to rst search for link alarms and then do another search for trunk alarms. Then you would have to separate those lines out and print them. In Perl, though, you can use one statement to search for both patterns at once. You could also narrow the search to a specic set of nodes and trunk cards, or even do a search that excludes all trunk and link alarms, printing out the rest. Many other options exist when using Perls regular expressions.

Using Regular Expressions in Perl

Introduction to Perl Scripting

137

.......................................................... Defining Regular Expressions

In Perl, a regular expression is dened in the same way it is done with the sed or vi utilities: by enclosing it within two forward slashes, as shown in Example 89:
Example 89 Typical Regular Expressions

Using Regular Expressions in Perl

Defining Regular Expressions

/trunk alarms/ /Node 152/ /Robert/ /Monday/

Similarly, a substitution pattern is dened as it is in sed or vi the letter s is followed by three forward slashes that separate the pattern to be matched from the pattern that is to replace it. See Example 90:
Example 90 Typical Substitution Patterns

s/trunk alarms/link alarms/ s/Robert/Bob/ s/Monday/Tuesday/ s/not needed//

In the examples given in Example 90, the text trunk alarms is replaced by link alarms, the name Robert is replaced by Bob, and Monday is replaced by Tuesday. The nal example deletes the two words not needed.

Introduction to Perl Scripting

138

..........................................................
Note: The forward slashes are only the default delimiters for regular expressions and substitution patterns. You can specify other nonalphanumeric character for this purpose by preceding the rst delimiter with m, as in m#Monday#Tuesday#. See the online Perl reference guide (http:/idDocs/scripts/perl) for further details.

Using Regular Expressions in Perl

Defining Regular Expressions

Introduction to Perl Scripting

139

.......................................................... Rules in Using Regular Expressions

When using regular expressions, a few basic rules apply in all cases: When matching a regular expression, the match is done against the default variable for standard input ($_) unless another variable is specied by using the regexp operator (=~). This greatly simplies using regular expressions when the input is either STDIN or the diamond operator, which can use the default variable. For example, a Perl script that reads a set of les and looks for a particular pattern could have a basic structure no more complex than that shown in Example 91:
Example 91 Template for Using Regular Expressions for Matching

Using Regular Expressions in Perl

Rules in Using Regular Expressions

143

.......................................................... Simple Matching and Replacing

The simplest possible match is one where the text being searched matches the desired pattern exactly. Such searches can be done with the equality operators for strings (eq and ne), as shown in Example 95. This script reads lines from a le specied on the command line (or from STDIN) and prints out all lines that are not Robert:
Example 95 A Simple Match

Using Regular Expressions in Perl

Simple Matching and Replacing

#!/usr/thirdParty/perl/bin/perl -w while (<>) { # read from file/STDIN chop; # chop off the newline char $name = $_; # assign the line of input to $name if ($name ne Robert) { # is the name Robert? print "$name\n"; # if not, then print it } # end of if } # end of while

Text can also be replaced in this manner, as shown in the script in Example 96, which prints all lines unchanged except for Robert, which is printed as Bob:
Example 96 A Simple Substitution

#!/usr/thirdParty/perl/bin perl -w while (<>) { # read from file/STDIN chop; # chop off the newline char $name = $_; # assign the line of input to $name if ($name ne Robert) { # is the name Robert?

Introduction to Perl Scripting

144

..........................................................
print "$name\n"; } # end if else { $name = "Bob"; print "$name\n"; } # end of if/else } # end of while # if not, then print it # otherwise, if the name is "Robert" # replace "Robert" with "Bob" # and print the new name

Simple Matching and Replacing

#!/usr/thirdParty/perl/bin perl -w while (<>) { # read from file/STDIN s/\bRobert\b/Bob/ig; # if Robert exists in either upper # or lowercase letters, but only as # a complete word, change to Bob # everywhere on the line print; # print the line } # end of while

Introduction to Perl Scripting

148

..........................................................
The script shown in Example 100 thus can make more intelligent substitutions, such as the following:
Example 101 Typical Substitutions becomes becomes becomes remains My name is Bob. Bob robertson Bob, Bob My name is Roberta.

Using Regular Expressions in Perl

Simple Matching and Replacing

My name is Robert. robert robertson Robert, Robert My name is Roberta.

The word boundary marker (\b) is one of four anchoring patterns that can be used to limit a match to a specic situation. Table 13 lists these patterns and illustrates their use:
Table 13 Anchor Pattern \b \B ^ $ Description matches a word boundary matches anything but a word boundary matches the beginning of a line matches the end of a line Anchoring Patterns for Regular Expressions Example /\bmail\b/ matches mail but not email nor mailman /\Bmail/ matches emailer and remail but not mail nor mailman /mail\B/ matches mailman and emailer but not mail nor email /^mail/ matches mail when it appears in the line mail is easy to use but not when it appears in the line I nd mail easy to use. /mail$/ matches mail when it appears in the line I like mail but not in the lines I like mail. (because the line ends with a period) nor the line I like mail sometimes.

Introduction to Perl Scripting

149

..........................................................
The anchoring patterns shown in Table 13 are a subset of a large number of special characters that can be used to limit a match using regular expressions. Most of these special characters are used to match nonprintable characters (such as the newline character), but some of them refer to a group of characters (such as whitespace characters or numeric digits). See Table 14:
Table 14 Anchor Pattern \d \D Description matches any digit (0-9) matches any non-digit (any character that is not 0-9) matches a formfeed character (ASCII 12 or CTRL-L) matches a newline character (ASCII 10 or CTRL-J) matches a carriage return character (ASCII 13 or CTRL-M) Special Characters for Regular Expressions (1 of 2) Example /N\d\d/ matches N20 or N91 but not NOPr /N\d\d/ matches Nor or Not but not N00 through N99

Using Regular Expressions in Perl

Simple Matching and Replacing

/end of page\f/ matches the words end of page only if they are immediately followed by a formfeed character /end of line\n/ matches the words end of line only if they are immediately followed by a linefeed character /end of line\r/ matches the words end of line only if they are immediately followed by a carriage return character (this match is not usually used in Unix systems, where only the newline character is dened as only linefeed, but it could be useful for les from DOS or Macintosh computers that use the carriage return)

Introduction to Perl Scripting

150

..........................................................
Table 14 Anchor Pattern \s Description matches any whitespace character (space, tab, newline, carriage return, or formfeed) matches any nonwhitespace character matches a tab character (ASCII 9 or CTRL-I) matches any word character (0-9, a-z, A-Z, or the underscore) matches any non-word character Special Characters for Regular Expressions (2 of 2) Example /Node\sCard/ matches the words Node and Card only if they are separated by one space, tab, newline, carriage return, or formfeed character /Node\SCard/ matches the words Node and Card only if they are not separated by a whitespace character (for example: Node-Card or NodesCard) /Node\tCard/ matches the words Node and Card only if they are separated by one tab character. /N\w\w\w/ matches N120, N_21, Node, and Nick, but not N.12 or N1-2 (since the period and hyphen characters are not word characters). /N\W/ matches N., N-, or the letter N followed by whitespace, but not No or N1

Using Regular Expressions in Perl

Simple Matching and Replacing

\t \w

Finally, to match a character with a specic ASCII value, specify that value in one of the three ways shown in Table 15:

Introduction to Perl Scripting

151

..........................................................
Table 15 Anchor Pattern \OOO \xHH \cX Description Specifying an ASCII Value Example /\15/ matches ASCII 13 (CTRL-M) /\141/ matches ASCII 97 (the letter a) /\x0D/ matches ASCII 13 (CTRL-M) /\x61/ matches ASCII 97 (the letter a) /\cM/ matches ASCII 13 (CTRL-M) /\cZ/ matches ASCII 26 (CTRL-Z)

Using Regular Expressions in Perl

Simple Matching and Replacing

OOO species an octal value. HH species a hexadecimal value X species a control character (A-Z)

The special characters given in Table 13, Table 14, Table 15 can be combined as desired to nd very specic patterns. For example, if you log in to a node using the Operator Interface and query the event log, the events are displayed in the following format:
Example 102 Typical Event Log

..........................................................
Table 16 Wildcard Character1 {x,y} Perl Wildcards (2 of 2) Description The square brackets match a specic number of consecutive instances of the immediately previous character, where x and y dene the range of allowable matches. For example: /1{5,10}/ matches from ve through ten consecutive instances of the number 1. Both the comma and second number of the range are optional. If the comma is present but not the second number, the second number is assumed to be innity. Thus, /\s{5,}/ matches ve or more whitespace characters. If both the command and second number are missing, the rst number species the exact number of characters that must be found. Thus, /\s{5}/ matches exactly ve whitespace characters. If six whitespace characters are present on a line, only the rst ve are matched. The square brackets specify a match with any of the enclosed characters. The characters can be listed singly ([abcdefg]) or as a range ([a-g]). For example: [0-9] is equivalent to the \d special character and matches any single digit; [a-zA-z0-9_] is equivalent to the \w special character and matches any word character. When followed by a carat (^), the square brackets specify a match with anything except the enclosed characters. The characters can be listed singly ([âbcdefg]) or as a range ([â-g]). For example: [^0-9] is equivalent to the \D special character and matches any single character except a digit; [â-zA-z0-9_] is equivalent to the \W special character and matches any single character except a word character.

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

[char list]

[^char list]

1. 2.

To match any of the wildcard characters themselves, put a backslash before the character. For example: /\./ matches the period (.) character, /\*/ matches one asterisk character, /\?/ matches a single question mark, and so forth. Be careful when using the asterisk (*) and question mark (?) since they are optional matches (they can match zero instances of a character or pattern). You might think the expression /\d*\.?\d*/ matches any set of decimal numbers (such as 1.0 or 0.899) but in reality it always matches any string because all of the search patterns are optional. When using * and ? in regular expressions, be sure you include at least one non-optional pattern to ensure a valid match is made.

Introduction to Perl Scripting

156

..........................................................
Note: Do not confuse Perls wildcards with those used on the Unix command line. When used on the command line, the asterisk (*) refers to zero or more of any characters; also, the question mark (?), not the period (.), is used on the command line to represent any single character.

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

Wildcards are Greedy

Perls wildcards are governed by two overriding rules: 1. Given a choice, earlier matches take precedence over matches that start later in a line. 2. If more than one match is possible with a given starting point, Perl returns the longest possible match. This behavior is called greedy and is why /.*/ matches everything on a line except the newline character. This greedy behavior of wildcards, though, can be both useful and troublesome. If, for example, you wanted to nd the last word in a sentence, you might consider using /\b.*\./ because you assume it nds only the last word boundary before a period. In reality, this regular expression returns everything between the rst whitespace on the line and the last period. Example 104 shows a Perl program that demonstrates this aspect of wildcards:
Example 104 Demonstrating a Greedy Match

#!/usr/thirdParty/perl/bin/perl -w while (<>) { /\b.*\./; # read from file/STDIN # match last word in sentence

Introduction to Perl Scripting

157

..........................................................
print "$&\n"; } # # # # print what was matched (using the read-only variable Perl defines for this purpose) end while

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

If you were to give the following line to this script:

Perls wildcards exhibit greedy behavior.

Using Wildcards in Regular Expressions

#!/usr/thirdParty/perl/bin/perl while (<>) { # read from file/STDIN if (/N\d+C\d+[BP]\d+/) # if port or bundle # { print; } # print the line } # end while

Note: When devising complex regular expressions, it is recommended you use the approach shown in Example 107 through Example 109: start off by writing and testing a regular expression that matches the common features of a desired pattern (in this case, the node and card numbers). Then make the regular expression more specic in a step-by-step manner, testing each step to make sure the proper patterns are being matched.

Using Wildcards for Substitutions

Wildcards can also be used for substitutions, as shown in Example 110, which substitutes the words PORT/BUNDLE for every port or bundle number found on a line:

Introduction to Perl Scripting

161

..........................................................
Example 110 Substituting Port and Bundle Numbers

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

#!/usr/thirdParty/perl/bin/perl while (<>) { # read from file/STDIN s/N\d+C\d+[BP]\d+/PORT\/BUNDLE/g; # do substitution on # all port/bundle #s print; # print the line } # end while

This script prints lines as shown in Example 111:

Example 111 Examples of Substitutions for Port and Bundle Numbers remains remains becomes becomes Node N75 Card N10C12 Port PORT/BUNDLE Bundle PORT/BUNDLE

Node N75 Card N10C12 Port N10C12P13 Bundle N23C7B1

Although this sort of blanket pattern substitution might be useful on occasion, wildcard substitutions are more often done using Perls ability to separate a regular expression into subpatterns using parentheses. When a set of parentheses surrounds a portion of a regular expression, that part of the expression can be referenced later by using a special set of read-only substitution variables: $1 refers to the rst parenthetical expression (as read from left to right), $2 refers to the second such expression, and so forth.
Note: Perl also allows you to refer to the read-only substitution variables as \1 through \9, but this usage is discouraged since it does not work in all situations.

Introduction to Perl Scripting

162

..........................................................
Example 112 shows the port/bundle substitution script rewritten to include parenthetical expressions so that more intelligent substitutions can be done:
Example 112 Substitution Using Read-Only Variables

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

#!/usr/thirdParty/perl/bin/perl -w %pbwords = ("B", "Bundle", "P", "Port", "b", "Bundle", "p", "Port"); # define an associate array to translate # "P" and "B" to the corresponding words while (<>) { # read from file/STDIN s/N(\d+)C(\d+)([BP])(\d+)/Node $1, Card $2, $pbwords{$3} $4/ig; # do substitution using # memorized values print; # print the line } # end while

The script in Example 112 still searches for port and bundle numbers, but now when one is found, it is converted from the NCP or NCB format into one that spells out the words node, card, port, and bundle. To achieve this, the new script has undergone three major changes from the previous one: The script now starts out by dening an associative array (%pbwords) which matches the letters b and B to the word Bundle and the letters p and P to the word Port. Since the regular expression matches either port or bundle numbers, this array uses the third letter (B or P) as the key to determine which word (Bundle or Port) should be printed. Since the regular expression is case-insensitive, the array needs to include both upper and lowercase letters.

Introduction to Perl Scripting

163

..........................................................
The matching portion of the regular expression has been rewritten to include four sets of parentheses:
N(\d+)C(\d+)([BP])(\d+)

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

If a match is made, the rst four read-only substitution variables ($1, $2, $3, and $4) are lled in with whatever was matched. Specically, the $1, $2, and $4 variables are set to the actual node, card, and port or bundle numbers that were matched. The $3 variable is lled with either a B, b, P, or p, depending on what was found in the input line.
Note: The read-only substitution variables are set to new values only when a regular expression contains the appropriate number of parenthetical expressions AND a match is made. If no matches are ever made, these variables remain empty, and once a match is made, these variables retain their values until another match is made. As a general rule, therefore, assume these variables do not contain valid data unless the last regular expression had a successful match.

The substitution portion of the regular expression has been rewritten so that it can substitute the words Node, Card, Port, and Bundle in front of the appropriate node, card, port, and bundle numbers:
Node $1, Card $2, $pbwords{$3} $4

Because the third variable ($3) could contain either a B or P (in either upper or lowercase), the substitution uses the %pbwords associative array to determine what word should be used. The word Bundle is substituted for either a B or b and the word Port is substituted for either a P or p in the original line.

Introduction to Perl Scripting

164

..........................................................
These changes to Example 112 allow more intelligent substitutions to be performed, where the original text determines the type of substitution that should be done:
Example 113 N75 N10C12 N10C12P13 N23C7B1 Examples of Substitutions Using Read-Only Variables remains remains becomes becomes Node Card Node Node N75 N10C12 10, Card 12, Port 13 23, Card 7, Bundle 1

Using Regular Expressions in Perl

Using Wildcards in Regular Expressions

Introduction to Perl Scripting

165

..........................................................

Using Subroutines in Perl

Like most languages, Perl supports the use of subroutines, which are useful for organizing your scripts into discrete parts, each part performing a specic function. Organizing your scripts into subroutines can make it easier to test and debug them, without having to worry about whether one part of your script is having unintended side-effects on another section. Perl allows you to dene subroutines anywhere in your program, unlike other languages that require them to be dened before they are rst used. One common convention among Perl programmers is to put subroutines at the end of the program, where they are easily locatable without getting in the way of the main part of the program. However, this choice is an arbitrary one and Perl allows you to follow your personal preference in the placing of subroutines.

Introduction to Perl Scripting

166

.......................................................... Defining Subroutines

A subroutine is dened using the sub keyword and following format:
Example 114 Dening a Subroutine

Using Subroutines in Perl

Defining Subroutines

sub subroutine-name { insert one or more Perl statements here } # end of subroutine definition

The rest of your Perl script then accesses the subroutine by attaching an ampersand (&) to the front of its name:
&subroutine-name; # call this subroutine

By default a subroutine can access any variables in your program; the only variables it cannot access are those dened as local within other subroutines (see Dening Local Variables on page 174). Many subroutines can therefore perform their needed functions without any arguments being passed to or from them. For example, the script in Example 115 uses a subroutine named convert_to_upper to translate whatever is in the default operator ($_) to uppercase. The script reads one line, calls the subroutine to convert it, and then prints the converted line.
Example 115 Using a Typical Subroutine

#!/usr/thirdParty/perl/bin/perl -w while (<>) { # while reading files/STDIN

Introduction to Perl Scripting

167

..........................................................
&convert_to_upper; print; } ###### ### SUBROUTINE DEFINITIONS ###### sub convert_to_upper { tr/a-z/A-Z/; # translate whatever is in $_ # to uppercase } # end of subroutine definition # convert line to uppercase # print the uppercase line # end while

Using Subroutines in Perl

Defining Subroutines

While it is often convenient to have subroutines directly affect the data in the main program, this can lead to subroutines having unexpected side-effects on the rest of the program. To avoid this, you can instead pass data to and from subroutines, as described in the following sections.

Introduction to Perl Scripting

168

171

..........................................................
# split line into words and # return as an array } # end of subroutine definition split(/\s+/);

Using Subroutines in Perl

Using a Subroutines Return Value

You might also think that you could simplify the tokenize subroutine into a single line, as shown in Example 119:
Example 119 Poorly Modied Subroutine that Returns an Array as a Value

#!/usr/thirdParty/perl/bin/perl -w while (<>) { # while reading files/STDIN # Tokenize the line and combine the returned tokens into a # comma-separated string and print them print("The words found in the line are:\n"); $token_list = join(', ',sort(&tokenize)); print("\t$token_list\n\n"); } # end while ###### ### SUBROUTINE DEFINITIONS ###### sub tokenize { split(/\s+/,($_ =~ s/[^\w\s]//g)); # split line into words and # return as an array } # end of subroutine definition

However, if you make this modication the script no longer prints out a list of words; at most it prints out only one number. This is because the substitution function, like

Introduction to Perl Scripting

172

Passing Arguments

You can pass any type of variable to a subroutine: scalar, array, associative array, or a mixture of these. Neither the number of variables nor their types need to be declared in advance because Perl automatically puts a subroutines arguments into a local array named @_. When creating this array, Perl inserts the passed arguments into the array in the order they were passed to the subroutine. Scalar variables are assigned one array slot each, while arrays are copied in element by element. A subroutine can access the @_ array as with any other array; it can act upon the array as a whole with operators such as split, or it can act upon individual elements of the array ($_[0], $_[1], and so forth). Thus, if you pass a subroutine two scalar variables and an array with 12 elements, that subroutines @_ array contains 14 separate elements. It is up to the subroutine to determine which elements came from which source and which ones it wants to use. You can determine the number of elements either by setting a scalar variable equal to the array (such as $length=@_;) or by looping through the elements of the array until you reach the rst one that is undened. Example 123 demonstrates both methods:

Introduction to Perl Scripting

178

..........................................................
Example 123 Subroutine Using an Array as Passed Argument

Using Subroutines in Perl

Passing Arguments

Passing Arguments

# local associative array

while ($_[$i]) { $_{$_[$i]} = $_[$i+1]; # recreate associative array $i = $i + 2; # point to next key value } # end while print "John is a ",$_{"john"}; print " and Jill is a ",$_{"jill"},".\n"; } # end subroutine definition

Introduction to Perl Scripting

182

Index .......................................................... Symbols

! operator 82 != operator 79 !~ operator 81, 141 $! variable 48, 130, 131 $# variable 34, 110 $$ variable 49, 99 $% variable 68 $& variable 49, 142 $( variable 49 $) variable 49 $/ variable 48 $< variable 49 $= variable 67 $> variable 49 $] variable 48 $_ variable 48 using while reading files 109 $| variable 48, 71 $ variable 49, 142 $ variable 50, 142 $0 variable 49, 117 $1 variable 50 $ARGV variable 49, 114 $OUTPUT_AUTOFLUSH variable 71 % operator 74 && operator 82 ** operator 74 < operator 80 <= operator 80 <=> operator 80 <> operator 112 to 116 getting a list of files 125 getting the current file name 114 == operator 79 =~ operator 81, 140 > operator 79 >= operator 80 @* operator 66 @_ variable 178 @ARGV array 49, 112, 117 to 118 || operator 82

A
abs command 97 anchoring patterns for regular expressions 149 arithmetic functions 97 arithmetic operators 73 arrays 31 to 37 $# variable 34 @ARGV 49, 112, 117 to 118 adding elements using a list 32 avoiding confusion 46 converting to an associative array 44 operators 36 reading an entire file 110 rules 31

Introduction to Perl Scripting, Release 2.0

Index - 1

..........................................................
using $# to get the last element number 110 using with subroutines 178 assignment operators 73 associative arrays 38 to 45 adding or modifying elements 39 avoiding confusion 46 converting to a normal array 44 deleting an element 41 extracting the keys 42 extracting the values 43 using with subroutines 178 atan command 97 abs 97 atan 97 chdir 124 chomp 101 chop 36, 101 chr 101 close 122 closedir 128 comments (#) 18 cos 97 die 120 each 44 exp 97 for 90 to 92 foreach 93 to 95 format 59 gmtime 100 hex 97 if 84 to 85 index 102 int 98 lc 102 lcfirst 102 length 102 localtime 100 log 98 mkdir 130 oct 98 open 119 to 122 opendir 126

Index

B
binary bitwise operators 74 boolean operators 82 buffering of output commands 69

C
chdir command 124 chomp command 101 chop command 36, 101 chr command 101 close command 122 closedir command 128 cmp operator 81 command line arguments 112 command line options 10 to 16 commands

Index - 2

Introduction to Perl Scripting, Release 2.0

..........................................................
ord 102 pop 36 print 52 to 54 printf 55 to 58 push 36 rand 99 readdir 126 renaming 129 reverse 36, 95 rindex 103 rmdir 130 select 55, 59, 111 shift 37 sin 99 sort 37, 95, 127 sqrt 99 srand 99 sub 166 to 182 substr 103 time 100 tr 93 uc 103 ucfirst 103 undef 104 unless 86 to 87 unlink 128 unshift 37 warn 120 while 88 to 89 write 59 to 68 comments 18 cos command 97

Index

D
delete operator 41 diamond (<>) operator 112 to 116 die command 120

E
each operator 44 eq operator 80 escaped characters 28 exp command 97 exponentiation operator 74

F
filehandles 106, 119 to 123 files 105 to 135 accessing the command line 117 to 118 accessing the command line arguments 112 changing the current working directory 124 deleting a file 128 directory operations 124 to 131 file test operators 132 to 135 finding the current file name when using the <> operator 114 listing the files in a directory 125 making a new directory 130

Introduction to Perl Scripting, Release 2.0

Index - 3

..........................................................
opening a file for appending 121 opening a file for writing 120 reading a directory 126 reading STDIN one line at a time 108 reading STDIN using the diamond (<>) operator 112 to 116 removing a directory 130 renaming 129 sorting a file list 127 using filehandles 106, 119 to 123 using STDIN to read an entire file 110 using STDOUT and STDERR 110 using STDOUT, STDIN, and STDERR 107 to 111 for command 90 to 92 foreach command 93 to 95 format command 59 functions 96 to 104 arithmetic 97 string 101 timekeeping 100

Index

I
if command 84 to 85 index command 102 int command 98

K
keys operator 42

L
lc command 102 lcfirst command 102 le operator 81 length command 102 localtime command 100 log command 98 logical operators 82 lt operator 80

G
ge operator 80 gmtime command 100 gt operator 80

M
mkdir command 130 modulo operator 74

N
ne operator 80

H
hex command 97

Index - 4

Introduction to Perl Scripting, Release 2.0

.......................................................... O
oct command 98 open command 119 to 122 opening a file for appending 121 opening a file for writing 120 using the die command 120 opendir command 126 operators ! 82 != 79 !~ 81, 141 % 74 && 82 ** 74 < 80 <=> 80 <> 112 to 116 == 79 =~ 81, 140 > 79 >= 80 @* 66 || 82 arithmetic 73 assignment 73 binary bitwise 74 cmp 81 delete 41 each 44 eq 80 file test 132 to 135 ge 80 gt 80 keys 42 le 81 logical 82 lt 80 ne 80 relational 79 values 43 ord command 102 output commands 51 to 68

Index

P
Perl accessing command line arguments 112 accessing the command line 117 to 118 additional documentation 7 anchoring patterns 149 arithmetic functions 97 array operators 36 arrays 31 to 37 assignment operators 73 associative arrays 38 to 45 basic features 5 basic rules 17 buffering of print commands 69 built-in functions 96 to 104 changing the current working directory 124 command line options 10 to 16

Introduction to Perl Scripting, Release 2.0

Index - 5

..........................................................
comments 18 control structures 83 to 95 debugger 11 definitions of true and false 19 deleting a file 128 directory operations 124 to 131 displaying the version number 15 file access 105 to 135 file test operators 132 to 135 floating-point format of numeric data 28 generating reports 59 to 68 getting the program or scripts name 117 introduction 4 listing the files in a directory 125 making a new directory 130 naming conventions 20 output commands 51 to 68 producing warnings 15 reading a directory 126 reading an entire file using STDIN 110 regular expressions 136 to 165 removing a directory 130 renaming files 129 report formats 61 scalar variables 25 to 30 simple matching and replacing 144 to 154 special characters 28 string functions 101 subroutines 166 to 182 timekeeping functions 100 topics not covered 3 using filehandles 106, 119 to 123 using STDOUT, STDIN, and STDERR 107 to 111 using subpatterns 162 using the interpreter 9 using wildcards 155 to 165 variables 23 to 50 pop command 36 print command 52 to 54 changing the buffering behavior 69 defaults to STDOUT 111 sending to STDOUT and STDERR 110 printf command 55 to 58 changing the buffering behavior 69 format types 55 procedures 166 to 182 Process ID getting from the $$ variable 99 push command 36

Index

R
rand command 99 readdir command 126 regular expressions 136 to 165 !~ operator 141 $& variable 142 $ variable 142 $ 142 =~ operator 140 anchoring patterns 149

Index - 6

Introduction to Perl Scripting, Release 2.0

..........................................................
defining 138 to 139 replacing subpatterns 162 rules 140 to 143 simple matching and replacing 144 to 154 special characters 150 special variables 142 specifying ASCII values 152 using wildcards 155 to 165 relational operators 79 rename command 129 reports 59 to 68 $% variable 68 $= variable 67 @* operator 66 adding page headers 67 formats 61 outputting multiple lines 66 writing multiple lines 63 return values, subroutines 169 to 173 reverse command 36, 95 rindex command 103 rmdir command 130

Index

S
scalar variables 25 to 30 rules 25 strings and numeric data 26 using double and single quotes 26 select command 55, 59, 111 shift command 37

sin command 99 sort command 37, 95, 127 special characters 28 sqrt command 99 srand command 99 STDERR 107 to 111 sending a fatal error using the die command 120 sending a warning message using the warn command 120 STDIN 107 to 111 reading an entire file 110 reading using the diamond (<>) operator 112 to 116 using to read one line 108 STDOUT 107 to 111 default for the print command 111 string functions 101 sub command 166 to 182 defining 167 to 168 passing arguments 178 to 182 using local variables 174 to 177 using the return value 169 to 173 subroutines 166 to 182 defining 167 to 168 passing arguments 178 to 182 using local variables 174 to 177 using the return value 169 to 173 substr command 103

Introduction to Perl Scripting, Release 2.0

Index - 7

.......................................................... T
time command 100 timekeeping functions 100 tr command 93 $_ 48, 109 $| 71 $ 49, 142 $ 50, 142 $0 49, 117 $1 48, 50 $ARGV 49, 114 @_ 178 @ARGV 49, 112, 117 to 118 avoiding confusion 46 defining local variables 174 to 177 filehandles 106 OUTPUT_AUTOFLUSH 71 scalars 25 to 30 special characters 28 string and numeric data 26 use in subroutines 174 to 177

Index

U
uc command 103 ucfirst command 103 undef command 104 unless command 86 to 87 unlink command 128 unshift command 37

V
values operator 43 variables 23 to 50 $! 48, 130, 131 $# 34, 110 $$ 49, 99 $% 68 $& 49, 142 $( 49 $) 49 $/ 48 $< 49 $= 67 $> 49 $] 48

W
warn command 120 while command 88 to 89 wildcards 155 to 165 replacing subpatterns 162 rules 157 using for matching 159 using for substitutions 161 write command 59 to 68 changing the buffering behavior 69

Index - 8

Introduction to Perl Scripting, Release 2.0

WIBU - Protection System and Configuration (EN)
No ratings yet
WIBU - Protection System and Configuration (EN)
14 pages
XNMS - Installation Guide - R4.0
No ratings yet
XNMS - Installation Guide - R4.0
25 pages
Rust for Network Programming and Automation
From Everand
Rust for Network Programming and Automation
Brian Anderson
No ratings yet
TXSP Guide 1.1
No ratings yet
TXSP Guide 1.1
96 pages
CAXperts PlantReModeller. Manual
No ratings yet
CAXperts PlantReModeller. Manual
25 pages
VXI-11 Spec
No ratings yet
VXI-11 Spec
66 pages
PC 851 CommandLineReference
100% (1)
PC 851 CommandLineReference
506 pages
Centera API Reference Guide 069001185 A03
No ratings yet
Centera API Reference Guide 069001185 A03
294 pages
AIX Host Utilities 5.0
No ratings yet
AIX Host Utilities 5.0
122 pages
Eb2 SoftwareOperatorsGuide W7Osx v00
No ratings yet
Eb2 SoftwareOperatorsGuide W7Osx v00
198 pages
01 - FibeAir IP-10G ETSI Product Description For I6.7 (Rev1.2)
No ratings yet
01 - FibeAir IP-10G ETSI Product Description For I6.7 (Rev1.2)
174 pages
RSA EnVision 3.5.2 Release Notes
No ratings yet
RSA EnVision 3.5.2 Release Notes
35 pages
Python Getting Started Guide
No ratings yet
Python Getting Started Guide
48 pages
Manual en
No ratings yet
Manual en
49 pages
Rsa Userguide
No ratings yet
Rsa Userguide
78 pages
B1807515A
No ratings yet
B1807515A
0 pages
Ip Ran
No ratings yet
Ip Ran
51 pages
VPN Remote 4600 Admin Guide
No ratings yet
VPN Remote 4600 Admin Guide
42 pages
Phoenix Getting Started Guide
No ratings yet
Phoenix Getting Started Guide
52 pages
Shaft 2012 Technical Manual
No ratings yet
Shaft 2012 Technical Manual
76 pages
Batch
No ratings yet
Batch
39 pages
Device Interfaces Using EDITechnology
No ratings yet
Device Interfaces Using EDITechnology
582 pages
HP-UX User Commands A-M (Vol 1)
No ratings yet
HP-UX User Commands A-M (Vol 1)
584 pages
(FUP) Reference Manual
No ratings yet
(FUP) Reference Manual
270 pages
80-ND928-7_A
No ratings yet
80-ND928-7_A
29 pages
Nat Wrapper
No ratings yet
Nat Wrapper
64 pages
Pipephase Instalation Guide
No ratings yet
Pipephase Instalation Guide
38 pages
Manuale Intermec PX 4i-PX6i
No ratings yet
Manuale Intermec PX 4i-PX6i
204 pages
FirePass Controller Getting Started Guide
No ratings yet
FirePass Controller Getting Started Guide
64 pages
NexLog Acess Bridge 2 - 8 - 0 Manual - 01
No ratings yet
NexLog Acess Bridge 2 - 8 - 0 Manual - 01
21 pages
Enhanced Remote Repair With WinRE Rev 1.0
No ratings yet
Enhanced Remote Repair With WinRE Rev 1.0
27 pages
DPtech FW1000 Series Application Firewall User Manual v5.0
No ratings yet
DPtech FW1000 Series Application Firewall User Manual v5.0
415 pages
MSL Install Admin R9.1SP1 en
No ratings yet
MSL Install Admin R9.1SP1 en
88 pages
LinuxSAS 1 0 1
No ratings yet
LinuxSAS 1 0 1
93 pages
Ngenius Decryption Appliance V1.6P: Release Notes
No ratings yet
Ngenius Decryption Appliance V1.6P: Release Notes
10 pages
Install_everRun_6.2
No ratings yet
Install_everRun_6.2
57 pages
Messages & Codes
No ratings yet
Messages & Codes
176 pages
Declaration of Conformity: NEC Computer Systems Division, A Division of Packard Bell NEC, Inc
No ratings yet
Declaration of Conformity: NEC Computer Systems Division, A Division of Packard Bell NEC, Inc
196 pages
FibeAir IP-20S C83 T
No ratings yet
FibeAir IP-20S C83 T
211 pages
Datasheet, Vol. 1 - 7th Gen Intel® Core™ Processor U - Y-Platforms
No ratings yet
Datasheet, Vol. 1 - 7th Gen Intel® Core™ Processor U - Y-Platforms
118 pages
Getting Started Guide for the Reference Platform J2ME 8.3 Intel Galileo MEEGG
No ratings yet
Getting Started Guide for the Reference Platform J2ME 8.3 Intel Galileo MEEGG
40 pages
Srx3600 Srx5400 Air Deflector Install Guide
No ratings yet
Srx3600 Srx5400 Air Deflector Install Guide
40 pages
DMR Conventional Radio - SIP Phone - Application Notes - R5.0
No ratings yet
DMR Conventional Radio - SIP Phone - Application Notes - R5.0
41 pages
Fortinac Vmware Install 85
No ratings yet
Fortinac Vmware Install 85
66 pages
Flexframe Ff4s-Sap Install
No ratings yet
Flexframe Ff4s-Sap Install
178 pages
ReferenceGuide 21E-6
No ratings yet
ReferenceGuide 21E-6
515 pages
PE Serial SPI Memory Programming For ARM Devices
No ratings yet
PE Serial SPI Memory Programming For ARM Devices
35 pages
Config 18 3
No ratings yet
Config 18 3
525 pages
Mellanox PXE Remote Installation User Guide
No ratings yet
Mellanox PXE Remote Installation User Guide
21 pages
Hytera Smart Dispatch Troubleshooting Guide V5.0.01 - Eng
50% (2)
Hytera Smart Dispatch Troubleshooting Guide V5.0.01 - Eng
49 pages
Nos 7.2.0a3 Upgrade Guide
No ratings yet
Nos 7.2.0a3 Upgrade Guide
37 pages
SAS - IntegrationGuide Apache HTTP Server SAML
No ratings yet
SAS - IntegrationGuide Apache HTTP Server SAML
21 pages
Analysis Handbook PDF
No ratings yet
Analysis Handbook PDF
171 pages
Rust for Network Programming and Automation, Second Edition
From Everand
Rust for Network Programming and Automation, Second Edition
Gilbert Stew
No ratings yet
Cisco Packet Tracer for Beginners
From Everand
Cisco Packet Tracer for Beginners
kalyan chinta
5/5 (3)
Docker, Containers And All The Rest: First Edition, #1
From Everand
Docker, Containers And All The Rest: First Edition, #1
Ami Adi
No ratings yet
OpenStack Networking Essentials
From Everand
OpenStack Networking Essentials
Denton James
No ratings yet
Linux Essentials for Hackers & Pentesters
From Everand
Linux Essentials for Hackers & Pentesters
Linux Advocate Team
No ratings yet
Instant Traffic Analysis with Tshark How-to
From Everand
Instant Traffic Analysis with Tshark How-to
Borja Merino
No ratings yet
TensorFlow 2 Pocket Primer: A Quick Reference Guide for TensorFlow 2 Developers
From Everand
TensorFlow 2 Pocket Primer: A Quick Reference Guide for TensorFlow 2 Developers
Mercury Learning and Information
No ratings yet
Searching and Sorting
No ratings yet
Searching and Sorting
27 pages
Programming Microsoft Visual C++
No ratings yet
Programming Microsoft Visual C++
679 pages
Lic Data Sheet
86% (7)
Lic Data Sheet
1 page
Programming Microsoft Visual C++
No ratings yet
Programming Microsoft Visual C++
679 pages
Visual Basic C++ 6
No ratings yet
Visual Basic C++ 6
17 pages
Form No.300 (BN) Life Insurance Corporation of India (Established by The LIC Act 1956)
No ratings yet
Form No.300 (BN) Life Insurance Corporation of India (Established by The LIC Act 1956)
3 pages