Elements of programming with Perl 9781884777806, 1884777805

Citation preview

Concepts, skills and practices of effective programming

Copley Square

Elements ofProgramming with Perl

Digitized by the Internet Archive in

2014

https://archive.org/details/eiennentsofprograOOjohn_0

Elements of

Programming with Perl

Andrew L. Johnson

II

MANNING Greenwich (74° w. long.)

For Susanna, Joseph, and Thomas For electronic browsing and ordering of this and other visit

http://www.manning.com. The pubHsher

when ordered

in quantity. For

Special Sales

Manning

Manning

offers discounts

more information,

books,

on

this

book

please contact:

Department

Publications Co.

32 Lafayette Place Greenwich,

Fax: (203)

CT 06830

email:

66 1-9018

[email protected]

© 2000 by Manning Publications Co. All rights reserved. No

part of this publication

may

be reproduced, stored in a retrieval system,

or transmitted, in any form or by

means

electronic, mechanical,

photocopying, or otherwise, without prior written permission of the publisher.

Many of the

designations used by manufacturers and sellers to distinguish

their products are claimed as trademarks. in the book,

designations have been printed in

@

Where

those designations appear

and Manning Publications was aware of a trademark claim, the initial

caps or

all

caps.

Recognizing the importance of preserving what has been written,

it is

Manning's policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end.

Library of Congress Cataloglng-in- Publication Data

Johnson, Andrew

L.,

1963-

Elements of Programming with

Perl

/

Andrew

Includes bibliographical references and index,

ISBN 1-884777-80-5 1.

Perl

L.

Johnson,

cm.

p.

(alk.

(Computer program language)

QA76.73.P22J644 005.13'3— dc21

(p.

348).

~ ,

,

'

,

;

"; i

;,

,

paper) I.

Title.

1999

99-42510

CIP

Manning

Production

Publications Co.

32 Lafayette Place Greenwich,

services:

Copyeditor:

CT 06830

Typesetter:

Cover designer:

Printed in the United States of America 1

2 3 4 5 6 7 8 9 19 -

CM

- 02 01 00 02

TIPS Technical Publishing Adrianne Harun Lorraine B. Elder Leslie

Haimes

contents

preface

xi

xv

acknowledgments

Part I 1

Introductory elements

Introduction

3

1.1

On programming

1.2

On

'

Perl

7

Getting started 1.3

2

3

4

10,

A bigger picture

Writing code

Peri

18

i

2.2

Naming

2.3

Comments

24

2.4

Being

12

.

29

2.5

A quick style guide

21

strict

31

32

A first program Specification

debugging

Getting help

20

Structure

Writing programs

11,

15

2.1

3.1

Running

34 34,

45,

Design

35,

Maintenance

V

Coding 47

40,

Testing and

faqgrep

3.3

Exercises

Part II 4

49

3.2

Essential elements

Data: 4.

55

1

types

and variables 60

Scalar data

63

Scalar variables

4.2

Expressions

4.3

List data

65

67

Array variables

5

6

59

Hash

69,

4.4

Context

4.5

References to variables

4.6

Putting

4.7

Exercises

variables

73

it

77

'

', .

Selection statements

5.2

Repetition: loops

84

5.3

Logical operators

89

5.4

Statement modifiers

5.5

Putting

5.6

Exercises

92

together

97

,'

6.1

File handles

6.2

Pattern matching

99

and join

The

6.5

Putting

103 105,

Regex language constructs

6.6

Exercises

107,

112

113

DATA file handle it

^ 5

98

Matching and substitution operators

6.4

,

92

Simple I/O and text processing

Split

.

80

5.1

6.3

'

78

Control structures

it

74

76

together

Matching constructs

vi

71

together

114

116

120

CONTENTS

7

Functions

121

\

7.1

Scope

7.2

Global variables

7.3

Parameters

7.4

Return values

7.5

Designing functions

7.6

Parameters and references

7.7

Recursion

7.8

Putting

123

it

8

8.1

'x,

;

;

,

129

139

141

143

structures

Nested hashes

147,

149

8.3

References to functions

149,

-

150

-

,

,

152

,,

;

•

,

153

Closures 8.4

Nested structures on the

8.5

Review

8.6

Exercises

fly

155

158 159

160

/

POD

9.1

User documentation and

9.2

Source code documentation

Other uses

of LP

Tangling code

A simple tangler

CONTENTS

Routine examples

137,

140

Scope and references

9.4

r;

134

mathq program

8.2

9.3

^

137

together

Creating references

Documentation

,

131

Nested or multi-dimensional arrays

9

i

,

.

and aggregate data structures

Mixed

.

'

>

.

.

-

135

Exercises

References

'

'

127

Revisiting the

7.9

127

Further resources

.

161

164

169 170 170 178

vii

Part III 10

Practical elements

183

Regular expressions 10.1

The

basic

10.2

The

character class

components

184

188

Search and replace: capitalize headings shortcuts

10.3

Greedy

10.4

Non-greedy

10.5

Simple anchors

10.6

Grouping, capturing, and backreferences

10.7

10.8

quantifiers: take

11.1

what you can

quantifiers: take

what you need

Inserting

commas

Exercises

201

1

13

96

number

in a

operator

11.2

The

11.3

Strings within strings

11.4

Translating characters

11.5

Exercises

198

' .

206

207

208 211

212

.

214

lists

215

12.1

Processing a

12.2

Filtering a

12.3

Sorting

12.4

Chaining functions

12.5

Reverse revisited

12.6

Exercises

More I/O

198

203

substitution operator

Working with

13.1

195

202

text

The match

192

193

Context of the match operator

12

class

191

get

Other anchors: lookahead and lookbehind

Working with

Character

89,

191

Prime number regex

//

1

list

217

list

lists

"

217

:

^

'-

221

223

224

225

Running

external

commands

226

CONTENTS

14

13.2

Reading and writing from/ to external commands

13.3

Working with

13.4

Filetest operators

13.5

faqgrep revisited

13.6

Exercises

228

directories

16

17

.

230

233 -ry::.--^

modules

236

14.1

Installing

14.2

Using modules

237

14.3

File::Basename

238

i

14.4

Command line options

14.5

The

14.6

Fetching webpages

dating

game

239

241

243 243 -

14.7

CGI.pm

14.8

Reuse, don't reinvent

14.9

Exercises

249 253

255

256

Debugging

Part

.

229

Stock quotes and graphs

15

-

234

Using modules

227

15.1

Debugging by hand

15.2

The

257 262

Perl debugger

rV Advanced elements

Modular programming

271

16.1

Modules and packages

16.2

Making

16.3

Why make modules?

16.4

Exercises

Algorithms

a

274

278

279

and data structuring

17.1

Searching

17.2

Sorting

CONTENTS

module

272

280

281

283

ix

17.3

Heap

17.4

Exercises

291

Object-oriented programming and abstract data structures

18

What

18.2

OOP in Perl

is

295 295,

basics

Stacks, queues,

and linked

Stacks

Queues

301

lists

Linked

307,

lists

309

314

OOP examples

More

315

19.1

The heap

19.2

Grades: an object example

19.3

Exercises

as

316

an abstract data structure

320

330 ^^

What's

appendix A

left?

^

331

Command line switches 333

appendix

B

Special variables

appendix

C

Additional resources

appendix

D

Numeric formats

glossary

342

index

301

18.4

301,

299

Inheritance

Abstract data structures

Exercises

292

293

18.3

18.5

20

OOP?

18.1

The

19

286

sort

348

336 338

340

" '

.

;

CONTENTS

preface The Norse God Odin had two

He would send them

ory).

they would return and

ravens,

out each day to

him

tell

all

Thought and memory,

resources.

Hugin and Munin (Thought and Memthe corners of the earth.

fly to

Odin knew how

their secrets.

cogitation

and

recall,

a programmer, these are the important resources

aims to be your guide in should have the will

skills to

By

this endeavor.

own hugin

Perl

his

—

as

you too must tame. This book you

you

finish this book,

to scour the

web

manage and query

for interesting

the database of

collect.

are a lot

recommend

manage

processing and storage

the time

program

information, as well as a munin program to

There

night,

manage your own Hugin and Munin. In other words, you

be able to write your

information you

to

At

of books about Perl on the market today, and some of them

highly. (See

Appendix C, "Additional

resources.")

However,

I

many

authors of these other Perl books assume readers are already familiar with pro-

gramming. Other authors take the ulary

side-effect

approach, teaching readers the vocab-

and syntax of the language but offering few guidelines on how

effectively.

I

do not

believe that the side-effect approach

is

an

effective

to use

it

means of

teaching programming.

This book instead presents the basic elements of programming using the context I

of the Perl language.

merely

teach

I

hammer you with

do not assume that you've programmed syntax and function names. This

you both programming and

you need

to

Perl,

become an accomplished

from the

Perl

basics to the

book

before, nor is

do

designed to

more advanced

skills

programmer.

Audience This book

is

intended for two types of readers: those approaching Perl as their

first

programming language and those who may have learned programming off the cuff

xi

but

now want

a

more thorough grounding

in

programming

in general,

and

Perl in

particular.

More people than for

to

Common

its

Gateway

Some

popularity.

programming

Perl

front that this

is

book

an example or two learning belt,

how

ever are learning Perl. Undoubtedly, Perl's widespread use

to

people need Perl

cool.

is

to

understand up

not about using Perl for web-related programming, although

illustrates that application

it

while others just think

skills for their jobs,

Whatever your motivation, you need

program using

you can apply

and web-client programming contributes

Interface (CGI)

Perl.

of

Once you have

to a multitude of problem

This book does not assume that you

programmed

Perl. Instead, this

that

book

is

about

knowledge under your

domains.

know what

variables, arrays,

and loops

However, familiarity with basic mathemat-

are,

or that you've

ical

concepts and logic will certainly be helpful. Readers with no prior program-

ming experience should, of through the

first

course, begin at the beginning

and work

their

way

nine chapters in order. Chapters 10 through 15 are largely inde-

pendent and can be read advanced

before.

any

in

Chapters 16 through 19 introduce

order.

Each of these chapters

Perl concepts.

lays a

foundation for the following

chapter, so read these four chapters in order. If you are already familiar

to read chapters 2

which you wish

and

3,

and then pick and choose chapters

to improve. For example, chapters 6, 10,

aspects of regular expressions If you are a

with elementary Perl programming, you

and matching

competent programmer

that tackle areas in

and 11 cover

different

operators. Chapter 8 covers references.

in another language, this

useful in demonstrating Perl's

way of doing

not be

and the content

as concise as you'd like,

may want

things. is

book may still be

However, the discussions

not organized

as a reference

may

book.

Organization The book

is

organized in four main parts, starting with things to consider before

you begin programming, followed by the Perl.

The

third section explores a

Finally, the later chapters

structures

essential aspects

few of the more

practical

and

Perl-specific areas.

introduce more advanced concepts, such as abstract data

and object oriented-programming using

Introductory elements

of programming with

The

Perl.

three chapters in this section provide elementary

information on programming and the Perl language. Chapters 2 and 3 also delve into the basics of

program structure and design. In chapter

two examples, providing a whirlwind tour of the

xii

3,

we work through

Perl language in the process.

PREFACE

Essential elements

you need

structures

from

Chapters 4 through 9 cover the essential concepts and

program

to learn to

effectively.

variables to loop control constructs to

expressions to subroutines to references ish this section

of the book, you

will

Here you

input and output to basic regular

file

and nested data

have

all

the tools

applications.

structures.

you need

Chapters

to the Perl language, exploiting

1

0 through

1

into areas

some of Perl's unique and powerful

explore regular expressions in

more

detail, string

and

>

V

;

you

5 take

When you

fin-

to build real-world

,

Practical elements

we

will find everything

more

f

specific

Here

strengths.

processing,

list

.

more

input and output techniques, using modules, and the Perl debugger.

Advanced elements

Chapters 16 through 19 provide an introduction to more

advanced programming techniques, including building modules and abstract data

You

structures.

programming

are also introduced to object-oriented

Chapter 20 mentions a few areas not covered in

this

book and

features in Perl.

suggests references

for fijrther study.

The

Appendices

four short appendices cover command-line switches, special

Perl variables, additional resources for readers,

and a

brief explanation of binary,

and hexadecimal numeric representation. Following the appendices

octal,

is

a

small glossary of technical terms used in this book.

Source code, solutionSy The

source code for

and errata

many of the example programs and modules

book may be obtained from Manning's www.manning.com/Johnson for

presented in this

website. Point your browser to httpill

links to the online resources for the book, including

source packages.

Many

chapters have a small

appendix of answers to these

number of

exercises.

exercises at the end.

There

is

no

However, the web page mentioned above

contains a link to a solutions page. Finally,

some

errors

although

may

tains a link to

an online errata

errata sheet

address to

PREFACE

strived to eliminate mistakes

have slipped through.

book was published. on the

we have

If you find

and

fix

them

which you can submit

The

from the manuscript,

previously mentioned

web page con-

listing corrections to errors discovered after the

any

errors, please let us

in a later printing.

The

know errata

so

we can

page

lists

list

them

an email

error reports.

xiii

— Conventions In this book, "Perl" (uppercase P) refers to the Perl

programming language, while

"perl" (lowercase p) refers to the perl compiler/interpreter or the perl distribution.

Filenames and

mands you might

Some

font.

URLs

appear in

italics.

command

issue at the

Code, program names, and any comline

prompt appear

blocks of code are written using a form of literate

in a

fixed-width

programming (LP)

syntax to break the code into smaller chunks for presentation (explained in chapters

3 and

In these cases, the real Perl code, or the pseudo-code,

9).

fixed-width

font, while the lines representing literate

zn italic fixed-width

Many sary.

You

the terms

first

appear in the

commonly used

able or the contents of a string. directly related to

terms

—and many

whatever similar

text,

book

this

are in

they are

are defined in the glos-

italicized.

words foo and bar throughout

will also see the

generic terms

programming syntax

^onl.

of the technical terms introduced in

When

in a plain

is

in syntax

the point of the example

vari-

is

not

being called "foo." You might encounter these

"dummy"

in publicly available articles

book. These are

examples to represent the name of a

They are used when

is

this

words, such as

f oobar, baz, qux,

and quux

and examples on programming.

Author online Purchase of Elements of Programming with Perl includes free access to a private Internet

forum where you can make comments about the book, ask

questions,

and

receive help

the forum, point your

from the author and from other

web browser

rules

xiv

forum once you

To

to www.manning.com/Johnson. There

be able to subscribe to the forum. This access the

Perl users.

technical

site also

are registered,

you

provides information on

what kind of help

is

available,

access will

how

to

and the

of conduct on the forum.

PREFACE

"

acknowledgments No

author works in a vacuum, and

people deserve

my

I

'

^

am certainly no

gratitude for their help

exception.

A large number of

and support while

undertook

I

this

"little" project.

First

my ideas,

I

would

letting

like to

me

thank Marjan Bace, the publisher, for taking a chance on

run with them, and reining

to take seriously the view that an author

His pleasant and personal

welcome

relief

from the

style

and

toils

in

and publisher

during our

stresses

me

many phone

when

necessary.

and

are partners,

He it

seems shows.

conversations was always a

of making a living while writing a book.

Many other people at Manning contributed considerable efforts to make the book you now hold in your hands something of which I can be proud. I'd like to his many insightful suggestions; Ted Kennedy, Mary Piergies, for managing the production protesting the results of my script to convert the LaTeX

thank Brian Riley; Ben Kovitz, for for

managing the review

cess;

Syd Brown,

chapters into

process;

for patiently

MML format; Adrianne

in copyediting;

Harun,

for her steadfast attention to detail

and Robert Kern, Lynanne Fowie, and Lorraine

Elder, for turning

the manuscript into typeset pages.

A great many reviewers also

caught embarrassing errors and glitches and pro-

vided helpful comments and suggestions.

I

would

like

thank Tad McClellan,

Randy Kobes, Brad Fenwick, Jim Esten, Paul Holser, Dave Cross, Patrick Gardella, Mike MuUins, Michael Weinrich, Peter Murray, Richard Nilsson,

Umesh

Nair, Vasco Patricio,

provided crucial advice

at a

responsible for helping

while

I

My brother Brad Johnson also

couple of junctures in the book. All of these people are

make

this a better

book.

Any problems

or errors that

my responsibility.

remain are Parts

and Richard Kingston.

of

was

this

book were

at Bellamy's, the local

always find one of

booth when

I

my

my

written, or at least conceptualized, in

corner

preferred beers

needed to work, and a

pub and

on

restaurant,

I

could almost

tap. Bellamy's offered a quiet table or

seat at the bar

XV

where

notebook

when I needed

rejoin the living.

I'd like to

thank Linda

E., the bartender, for

not only serving up good

ale,

but also

being a cheerful friend.

Anyone who

uses uses Perl

and enjoys

gratitude to Larry Wall for creating this

thanks are due to

Tom

Christiansen,

it

as

much

gem and

as

giving

I

do owes a

serious debt of

to us so freely. Also,

it

whose long and continued

efforts

many

have been

instrumental in creating and maintaining a vast and informative documentation set that, in

Thanks from

my

opinion, remains unmatched in any other software documentation.

are also

whom

improve

Perl,

and taking Lastly,

I

to the

many and

Perl into

rest

new

of the Perl community

not;

my wife,

least, I'd like to

Susanna, just for being

xvi

continually

work

for continually keeping stories,

to

keep sharing code and ideas

thank

my

faults.

.

who

she

.um,

eccentricities);

Joseph, for their patience and understanding

games, reading

who

mother and three brothers

encouraging and never lacking in good advice whether you want

hours and countless other

and

who

on comp.lang.perl.misc

territory.

but certainly not

are always

varied regular posters

have learned much, the perl5-porters

and the

who lar

due

me

building

is

(and for putting up with

when Dad

and

it

or

my irregu-

my sons, Thomas

and

disappeared into his ofHce,

in touch with the pleasant side of reality: playing

snowmen, and other simple

pleasures.

A CKNO WLED GMENTS

Introductory elements

Introduction 1

.

1

1.2 1.3

On programming On Perl 7 A bigger picture

4

15

— To

write a story, fiction or fact, one

enough

at least so that

readers.

One must

manner

that

must grasp the

basics of the language in use

one can make simple statements that may be understood by

also

be able to string together a

communicates meanings and events

Stories also have certain compositional elements

series

of such statements in a

in relation to

time and space.

beginning, a middle, and an

like a

end, although the presentation need not proceed in that order. Listen to writers talk about writing, result

in the

mind and simply

writes

claiming that inspiration result

you'll find that writing

and

rare

is

Much more

down.

it

meaning

is

once

often, you'll find writers

—and

and usually comes during

fleeting

many ways

similar in

how

are described in space

—

and ends

are also

as a

nor a

visionaries,

like writing, that

and

skill levels

of statements such that events and

and time. Structural elements

immersed an

is

in the

—

Finally, real inspira-

is

often a subject of discussion.

neither an art achievable only by innately talented right-brain

is

strictly scientific left-brain logic

of

first

principles. It

on

some programmers

little

novels, others write pulp fiction,

write

all

trade,

go on with their

1.1

squares of adhesively backed yellow paper.

write elegant programs solving massively complex

is

all

manner of tools and big and

who

are not pro-

little

programs and

about

telling narra-

real jobs.

programming

is

a craft like writing,

and writing

programming about? Programming

is

is

about solving problems.

On programming

Computers talk

crank out

and many

kinds of narratives from business

problems; others produce solid utilitarian code daily; and many,

what

a craft,

for a multitude of purposes.

reports to postcards to notes

So, if

is

can be learned, practiced, developed, and honed to a variety of

Some writers write great literary who are not writers by trade

grammers by

beginnings, mid-

development process, not before.

art or a science

people

Similarly,

One must know the basics of

important in program composition.

Whether programming But programming

to writing.

to string together a series

tion generally occurs while

we

seldom the

— the writing process, not the other way around.

the language and

tives,

is

realizes the entire story at

of

Programming

dles,

and

of any "holistic inspiration" where the writer

are mindless devices capable only

about the

activities

of what a program

hardware into a

is

of doing what they are

told. Before

of programming we need to have a basic understanding

and the

role

it

plays in turning an expensive piece of mindless

usefiil device.

Imagine the following scenario: You are taken to a room containing a desk and a chair.

4

On

the

left

of the desk

is

an "in-box"

fiill

of pages of numbers, and on the

CHAPTER

1

INTRODUCTION

right

an empty "out-box." In between

is

lies

a manila envelope, a calculator, a

pad

of paper, and a stack of blank forms. You are told to open the envelope and follow the instructions you'll find inside. take the

first

The simple and

these calculations into certain

sets

of those numbers and to write the

into the out-tray

you must place the newly

and begin again with the next page of numbers

In this scenario,

you

are operating essentially as a mindless

taking input, performing simple operations, instructions are simple in

results

out form

in the in-tray.

computing

and writing out the

and do not require "thought" or

numbers, operate the

filled

of

When

numbered boxes on one of the blank forms.

you've completed one page of numbers,

results

to

page of numbers from the in-tray and perform certain simple arith-

metic operations on particular

you can read

you

explicit instructions tell

device:

results.

The

interpretation, merely that

calculator, temporarily store intermediate

on the pad of paper, and control the output device

(pencil) to write out the

results (see figure 1.1).

Memory Instructions

Other Storage (scratch pad)

Output

Input

Input

CPU

Output Device

(brain)

Device

ALU

Figure

1.1

An

(calculator)

Processing data

important point to note

in this scenario.

You may be

just

is

that

you have no idea about what you

one part of a team performing various

are

doing

steps in a

complex encryption/decryption scheme, or you might simply be balancing checkbook. At any

rate,

tion to being boring ties

you would not

and

repetitive

—

nonetheless require attention to

but don't absolutely free your mind.

such a

likely

enjoy this particular

activity.

It

small details.

would be hard

In addi-

—such

activi-

They occupy your

brain,

the usual definition of mindless

many

my

to meditate while

performing

task.

The most important component in the above situation is the set of instructions. The mindless brain can be replaced by a mindless central processing unit

ON PROGRAMMING

5

(CPU) controlling simple mechanical/ electrical devices metic operations and temporary storage. However, given set of instructions to control such a machine.

it

for input, output, arith-

takes a

mind

Anyone who has

to conceive a

stayed

up

late

trying to put together a "some assembly required" toy for their

on Christmas Eve

child can appreciate the problems of working with incomplete, out of order,

and

badly written instructions. I

rate.

said

programming

You not only have

is

about solving problems, but that

to think of a

way

develop that solution into a complete step-by-step solving the problem.

When

a

method

of simple, repeatable instructions,

An

we

for solving a

result. If

each step

is

An

of simple instructions for

problem

is

reduced to a

series

must be simple and not subject to

algorithm must also always generate the same

performed

fliawlessly,

the

outcome

is

guaranteed. Program-

about creating algorithms to perform simple or complex tasks and trans-

lating these algorithms into instructions that a

The as

have to

also

algorithm can be specified in any language, but regardless of how complex

interpretation or intuition.

is

set

you

that set of instructions an algorithm.

call

the algorithm might be, each step or instruction

ming

not entirely accu-

is

to solve a given problem,

particular instructions that a

computer can perform.

computer can execute

form known

are in a

"machine language" or simply "machine code." Machine code instructions con-

sist

of sequences of numbers, ultimately reduceable to zeros and ones

code). These instructions deal with into a particular

memory

address, or adding a

low

level operations

location, reading a

number

such

(i.e.,

as storing a

number out of a

particular

binary

number

memory

into an accumulator. For example, the following

snippet of machine code causes two numbers, which are stored in memory, to be

added together and saved into another memory location for

later use:

'"

8B45FC 0345F8 8945F4

'

Of course, we humans

'

have a hard time trying to formulate algorithms in a

machine language so we soon developed a language consisting of abbreviated words

to stand for the particular operations a given

could write programs out in

this

machine could perform.

We

"assembly" language, then translate the language

machine code using one machine instruction per each

into the corresponding

assembly instruction.

Assembly code was

easier to write

than the machine code

it

replaced, but

because different machine architectures used different machine code, each had to

be programmed in

its

own

one machine type had

version of an assembly language.

to be rewritten to

problem with assembly languages tions of moving

6

around

bits

is

A program written for

run on another machine type. Another

that they

still

dealt with the

low

level instruc-

of information.

CHAPTER

1

INTRODUCTION

Higher

level

languages were later developed to allows instructions to express

higher level concepts.

With

a

low

level

language

like

an assembly, one had to write

individual instructions to place a

number from

a specific location in

a temporary holding area;

number from

a different

finally, store

high

add

a

memory

one could write a

into

location; and,

memory. With

the result of that operation in a third location in

level language,

memory

a

single instruction that encapsulates the con-

cept (see figure 1.2).

Machine Code

Assembler Code

movl a, %eax addl b, %eax movl %eax, c

8B45FC 0345F8 8945F4

Comparison

Figure 1.2

High Level Code

c

of macliine, assembly,

a + b

=

and high

level

languages

Aside from the obvious advantage of making the instructions easier to read

and write

for

ment down

humans, compilers were created the corresponding assembly

to

that translated each high level state-

and machine codes

for different

machines. This meant that one could a write a program once in the high

guage and be able to run

it

on any machine

that

had a compiler

level lan-

for that language.

Early high level languages included Fortran, designed primarily for mathematical

computing;

intended

COBOL,

initially as

from which

exist

Perl

On

to choose, each with particular strengths is

about the language that

of

When

will

and weaknesses. The

be taught in

its

initially released in

1987.

nature (and certainly says something about

this

book.

inception

Perl's

its

is

creator as well).

Larry was faced with a problem that involved complex text processing and

report generation exceeding the capabilities of

what could be done

standard Unix tools like sed and awk he

made

viewpoint

he saw that

whole

Pascal,

Perl

was created by Larry Wall and

illustrative

programming; and BASIC and

teaching languages. Today, a wealth of high level languages

remainder of this chapter

1.2

for business related

to solving this particular task,

class

easily

with

a choice. Rather than restricting his his

problem was

just

one of a

of problems for which existing tools and languages provided no simple

solutions. So, in the spirit of long-term laziness, Larry

Wall created a new tool for

solving such problems. Perl did not capabilities

ON PERL

simply

fill

a gap in the existing toolset. Perl incorporated the

of existing tools and borrowed freely from other languages.

It

soon

7

became the language of choice (and

its

for getting things

done

in the

usefulness soon spread to other operating systems

another way, Perl didn't

one particular gap

fill

Unix environment

and environments). Put

in the toolset;

it

became

the tool to

use for filling gaps everywhere.

Designed not only for Perl

has become

incarnation,

it

practical usefulness, but also for

offers

and quite

at the

module system,

of the features

all,

moment. You want

you can write programs

I

just

a

may

program

on your hard

So what

analysis.

is

good

Perl

to interact

drive,

but the

new

files

Perl,

and writing plain

realize all the

code that

easily write

or directories, rename

files,

you save

files

files,

tasks

and more. but one

is

use of Perl.

ments you send

to a database server

to a webserver

simply encoded

text. Similarly,

A

significant portion

search capabilities are

and the

results

HTML pages

and the

programs use a simple, encoded (CGI).

ways you might

will read in directory list-

delete (unlink)

Query Language (SQL)

Client-server interactions, such as the Structured

you send

Pro-

text.

are representations

Automating many kinds of system administration and backup

common

and

for?

and directory names themselves

you can

it

some kinds of

with textual data. Not only the plain text file

that

accurate, but

either. Perl isn't well suited for

not seem like a big deal until you

of textual data. With ings, create

you

Perl. Telling

do anything you want wouldn't be

to

Perl excels at reading, processing, transforming,

want

with

lot to

for example, writing operating systems, writing device drivers,

doing heavy numeric

cessing text

references, nested data

mentioned don't mean a

know yN^iztyou can do

to

wouldn't be too far from the truth

programming:

current

a bit more.

Perhaps some, or even

you

its

extremely powerful regular expression enhancements, object-

oriented programming, a well defined structures,

continued expansion,

programming language. In

a powerful general purpose

it

it

returns, or the

sends back, are

all

HTTP

communications between a webserver and external text protocol

of Internet

powered by

and pass

write programs that "glue" language.

it

Perl

know

sites

as

Common

Gateway

dynamic content or

that provide

back to the webserver. Because

because of

its

Interface

programs that handle requests from the web-

work between other programs,

And

requests

largely plain or

server; turn these into queries for a database's server; collect, transform,

the resulting data;

state-

Perl

Perl

is

makes

and format it

so easy to

often referred to as a

wide use sticking various things together

throughout the Internet, Perl has also been called the "duct tape" of the Internet. I

mentioned

that Perl

module system. This means

mon for

8

ones

—have

anyone

was designed that

to

grow and

many of the common

has a well defined

that

it

tasks

—and some uncom-

already been encapsulated into modules that are freely available

to use (see the discussion of

CPAN

later in this chapter).

CHAPTER

1

When

you

INTRODUCTION

want

to write a

CGI program,

you can use

(FTP), or interact with a database, that provides

your

do

write client software to

file

and debugged module

a well tested

most of what you need, leaving you only

transfer protocol

add the code

to

to deal with

specific task.

Not only do modules make

it

modules provide extensions that allow you itself

might be

less

well suited.

I

common

easy to use Perl for

but some

problems for which

to use Perl for

mentioned above that

tasks,

may

Perl

Perl

not be a good

choice for numeric analysis. However, there are modules designed to extend

Perl's

handling of numeric data by providing arbitrarily large integers and floating point

numbers. There

is

Data Language (PDL) module package, which pro-

also the Perl

on

vides extensions for doing fast mathematical computations

numeric

ten in that language

is

languages are interpreted, meaning that a program writ-

read by an interpreter program that translates each state-

into the appropriate

machine code and executes

cannot be detected until the program

is

encounters a statement that generates an

meaning

that a

code before

whole program

is

even run. (Some

is

caught until the program

you run

is

it.

already running and the interpreter error.

Other languages

many

errors, called

running.) Perl

is

run-time

to the perl interpreter

many

and sometimes

will

errors,

not be

still

both interpreted and compiled.

program and compiles

an internal format (not machine code), then interprets Thus, in

are compiled,

kinds of errors can be caught before

a Perl program, Perl reads the entire

like a regular interpreter.

In such languages, errors

read by a compiler and translated into machine

can be run. In this case,

it

the program

When

of

data.

Some programming ment

large matrices

it

into

this internal representation

places in this book,

I

will

sometimes

— but they both

to the perl compiler

refer

refer to

perl itself Perl, however, refers to the Perl language.

The advantage of such errors

a compiled/interpreted system

is

that

kinds of

can be detected during the compilation phase, before a program begins exe-

cuting. Yet

you do not need

executable each time you

guage such

as

to separately

make

compile and link your code into a binary

a change, as

you would

for a strictly

C. You can simply type in your program and run

piler/interpreter takes care of the rest.

The

tradeoff

is

a

little

it.

whose statements

are individually interpreted with each

programs usually run very Yet another benefit of

many lower level compiled cifically

fast,

Perl's

ON PERL

is

running.

perl

faster

com-

A

than one

run through. That

interpreted nature

is

said,

memory management.

languages, like C, your program

When

The

especially for text processing types of tasks.

with allocating and releasing the necessary

your program

compiled lan-

loss in speed.

program compiled into machine executable code runs somewhat

Perl

many

you program

is

memory

In

required to deal spe-

for storing data while

in Perl, the perl interpreter takes

9

memory when needed and

care of allocating extra

releasing that

memory

so

it

can

when it is no longer needed. This doesn't mean you can completely ignore memory issues. You still need to make choices such as whether to read a file completely into memory or read a file one line at a time. But you don't have to worry about actually allocating and releasing the memory yourself. be used again

Later in this chapter, greatest thing since

I

will

continue

peanut butter

this discussion

of Perl and

why

it is

the

bread really wasn't such a big deal until

(sliced

peanut butter arrived on the scene). Right now,

turn to the

let's

more

practical

matter of ensuring that you have a perl distribution up and running so that you

can begin your Perl programming journey.

1.2.1

Getting started

If you are

not using a system that has perl

distribution

and

install

it

The

yourself

installed,

latest

you

will

have to obtain a perl

source distribution can be found

Network (CP7\N)

on

the

Comprehensive

src.

Pointers to binary distributions for various platforms can also be found there

Perl Archive

in the /ports directory.

and the process

is

own

On

can be a

downloading the

unpack

to

it

it,

$ $ $

$ $

file.

.

time consuming.

The

installed.

first

process

is

thing you want to do,

from the above mentioned

CPAN

README file

site, is

for

your

is

just

,

You

will

have to answer a variety of ques-

your system and where you want things

all that's

The

;

'

configure step will take awhile.

NT systems

Win/

compiler

version of perl. Essentially, the process

'

usually

probably want to compile

This should provide you with enough information to

rm -f config.sh Policy. sh sh Configure make make test make install

The

C

will

go into the resulting directory, and read the

own

tions about is

little

you have a

latest distribution

system and the INSTALL build your

you

a Unix-like system,

version of perl, assuming

simple, though after

distributions contain detailed installation information,

usually painless.

Unix-like systems your

The

http://www.perl.com/CPAN/

at

needed in most

On Win32

ActiveState version of perl, which

installed.

Picking the defaults

cases.

systems, your best bet is

is

probably to obtain the

available at http://www.ActiveState.com/

For Win95, you will probably need to get the before starting to install the perl distribution.

DCOM package and install

You can

find

it

it

at

http://www. microsoft. com/com/dcom/dcoml_2/download.asp

10

CHAPTER

1

INTRODUCTION

—

;

Installing the ActiveState version of perl

The

archive.

you have good reason not

defaults unless

able to run perl

a matter of double-clicking the

is

process will ask a few questions and

install

command prompt and

from the

you should accept the

to accept them. After this,

run the perldoc

you should be

utility to access

the documentation (see later in this chapter).

MacOS

You can

get a compiled binary distribution of Perl for the

the ports section of

CPAN:

link should automatically redirect

you

Installing this version involves

and

few configuration

setting a

README

file.

The major

the help

menu.

1.2.2

Running Perl

MacOS

in

http://www.perl.eom/CPAN/ports/index.html#mac. This to a nearby mirror site.

unpacking the archive, starting the program,

details that are

sections of the

pointed out in the included

documentation should be accessible via

Once you have perl installed, creating and running a Perl program is a simple process. The following is a simple, one line program that prints the string "Hello World": \

print "Hello World\n" Create a fortable.

find a

new

text file (plain text) using

This should be a text

list

editor,

any editor with which you

not a word processing program

are

com-

—you can

of decent editors for various platforms by pointing your browser

at http:/

/reference.perl, com/query. cgi?editors

Now

enter the above statement. Save the

program from the command

file as "first."

You can then run

the

line as

perl first

On many Unix-like

systems you can create your script to be run as

executable program. This

gram and Here

is

method means adding

setting the executable bit

the

new

on the

file

a special

first

line to

if it is

an

your pro-

with the chmod Unix command.

program:

/usr/bin/perl print "Hello World\n" #

!

The

first line,

characters #

!

called the

followed by the

"pound-bang" or shebang full

path to where perl

in other words, the absolute directory path to the perl

ON PERL

is

line starts

located

with the two

on your system

program. If you save

this as

11

and then type chmod +x first

before

at the

prompt, you can then invoke the

program hke: first

,T, ,

i:.

If the current directory

PATH (the environment variable hsting you may need to qualify the above call as

not in your

is

search paths for executable programs),

./first.

The

ActiveState port

into a batch

you

If

good idea put one chapter

(see

2).

called a "droplet,"

is

turn your perl program

utility to

PATH and called like any other program.

in the script, line

in,

is

and then choose run script from the script

not necessary on non-Unix systems, but

because perl will check

With MacPerl, you can which

is

a version

it

for

command

always a

it is

line switches

such

also save the script as a Mac-specific

you can execute by double-clicking

its

as

item

icon.

Getting help

1.2.3 Perl

pl2bat

MacPerl then you should be able to simply choose new from

are using

menu. The shebang

-w

a

that can be placed in your

file

menu, type

the file

comes with

a relatively easy language to learn, but

not a small language. This book

it is

does not attempt to be a reference for the Perl language. If you have perl installed, however, you already have the most up-to-date language reference available. perl distribution includes a large

Unix manpages and/or

amount of documentation

The raw documentation

format called Plain Old Documentation {POD), and included perldoc utility (or shuck on the Mac).

you can enter perldoc perl list

installed as

at

your

command

is

in a plain text

mark-up

is

also readable using the

To view

the initial perl pod-page

line

prompt. This document pro-

of the remaining sections of the core documentation. Another useful

starting page

tents

is

HTML pages (or some other format, depending on instal-

lation configuration details).

vides a

that

The

is

perldoc perl toe which provides a more in-depth table of con-

of the Perl documentation.

One

extremely useful

of documents

set

is

the set of perlfaq documents. Very

down into smaller problems and addressing those. However, when learning a new language, some of the smaller problems are often difficult because you do not yet know how to express the solution in the context of the language you are learning. This is when it is time often one begins to tackle a problem by breaking

to turn to the Frequently

Do

Asked Question (FAQs).

not assume that the

FAQs only

that your question will not be

but they are no

12

less

it

found

valuable for that.

address simple or

there.

On

"little"

Many FAQs do

questions and

have simple answers,

the other hand, there are also

CHAPTER

1

many

real

INTRODUCTION

programming particular

problem seems

to be, you'll often

we

use in the FAQs. In chapter 3,

FAQs

FAQs.

issues addressed in Perl's

for information

The FAQs

we might

No

and

are viewable lists all

will begin developing a tool to quickly search the

with the perldoc

is

easy or difficult your

need.

of the questions you

Another source of help

how

have good luck finding something of

are divided into nine sections, or

and

matter

The perltoc page

utility.

will find

named perlfaql

files,

to perlfaq9

describes each of these

answers to in each document.

the Usenet community. There are separate news-

groups for discussions on miscellaneous Perl topics {comp.lang.perimisc)., discussions

on

Tk

graphics toolkit

moderated group that you can

read, but partici-

modules {comp.lang.perl.modules), and the

perl

[comp.lang.perl.tk).

There

is

also a

pation requires registration {comp. lang.perl, moderated)

pated in Usenet newsgroups before,

I

recommend

you have never

If

.

that

you

partici-

take a look at

first

news, announce, neivusers.

Although forums

all

of the newsgroups are open to public participation, they are not

for questions addressed in the perl

documentation and FAQs. The people

participating in these groups are knowledgeable to have tried to find answers to

and

helpful, but

you

are expected

your questions in the documentation before turn-

ing to the newsgroup. These newsgroups are not free help desks. If you treat

you

as such,

On

will likely get ignored or worse.

a related note, remember,

ners often approach a learn.

programming

programming language

This can lead to asking questions

like

is

about problem solving. Beginsimply another application to

as

"How do

I

do "X"

learning a

new word processor application, one might formulate

"How do

I

does not provide single Before you ask a

It

approaches

fail,

a question such as

provides ways to formulate solutions to problems.

It

"How do

FAQs

When is

commands

Perl's built-in fianctions (see

search the

my

in Perl?"

documents?" But a programming language

create footnotes in

not simply an application.

Then

them

I.

or functions for every conceivable problem.

." .

question, search through the documentation

perldoc perlfunc)

to see if

to see if your question has already

on

one meets your needs.

been answered.

two

If these

ask yourself how you would go about solving the problem without a

computer. For example, recently a question appeared on the comp.lang.perimisc

newsgroup asking (and not There

you

is

for the first time)

no simple even or odd

how

to

tell if

an integer

is

built-in Perl fiinction that solves this

odd or

even.

problem

for

The obvious question to ask yourself is "How do / tell if an integer is odd?" Most people simply notice if the last digit is one of 0, 2, 4, 6, or 8. If

directly.

even or

so, the integer is even.

Algorithms often

You may not succeed

in solving

not be the optimal solution, but

07V PERL

arise

from such simple beginnings.

your particular problem, or your solution

this

common

sense approach

is

the

first

may

step in

13

thinking like a programmer.

One more

question in the newsgroup,

to use

is

avenue, before resorting to asking your

one of the Usenet search engines

(for

example,

www.dejanews.com) to search the Perl newsgroups for similar questions that have been asked and answered in the

past. Finally, if you

have exhausted

all

may

avenues

of inquiry without success, ask your question on the appropriate newsgroup. Be

on what you've

sure to include information

you

are not just looking for free

Perl

handouts but are actually interested in learning.

Another place to begin exploring a wealth of

Perl related information

home

will find links to

page

sions of the Perl Perl Archive

From

www.perl.com.

at

there

Network (CPAN). At CPAN, you can with

its

you

If

new

are

encounter quite a

when

in the hacker

--esr/jargon/,

may want

the newsgroup

you

community. You can find

started,

and

beyond the standard

it

is

I'll

you may

is

the Jargon

One File.

slang terms

this file at http://www.tuxedo.org/

run through a few terms that you might happen

two standard

if

you do ask

a question

on

answered in the FAQ, you're unlikely to get responses

RTFM which

Quite often, people are

to look at

common and not-so-common

as you begin to read the literature. For example,

These

in general,

or use your favorite search engine to locate a copy.

Just to get

upon

problem domains.

using the above-mentioned resources.

a large dictionary or lexicon of

found

the

and download not only the

programming and/or Usenet

to

of jargon

bit

find

scripts for various

very good, and quite extensive, resource you is

is

HTML ver-

standard libraries and modules, but also a large

number of contributed modules and

This

you

documentation and FAQs, plus pointers to the Comprehensive

Perl source distribution,

Jargon

know

tried so the helpful people there

will

Perl

means, "Read The F****** Manual."

quote material from the "camel" or "llama" books.

books by published by O'Reilly and Associates. The

books feature pictures of the respective animals on

gramming Perl (camel) and Learning

Perl (llama)

—

their covers

and

are titled Pro-

See appendix C. Both are very

good books, by the way.

A

couple of other frequently used terms are "grep," meaning to search, and

"grok,"

meaning

to understand.

Grep

derives

from the standard Unix search

of the same name. If you want to grok Year 2000 (Y2K) issues in grep the

FAQs

Another of data

fied set

term

as a string (a

of syntactic

rules.

is

"parse." Specifically, parse

More

generally, parse

is

to break

up a piece

—according

to a speci-

means

sequence of characters or words)

often used in the context of sim-

ply recognizing and/or extracting particular bits of data from a larger

You may

you should

for the relevant entries.

common

—such

Perl,

utility

also see reference to "p5p,"

which

chunk of data.

refers to the perl5-porters, a

group

of people responsible for maintaining and upgrading the actual Perl distribution

14

CHAPTER

1

INTRODUCTION

— across the

many platforms on which

it

Another group

runs.

—

set

of groups

really

the Perl Mongers, a collection of user groups distributed around the world. (Visit

is

http://www.pm.org to find your nearest group or to start one.)

member of the Winnipeg

Perl

Mongers (Winnipeg.pm

happen

I

to be a

for short).

A variation of the Monger moniker seems to be Perl M(o|u)nger, which ular expression talk (you'll learn refer to either

Monger

munge," which means

reg-

about regular expressions in chapters 6 and 10) to

or Munger. Munger, then, essentially, in the

cess, slice, dice, julienne,

is

is

the

noun form of the verb

"to

context of data processing, to parse, pro-

massage, fold, bend, or otherwise mutilate

manipu-

(i.e.,

late) data.

This in

little

interlude barely scratches the surface of the jargon

your journey.

only a

If

nothing

new area of study, but

a

new linguistic

the Jargon File mentioned above

1.3

A

warned you

else, at least I've

—

you

will

run into

are entering not

arena as well. Don't forget to check out

contains

it

that

you

much more

than mere definitions.

bigger picture

The

previous sections have dealt with basic information

Perl.

Now we will take a brief step back and take in a larger view. My first choice for

a

title

Perl,

for this section

was

"Practical

and the Rest of this Book," but Several years ago,

inspection, repair, different,

I

worked

and Philosophical Remarks on Programming, that

and construction

diver,

tasks, often in

and there was no such thing

we had

—even

for

me.

doing a variety of underwater

fast-moving water. Every job was

as a transportable stable

could be used in every situation. Insted, selection of tools, a

was a tad long winded

an inshore

as

on programming and on

work platform

that

the next best thing: a shop with a

wide variety of surplus construction

steel (rings, bolts, rods,

angle iron, and I-beams), and an arc-welder. This was a hacker workshop.

We

cre-

ated reusable bracing and clamping components, and rigged up a variety of different scaffold systems that could be lowered

from the

barge, positioned,

and anchored

various ways to bridge piers of different sizes and shapes, pilings, or

tems.

That arc-welder was the key

variety of components into

In the

to being able to quickly

and

working solutions we could deploy

programming world,

Perl

reminds

me

very

solidly

brute force

utility.

I

to

its

think a better analogy

quite capable of hacking out

fast,

gate sys-

connect a

in the field.

much of

that

and, in particular, the arc-welder. Perl has been nicknamed the Swiss

saw of programming languages due

dam

in

workshop

Army

chain-

multitude of built-in tools and overall is

that of a Swiss

Army

arc-welder,

sometimes crude, one-time solutions,

one

as well as

building and joining (virtually seamlessly) components for solving more complex or longer term problems.

A BIGGER PICTURE

15

Perl

is

not your average everyday programming language. In

programming language. There

exceptional everyday

programming languages out computer

and

Perl

purists,

seem

scientists

there than

to get great pleasure

seems to have more than

who complain

So what makes

that Perl

its fair

No

and any program you write using

seems to

much

the

some

satisfy the

The language

same high

level

of sticks anyway,

share of detractors from computer science

single feature of Perl

Perl

makes

it

outstanding,

could also be written using another lan-

things easier to accomplish than they might be

in other languages, but this can't be offer pretty

an

too big, ugly, and redundant.

is

Perl so great?

guage. Certainly, Perl makes

lot

is

Of course, some

stick at.

from shaking a

it

more high

are currently

you can shake a

tact,

all

there

is

to

it.

There

are other languages that

level functionality as Perl,

and do

so in a

way

that

above mentioned stick wavers. Yet Perl remains wildly popular.

continues to evolve, and

its

user base

is still

growing unchecked.

What

appeal might Perl have beyond the sheer functionality that might

attract

programmers from other languages, and why would experienced program-

mers

fall

more

language

this

if

other "better" programming languages exist?

blame squarely on the shoulders of Perl's

lay the

I

with

in love

precisely, slightly

first

creator, Larry Wall. (Well,

above and between Larry's shoulders.) Besides being a com-

puter programmer, Larry also has a background in linguistics. Consequently, the fact that Perl has the qualities

of a natural language

some of Larry's own musings on ral.html.

Here

Two dancy I

will

1

no accident. You can read

these qualities at http://kiev.wall.org/--larry/natu-

touch upon only a couple of points in

this regard.

of the things Perl receives criticism for are the richness and the redun-

in the language,

mean

is

that Perl

is

which

are

by no means unrelated

a big language, incorporating

issues in Perl.

and supporting a

By

large

richness,

number of

powerful and specialized features directly in the language. In contrast, other languages tend to be minimal, providing standard libraries for specialized list

tasks.

The

of Perl's specialized features includes regular expressions, pattern match operaprocess

tors,

ming

management,

and directory manipulation, and socket program-

tools, to highlight just a few.

to provide

it

TMTOWTDI

exists in natural

is

"),

Perl.

is its

ability

This

is

Indeed, the Perl slogan

is

which stands

for "There's

task.

More Than

It."

Critics say that this

languages and in

(pronounced "timtoady

One Way To Do But

Another example of Perl's richness

more than one way of saying or accomplishing the same

redundancy;

learn.

file

both richness and redundancy make the language harder to

only true up to a point. Certainly,

I

may

be able learn a complete

minimalist programming language rapidly, but assuming there are libraries providing additional functionality, libraries to

16

do the things

I

I

would then

might want

still

have to learn to use the various

to do. Perl

is

not really more demanding in

CHAPTER

1

INTRODUCTION

this respect.

You do not have

to learn the entire language before

you

the essential elements plus any extra built-in features

present task. Similarly ble

way

to say

Perl's

you

start,

merely

find necessary for your

redundancy doesn't require that you learn every

something before you begin. Redundancy merely expands your

options. Indeed, the positive consequence of these natural language qualities

make

that they

possi-

it

make

easier to think in Perl; they

easier to express

it

is

not

your

thoughts in Perl.

There

is

also a strong sense

of community

among many

More than just a large number of users sharing information on Perl community shares a sort of Perl spirit. Perl's "naturalness" fulness

—not merely

clever

programming

more than fun and games, but

I

think

programmers.

various forums, the lends itself to play-

but poetry, puns, and other games

tricks,

Of course,

of the sort people play with natural languages.

Perl

this

community

significant to note that

it is

coming from other languages who have found

their calling to be

spirit

is

programmers

growing tedious

have expressed gratitude that Perl has made programming fun again.

The

Perl

community

are given freely

on the newsgroups and many

the development and evolution of Perl itself tion of contributed

modules from

ming, unlike most creative originality.

available

concept of sharing. Help and advice

also holds a strong

The

acts,

community

Perl

Perl

talented

Beyond

programmers

places a high is

programmers cooperate on

that all

is

CPAN

—

a vast collec-

over the world. Program-

premium on

reuse rather than

no exception. Several hundred modules

on CPAN, ranging from database

interfaces to

faces for several graphics libraries to Internet

development

programming

are

tools to inter-

to date manipulation

modules and much more. Whenever you find yourself facing a new programming challenge, check out

module

that will

CPAN. Chances

make your

task

much

are pretty

program with

it.

The

that

someone has written

a

easier.

By now you might be wondering when we start learning to

good

will stop talking

about Perl and

next two chapters concentrate on aspects of

writing good code and the process of developing programs. In the latter chapter,

we

follow the development of two Perl programs from

working programs.

A good deal of Perl will

A BIGGER PICTURE

initial

idea through to

be presented along the way.

17

CHAPTER

P7

Writing code 20

2.1

Structure

2.2

Naming

2.3

Comments

24

2.4 Being strict

29

2.5

21

A quick style guide

31

2

—

Writing code

guage

—

is

that

is,

typing in the set of instructions in a programming lan-

only one part of the programming process. In

next chapter,

a relatively small part of the

it is

may

small the act of writing code

The

decisions

gramming which

How

in turn affects

well

how

programming

be in the overall process,

you make here can have a

process.

it is

on

large effect

you write your code

easy

fact, as

to fix (if a

all

affects

problem

we

will see in the

process. But, it is

however

an important

act.

other steps in the pro-

how

arises),

easy

it is

to read,

upgrade, and add

additional features. Perl

—meaning and understand—but

often derided as being a "write only" language

is

written in Perl are inherently hard to read

this

of

all

symbol on a standard keyboard

simply

is

false.

the fianky symbols used in Perl (Perl uses every

for

variety of shortcuts Perl offers the

programs

Some presumed

Mostly, these accusations arise from people unfamiliar with Perl. difficulties arise as the result

that

one purpose or another); some

due

are

to the

programmer; and some occur because people sim-

ply writing bad code (this happens in every language). Although at

first

glance, Perl

appears to be a difficult language to read,

it is

not terribly

difficult to write hard-to-read

code in Perl

—but

easy-to-read code in Perl either. This chapter

not worry tions.

if

you

really isn't. Certainly,

it

is

it is

not terribly

difficult to write

Do

about writing simple, clean code.

don't recognize or understand the Perl code in the following sec-

They are only examples

to illustrate style issues.

and apply these guidelines

tunity to learn Perl

As we mentioned

You will have plenty of oppor-

in the chapters that follow.

previously, high level languages exist for the benefit of the

programmer, not the computer. The computer does not execute the instructions in a high level language. the particular

code:

first

be translated into the machine language of

computer system where the program

high

last chapter,

They must

level

They provide

will be run.

a level of portability across

instructions because certain operations that

all it

the different machine types that easier for

might take

humans

it

easier for

humans

to write the

several lines of

code can be written in a single simple statement in the high

make

in the

languages offer three advantages over low level machine

have translators for that language; they make

they

As we saw

machine

and

level language;

to read those instructions. This last benefit

is

the

subject of this chapter. It is

level

up

to the

programmer

to take full advantage of whatever facilities the high

language offers to produce easy-to-read programs.

read affects

how easy it

WRITING CODE

is

to write, debug,

and maintain.

How Let's

easy a

program

is

to

begin with structure.

19

;

Structure

2. 1

This book

is

organized into parts, chapters, sections, subsections, paragraphs, sen-

and words. Whitespace plays a

tences,

large role in delimiting these elements.

wouldn'twanttoreadabookwithnowhitespaceinitnowwouldyou?

look

Let's

You

at

an

example of bad code written in Perl: $s=0; $i=l;while ($i>= {$response eq 'q' or $response =~ m/''\d+$) $is_valid = 1; else { print "Invalid Input: enter an integer or

{

'q'

to quit\n";

}

The

conditional reads like

this: if

the response equals

tains only digits, then set the valid indicator to Finally,

we

translate the last

loop, or whether the response

A FIRST PROGRAM

q,

or the response con-

1.

chunk, which

tests

whether we should end the

was right or wrong.

43

;

;

;

;

;

;

;

;

= if ($response eq 'q' { $quit = 1; elsif {$response = $solution) { print "Correct\n" else } print "Incorrect: $question $solution\n" )

,

,

,

}

{

}

Once

again, performing our

the top level,

chunk

substitution from the low level back

up

to

we have our completed program:

faqgrep sort perlf aq4 .pod: How do I sort an array by (anything)? perlf aq4 pod How do I sort a hash (optionally by value instead of key)? perlf aq4 pod How can I always keep my hash sorted? .

,

.

.

know

Users would then

that the information they seek

is

of the perlfaq documents, which can be read using the

located in section 4

command perldoc

perlfaq4. Before

we

format of the perlfaq pod question

is

=head2. So for

tem.

files.

The format of these

contained on a single line and

we know

our pattern on a

You

will also

that,

when we

to

result in a lot

pod

files is relatively

about the

bit

simple.

with a pod directive that looks file,

the perlfaq

files

we only need

were

they were installed into a directory

installation

know a little

Any like

to search

with that sequence of characters.

know where

/usr/local/lib/perl5/5.00502/pod find the

starts

to

read through each

line that begins

need

On my system,

To

we need

begin designing the program,

,

.

: ..

installed

on your

sys-

which

will

named

.

,

on your system you can type perl

-v,

of output regarding the configuration of Perl on your system. Near

the end of this output

is

You should

subdirectory under one of these listed directories.

find a

/^o>=

,

/usr/bin/perl -w use strict; «set directory and filename list>> «set search pattern» >= my $pattern = $ARGV[0] or die "no pattern given:

FAQGREP

as the first

element in the @argv array can be referred to as $argv 0

because

in the array. In

program

$

!

"

51

;

We will explain the $ARGV[0]

is

or die syntax

empty or contains

shortly. In this case,

it

simply means that

program

a false value, then the

if

with the

will exit

given error message.

We

have seen the while and until loop structures in the previous example.

Perl has another looping construct that

values. This structure

designed specifically to loop over

is

The

called the f oreach loop.

is

foreach variable (list of values) statements;

syntax of the loop

lists

of

is

{

"'" }

In this structure, the loop executes once for every value in the

each execution, the loop variable

is

assigned the next value in the

During

list.

list.

You may

To

declare your loop variable prior to the loop or directly in the foreach line. ate over each

file

we may

in our array of filenames,

iter-

use

= foreach my $filename (@faq_files) {

}

Before you can read a dle.

A file handle

you need

file,

a Perl data-type that

is

automatically opened the

file

it

handle,

The

it

and

associate

to be read

we may

from elsewhere. Once we open a

read lines from the

syntax of the

file

openO function

a system operation that

failure occurs, so

we

We may

do

this

using a logical

or

operator like

tion.

open

(

f ilehandle

You

,

may

fail

for reasons such as the

using an if conditional, but

$filename) or die("can't open

tor.

The former

ter

4 for a discussion of precedence.)

it

file.

We want

is

file

to (

)

does

know func-

more commonly done

to evaluate the expression

on the

$f ilename

'

:

$

!

"

)

operator instead of the or opera|

just a higher precedence version

When

'

of the same operator. (See chap-

Perl encounters

left,

the open

that expression evaluates to true Perl ignores the right

52

with a

it

so:

|

first tries

is

$filenaine).

always check the return value of the open

will often see this written using the is

Perl

explicitly

associate

open(filehandle,

is:

or the user does not have permission to read that

such a

han-

file

using the same syntax: .

a

file is

and

file

not if

with a

keyboard by default, unless you've

Opening exist,

it

handle stdin for reading, stdin reads from what

called the standard input, usually the

file

open

associated with an input or output chan-

our method for reading input from the keyboard using .

nel. Recall

redirected

to

is

CHAPTER

{

)

it

function in this case. If

hand

3

such a statement,

expression. If the

left:

WRITING PROGRAMS

;

expression

and

exit

Perl then evaluates the right

fails,

hand expression

right

prints

;

its

is

a call to the die

argument

)

(

function,

)

The

to the screen.

value of the current system error, so

die

(

hand

we

expression. In this case, the

which causes the program

special Perl variable $

include

it

in the string

we

to

holds the

!

pass to the

function to provide a better diagnostic message about what went wrong.

We may define our next code chunk as «read files and print matching lines>>= open(FILE, Sfilename) or die{"can't open '$filenaine': while () {

$

!

"

)

" }

close FILE; It is file

^

important to remember that the

handle being read. You do not close

{)

is

the input operator and file

an input operator, just a

file

is

the

handle:

close FILE; Perl does

some

extra

magic when we use the input operator

within a while conditional.

while

(

defined ($_

When you

It

read from a

file

undefined value at the end of the file is

and assigned

only thing

automatically converts the conditional to read

)

=

as the

)

{

using , the input operator () returns an So, in this conditional, a line

file.

to a special Perl variable, $_. This value

is

read from the

then checked to see

is

defined. In this way, the loop will be executed once for every line in the

ting $_ to each line in turn.

We we

time

The loop will

exit

when

the end of the

file is

file,

if it

set-

reached.

use regular expressions again to test for matches against our pattern. This

introduce the substitution operator,

works the same

s/pattem/replacement/. This

match operator with regard

as the

to

matching the pattern, but,

instead of just matching, Perl replaces the found pattern with whatever

is

in the

second half of the s/// operator. The replacement part of the substitution operator

is

just a string,

not a regular expression.

with =head2 and to see

them

if

we

We will use this to find lines beginning

strip off those characters

print out that line from the

without replacing them so we don't

file.

= s/ ''=head2 / / and m/$pattern/) { print " $f ilename \n$_"

if

{

:

}

Notice that we did not use the =~ binding operator with either the substitution or the

match

operators. This

is

because

being bound to a particular variable,

FAQGREP

it is

when

either operator occurs without

automatically

bound

to the special $_

53

;

variable,

which, remember,

is

;

;

;

'

the variable that contains each line in our

,

file

due

to

the magic while condition mentioned above.

That completes the whole program. chunks into

All that remains

their relative places to create the

whole program

to insert the code

is

listing:

= # /usr/bin/perl -w use strict; my $f aq_directory = /usr/local/lib/perl5/5 00502/pod' perlf aql pod 'perlf aq2 .pod' 'perlfaqS .pod' my (afaq_files = perlf aq4 pod 'perlfaqS .pod' 'perlfaq6 .pod' perlf aq7 pod 'perlfaqS .pod' perlf aq9 pod !

'

.

(

'

.

'

,

,

.

'

,

,

.

'

,

,

'

'

)

'

.

;

die "no pattern given: $ my Spattern = $ARGV[0] foreach my $filenaine (@faq_files) open(FILE, $filename) or die "can't open $f ilename while () if (s/^=head2// and m/$pattern/) { print $f ilename \n$_" !

"

|

|

{

'

'

:

$

!

"

{

"

,

:

-

)

,

.

,

close FILE;

This compiles fine with perl

-c but running

to search for a pattern

it

sort produced an immediate error about not being able to open a trates the

kind of extra information that the

We check our open out giving the this

is

where

full

it

openlFILE,

Now

"

call

and

realize that

when

running perl

it

files

with-

variable can provide.

!

we

are trying to

(

trying to

open the

$faq_directory/$f ilename"

will return to

illus-

open the

We knew we needed the FAQ directory location, and needed. We have to change the open function to use the full

intitial specification.

we

)

of

This

pathname.

was

path and filename

(

$

file.

)

)

file:

or die "can't open file:

$!";

faqgrep sort produces the output we showed in our

We will

not proceed further with

and modify

it

this script at this time,

to optionally print out the full answers to

but

match-

ing questions rather than just the filename locations.

We have covered a lot of ground in this chapter. We have taken two programming projects from initial ideas through to working programs. We have also been exposed to quite a If you

don't

bit

of Perl code in the process.

had no previous experience with the

worry

if

some of it seemed

a

little

Perl language prior to this chapter,

over your head.

The main purpose of this

chapter was not to teach Perl, but to introduce you to the process involved in creating programs.

54

Too

often,

it is

tempting to jump right into writing code when

CHAPTER

3

WRITING PROGRAMS

given a problem, especially often have a

seems

like a

way of requiring more complex

When you sit down topic

if it

to write

and purpose or goal of the

an

essay,

essay.

Programming has

edit

revise

tion

you

give to the early specification

it.

solutions than

you need

to

Then you need

and develop an outline of your arguments. and

simple problem. But simple problems

Finally,

a similar

first

to

first

imagine.

have a clear idea of the

do the necessary research

you can write the

development

and design

we

cycle.

stages, the less

way

right

to design a program, or to

the prevailing

wisdom

is

and writing code.

33 1

that .

decompose

you should ^

a

is

no

single

problem into subproblems.

design your

program

first

then

atten-

time you'll have

spend debugging or redesigning and rewriting your program. There

to

essay,

The more

Still,

before diving in

Exercises

Modify the mathq program

to keep a

running score of right and wrong

answers. 2

Design and pseudo-code a program that simulates the rolling of two standard six-sided die

and

prints out the total of the

roll.

Then

consider

how

be modified to display the faces of each dice rolled, for example: a

and

5

might be displayed

#######

EXERCISES

might

roll

of 3

as

#######

####### ###### ####### #######

it

-

#######

55

PART II Essential elements

CHAPTER Data: 4.1

types

and variables

60

Scalar data

65

4.2 Expressions 4.3 List data

67

4.4 Context

73

74

4.5 References to variables

4.6 Putting

it

4.7 Exercises

4

together

76

77

59

At a

basic level, a

program operates on

data.

Not

among programming languages

mental variation

surprisingly, a source

of funda-

how they carve up

the world

is

in

of data into meaningful or interesting types of discrete data.

Some

languages are

drawing fine-grained distinctions between

splitters,

ous kinds of data. For example, in some languages, what

we normally think of as

simply numeric data (numbers) might be divided into integer numbers and

may

ing point numbers. These

be further divided based on their

much

storage space they require in

might

differentiate only

on

tions defined

memory). Other languages

between numeric data and character

These type distinctions

and second,

a given type of data,

may

two ways:

are applied in

A variable,

vari-

first,

float-

size (i.e.,

are

how

lumpers and

data.

in terms of the opera-

as restrictions

on the

types of

we mentioned in the previous chapter, can be thought of as simply a named memory location where a value of a particular type can be stored. In a splitter language, you may have several different types data a variable

contain.

as

of variables: an integer type that can hold only integers (again, perhaps further

on

divided into short and long integer types based

the size of the integer), a float

type for holding floating point numbers, a char type for holding a character, and

perhaps other types Variables

as well.

may also

be

(scalar) or structured. Primitive

classified as primitive

or scalar variables hold a single piece of data; structured variables hold a collection

of data. In a

floating point Perl

list

much

lumper language.

a

singular or scalar values

and

plural or

—

holding single pieces of data

number

(such as 42 or

3

such a

is

of

list

It

draws a primary distinction between

values. Perl has only

the scalar variable.

A

one variable type

scalar variable

may

for

hold a

It

may

also

hold a reference to another variable or

location (see section 4.5).

Similarly, Perl has a

ordered

list

.14159) or a character string (such as h or hello or this

string has 29 characters).

memory

variable that

of integers, and another array variable defined to hold a

numbers.

very

is

you may have an array type of

splitter language,

defined to hold a

list

list

list

of scalar values.

might

type of variable called an array that can hold an

The

scalars

need not

all

be the same type, for example,

be: (42, 'hello', 3.14159). Perl also has

another plural variable

type called the hash or associative array (see section 4.3.2).

4.1 The

Scalar data

simplest

way

to use data within a

program

represented directly within the program.

world program

60

in chapter

1

We

is

as literal

—

data

have already seen

that

this

4

DATA: TYPES

explicitly

with our hello

where the program printed out the

CHAPTER

is,

AND

literal

string

VARIABLES

:

Hello World followed by a newline (represented by representations of numbers with

print 42; print 3.14159; print -2;

# #

\n).

Here

are a

few

literal

comments:

an integer a floating point number # a negative integer

Perl also allows for a

few other

literal

representations of numeric data such as

scientific notation:

2.31e4 2.31e-4

is 2.31 times 10 to the 4th power, is 2.31 times 10 to the -4th power,

or 2310C or 0.000231

Additionally, in literal representation only, a

taken to be a is

taken as a

number

number

binary, octal,

in octal (base 8) notation,

and hexidecimal numbers,

Finally, Perl allows

We

bers.

please refer to appendix D.)

notation notation

(base ten) (base ten)

one further notational convenience

numwe use

for representing

is 1369253

is 7214300.312413

important to

realize that these integers

and

floating point

character data for that matter) are not internally represented

sequence of digits you see on your screen (or in

sentation.

with

writing out large numbers:

1_369_253 7_214_300.312_413

binary format.

is

and a number preceded by an Ox

can use underscores with numbers to enhance readability, just as

commas when

It is

a zero

in hexidecimal (base 16) notation. (If you are unfamiliar

is 139 in decimal is 506 in decimal

0213 Oxlfa

number preceded by

Not

all

floating point decimal

The number

this

book).

numbers have

0.2, for example, if printed

numbers (and

and stored

They

as the

are stored in

a precise binary repre-

out to 20 decimal places turns

out to be a representation of 0.20000000000000001110. This leads to occasions

when

the results of some mathematical operations are not exactly

expect. This

is

perlfaq4 for further discussions of such data String or character data

and double-quoted

strings.

marks or apostrophes, quoted print

(

strings

what one might

not a Perl problem but a fact of binary representation (see perldoc

first.

in

two

basic forms in Perl: single-quoted strings

Single-quoted strings, delimited with single quotation

are the

more

literal

Recall our Hello

"Hello WorldVn"

SCALAR DATA

comes

issues).

of the two forms.

We will look at double-

World program from chapter

1

);

61

This prints out the string of characters Hello World followed by a newline.

The

\n

is

a special sequence denoting a newline in a double-quoted string. This

referred to as backslash interpretation. available within

Table 4.1

double-quoted

Backslash interpretation

There

strings, as

in

are several backslash interpretations

shown

in table 4.1:

double-quoted strings

X

\a

alarm

\cX

control

\b

backspace

\Onnn

octal byte

\e

escape

\xnn

hexadecimal byte

\f

formfeed

\l

lowercase next

letter

\L

lowercase

next\E

\u

uppercase next

letter

next \E

\n

newline

\r

carriage return

\t

tab

\U

uppercase

W

backslash

\Q

backslash non-alphanumerics

\"

double quote

\E

end\LAU,or\Q

'

until

until

For any other character, the backslash means interpret the next character ally (losing

any

special

meaning

is

it

may

have had). This

is

liter-

usually referred to as

escaping a character. So, to include a double-quote character or a backslash character

within a double-quoted string, you escape them with a backslash:

print "This \\ is a backslash"; print "Here \" is a double quote";

# #

prints: This prints: Here

\ "

is a backslash is a double quote

Aside from backslash interpretation, double-quoted strings also allow variable interpolation. This

by

its

means

present value:

that a variable in a double-quoted string will be replaced

;

Svariable = 'Hello'; print "$variable World";

Array variables

may

prints: Hello World

#

also be interpolated,

but hash variables are not subject to

interpolation in this manner. All scalar variables begin with a $ symbol

and

array variables begin with a @ symbol, so a consequence of this interpolation if

you want

to have to

with a backslash so that

one of those symbols it is

$variable = 'Hello'; print "\$variable World";

interpreted

#

prints:

in

is

all

that

your string you must precede

it

literally:

$variable World

Single-quoted strings cannot interpolate variables. Single-quoted strings only allow for two special cases of backslash interpretation: a backslash

62

CHAPTER

4

DATA: TYPES

may

be used to

AND VARIABLES

;

escape a single quote

(i.e.,

to allow a single-quoted string to contain a single quota-

tion mark), or to escape a backslash as in a double-quoted string.

often helpftil in terms of maintenance to adopt a style of coding where

It is

you only use double-quoted

strings

tion or interpretation not offered

marks

for

all

when you

require a double-quotish interpola-

by single-quoted

strings.

Use

single quotation

simple strings.

Of course,

we want to use it in a program at best. If we could name an item of data, then just use the name to refer to it, we would be much better off. Well, we don't do exactly that, but we can create named containers (i.e., variables) to hold bits of data. Then we can access the data through the name of the container. specifying data literally every time

would be tedious and error-prone

4.1.1

Scalar variables

A variable

is

a container or slot of memory, associated with a name, where

store data values. Perl's scalar variable type can string, or a reference.

We

discussed variable

you can

hold any scalar value: a number, a

naming

in chapter 2,

but

let's

quickly

review the particular naming rules for variables in Perl here.

A variable

name

in Perl, apart

or an underscore character and

may

or underscore characters (well, any has a large

number of special

sequently,

you seldom have

from

its

number

legal

and

illegal variable

do not follow these variables

following

list

names you may use with your own

$total_amount $_private $field_3 $abcl23 $This_is_a_LONG_variable_name illegal illegal

The

digits,

than 255 characters anyway). Perl

worry about giving your

$ainount

$!var $13_var

less

built-in variables that

to

number of letters,

be followed by any

or clash with built-in variable names.

flict

type symbol, must begin with a letter

rules.

names

Con-

that con-

provides examples of

variables:

legal legal legal legal legal legal

(must start with letter or underscore) (starts with digits)

WTiile Perl does not force you to declare your variables before you use them, the strict

pragma discussed

in chapter 2 does force

you

to declare

your variables

or use fully qualified variable names (discussed in chapters 7 and 16).

way

to declare

your variables

is

The

simplest

with the my declaration:

my $variable; my $naine; my $f oo, $bar) (

SCALAR DATA

63

;

As you can

you can

see,

a comma-separated

it.

;

list

;

;

declare a

list

of variables by using parentheses around

of variables.

Once you've declared a variable, you'll need to know how The equals sign (=) is the assignment operator:

$foo $bar

=

to assign a value to

42;

Hello $greeting = "$bar World\n" print $greeting; =

'

'

Figure 4.

memory

1

shows the relationship between a variable name and

its

value in

during declaration and assignment statements.

Variable

Name

Code

Value

declaration

my

$foo;

$foo

#

$foo

#

assignment $foo = 42;

Figure 4.1

Scalar variable declaration and assignment

Assignment may

also

be combined with declaration either singly or in

list

form:

my $greeting = 'Howdy'; print "Sgreeting WorldVn" my ($first, $second) = ('Hello', print "$first $second\n" It is

the

'World');

important to note that assignment writes a value into the variable

memory

location), but using a variable, as in the

(i.e.,

into

print statements above, does

not remove the value from memory, but only accesses the value from the variable. If

programs were confined to the

would be of limited

use.

We

64

We will

examine

this

data contained within them, they

need to obtain data from outside the program from,

for instance, a user typing at a disk.

literal

keyboard or by reading data from a

more

in

file

stored

on

depth in chapter 6 when we discuss input and

CHAPTER

4

DATA: TYPES

AND VARIABLES

;

output. For now,

we

consider only the simple case of obtaining scalar values from

We

a user at the keyboard.

input

file

,

can do this using the input operator and the standard

handle stdin as follows: ""

my Sinput; print "Enter a value: " $input = ; print "You entered $ input";

In a scalar context, such as assignment to a scalar variable, the operator reads in

one

line

of input from the standard input, which

board unless you've otherwise redirected

it.

is

usually the key-

So, in the snippet above, the

statement prompts the user to enter a value.

print

first

The assignment statement

takes

everything the user types at the keyboard up to and including the newline (generated by hitting the enter key) and assign that input to the variable $input.

4.2 An

.

Expressions

expression

is

something that evaluates

to a value. It

able, a function that returns a value, or the result

may

be a

literal value,

familiar with, addition, subtraction, multiplication,

the operators +

,

-

*

,

and

,

/

respectively.

a vari-

of an operation on one or more

values or expressions. Perl supports the basic mathematical operations

and

you

division, represented

are

by

For example:

=3+5;

$foo $bar

=

{$foo

The

+7)

/

5;

sum of its two

addition operator returns the value of the

in this case are the

two simple expressions represented by the

the right

and the

result

of the expression ($foo +

Operators also have a

relative

onstrated in the above example.

precedence

Of the

7)

on the

operands, which

literals

the second line, the division operator also has two operands: the

tion

,

3 and

literal

5.

In

value 5

on

left.

level associated

with them,

as

dem-

four basic arithmetic operators, multiplica-

and division have a higher precedence than addition and subtraction, meaning

that multiplication

and division operations

subtraction. In the example above,

are evaluated before

we used

any addition and

parentheses to override the standard

precedence, causing the addition to take place before the division because parentheses

have the highest precedence.

Had we

$foo would have been added to the Perl has

two additional numeric

exponentiation operator the

modulus

ands.

It

result

operator),

is

**.

it is

of 7

/

5.

operators: exponentiation

and modulus. The

Like the four simple arithmetic operators above (and

a binary operator. In other words,

returns the result of its

EXPRESSIONS

not used parentheses, then the value of

left

it

takes

operand raised to the power of its

two oper-

right operand:

65

;

'

$foo = 4 ** 2; $bar = $foo ** 3;

The modulus dividing the

$foo is 4 raised to the power of 2 or 16 $bar is 16 raised to the power of 3, or 4096

#

,

#

operator

may

(%)

be

less familiar. It

operand by the right operand. Both operands are taken to be

left

by removing any

gers (or converted to integers if necessary

The

result

of 10 %

remainder and testing

is

because 10 divided by 3

3 is 1

even or odd, you might

if it is

provide a ready means of making such a

test.

The

2 will only have a non-zero remainder

N

an odd

two binary

Perl also has (.),

and

will

be handy to

is

inte-

fractional portions).

3 with

left over. 1 is

1

the

the value returned by this expression. If you recall the question of

an integer to see

know string.

by an

right away, the

This

if

is

realize that this

operator can

of any integer N, modulo

result

integer.

string operators: concatenation, represented

repetition, represented

newline from a

returns the remainder after

is

x.

There

chomp

(

)

is

also

one

which removes

function,

by a dot

built-in function that a trailing

remove the newline from an input value

useful to

obtained using the operator described above. $foo = 'hello $bar = $foo 'world' '

.

$foo = 'bo' X

3

#

;

;

concatenation: $bar is now 'hello world'

#

$foo is now

'

bobobo

print "Enter a value: $ input = ; chomp ($ input # removes newline from $input )

'

;

Perl also offers several

shorthand assignment operators that combine a scalar

operator with the assignment operator, the complete perlop pod-page (perldoc

list

of these

is

available in the

perlop), here are a couple examples to illustrate the

concept: $a = 42; $a +=5;

same as: $a

$b = 'hello $b .= 'world'; '

$a + 5

=

;

#

same as

:

$b = $b

.

'world'

You might now wonder what happens you attempt is

"

,

#

to use a

if

numeric operator such

are only defined for

add

as addition to

the second application of type distinction

Numeric operations

a scalar variable contains a string

I

mentioned

numeric

values,

it

to a

in the

and

and

number. This

opening section.

string operations are

only defined for string operations. In a strongly typed language where each variable can only hold a particular type of value such as an integer or a character string, the

66

compiler can detect an attempt to add two mismatched variables and

CHAPTER

4

DATA: TYPES

AND VARIABLES

;

;

' '

cause an error before the program

is

actually run. In Perl, with only

type for both strings and numbers, such information piler.

An

gram

is

not available to the com-

is

running and the variables are evaluated for their values.

problem

number

expected, the

is

in a very relaxed

manner.

number

is

expected,

it is

used where a

is

converted to a string. (For example, the

is

converted to a

something reasonably interpreted

as a

if

a string

number according

leading spaces in the string are ignored. If the

a number), they are taken as the

number

If a

3.14 becomes the string of characters 3.14.) Similarly,

Any

scalar data

attempt to add a string and a number cannot be detected until the pro-

Perl solves this

string

one

number

number. Any

used where a

to the following rule:

non-space characters are

first

minus sign followed by

(or a plus or trailing

is

number

non-numeric characters

are

ignored. If the string does not have an obvious numeric interpretation, a value of 0 used.

is

'

3

.14

converts converts converts converts converts

'

3.14'

'

3.14abc' 'abcl23 '

'

number

This conversion keyboard, which

is

is

to 3 14 to 3.14 to 3 14 .

'i

.

.

;

to 0 to 0

^ :

a useful device that allows

read as a string, and use

it

you

as a

to read a

number.

have done some calculations and wish to print out the verted back to a string for output.

Run

[

number from

the

Similarly, after

you

number

con-

results, a

the following example

,

v

program

a

is

few times

using different values for input. Try using: 42, 42abc, and hello. # /usr/bin/perl -w use strict; print "Enter a value: " my $input = ; my Sresult = $input + 5 print "result is $result\n" !

;

If

you

program

are using the

-w switch for warnings, which

warnings

will issue

interpretation. Try

when

I

highly recommend, the

a string value does not have

running the preceding

script again

an obvious numeric

with the same inputs but

without the -w switch.

List data

4.3

A list

is

simply an ordered collection of scalar values.

comma-separated

LIST DATA

list

It is

represented literally as a

of scalar values or expressions enclosed within parentheses:

67

)

|

list of four values list of three values list of three values

(1,2,3,4)

Ca', +

(4

"red") $foo, 1)

42, 5,

A nested gle flat

where a

list is

inserted within a

4),

is the same as

(1,

3,

We've already seen an example of using a

list

(3,

5)

my

able declaration using the

sin-

it

5)

4,

in the previous discussion of vari-

The print

declaration.

argument, though we've only used

its

simply evaluated to a

list, is

list:

2,

2,

(1,

list,

function also takes a

)

(

so far with a single element in the

list

as

list:

print ("the value of \$a is $a\n"); print (' the value of $a is ', $a, "\n"); #same output as above In the second version we've used a

same output

second

is

The

as the first version.

(Hence, we did not have

of three scalar values to produce the

list

element

first

the value of the variable $a.

And

double-quoted strings

symbol in the

the third element

quoted string producing a newline. The practical in

{ '

one

'

— ,

two

'

,

'

three

'

,

Creating this type of

and

lists,

is

four

'

list

in

producing

'

one

'

,

'

'

,

'

three

'

,

'

your code can make

four

first

lists

version.

of quoted

'

it

difficult to read for

prone to the error of forgetting a quote. The qw

two

The

list:

sequence of whitespace-separated "words" and produces a {

string.)

simply a double-

demonstrated here by the simplicity of the

is

the quote function. Consider the following

'

is

of variable interpolation

utility

Perl has a convenient list-making function for strings

the single-quoted string.

is

to use a backslash to get a $

list

(

)

long

function takes a

of quoted "words":

'

is the same as:

qw(one two I

three four)

used quotes in the above paragraph to describe "words" because they don't

have to be words in the ordinary sense ters

separated by any

just sequences

amount of whitespace. The qw

use parentheses to delimit acter.

—

its

argument.

One

(

)

of non-whitespace characfunction does not have to

can use any non-alphanumeric char-

Common choices are slashes or vertical bars:

qw/one two three/ qw one two three

'

I

68

CHAPTER

4

DATA: TYPES

AND VARIABLES

;

;

;

Array variables value may be stored in an

;

4.3. 1

A list

prefixed w^ith an @

array variable (see figure 4.2).

symbol (think of it

as a stylized "a"

fiar

An

array),

array variable

but otherwise

lows the same naming rules as those for scalar variables mentioned

ment

to an array variable

assignment operator to assign a

@array =

same

the

is

list

as for scalar variables.

earlier.

is

fol-

Assign-

Simply use the

value to an array variable:

(42, 13, 2);

@array#

$arrav[1]#

An

Figure 4.2

array variable

is

a

list

of scalars.

three' ©foo = (1, 2, ©bar = ($a, $b, 3 + 4) ©copy = ©foo; '

)

Whenever you

mind. That way you won't find element of a ©foo ©bar ©new

it

list

you cannot

surprising that

representation in

store

an array

as

an

list:

=

(1

=

('four',

=

(0,

,

you should keep the

picture an array,

2

,

'

three

©foo,

'

)

6);

5,

©bar,

7);

is the same as:

©new

= (0, three '),(' four (1, 2, which resolves to: ©new = 0 1 2 three four '

(

,

Lists

and

,

,

'

'

,

'

arrays are ordered.

'

,

'

5

6),

5,

,

,

6

,

7

7

)

)

We can access

individual elements of them using

a subscript notation to refer to the position, or index, of a value in the

list:

©array = {9, 10, 11, 12) $second = $array[l]; # assigns 10 to $second

You might bered

1

,

find

two things odd

and why the

access into the array

bol. First things first. Perl, like

LIST DATA

at this point: is

why

the second position

is

num-

prefixed with a $ instead of an @ sym-

many programming

languages, starts counting

69

from

zero.

indices

numbered from 0

On any

we

This means that the four element

stored in the array has positions or

to 3.

the second point, recall that an array holds a

given element in the array

say

@foo

list

is

-

^

•

(42,

12,

of scalars, so the type of $

When

symbol.

^

,

,

=

list

always a scalar type denoted by a

2)

;

performs the equivalent assignment of

this

Well,

$foo[2])

$foo[l],

{$foo[0],

it's

=

12,

(42,

2)

not quite the same thing. In the

equal that three element

list,

while in the

first case,

the entire array

only the

latter case,

is

set to

three elements

first

are set to those values. If the array previously held ten items, the last seven

remain

unchanged.

Each element of the array does

is

a scalar in

is

own

its

right. All the array variable

allow us to refer to the whole collection as one

on the

certain operations

list itself

such

beginning, the middle, or the end of the

Before

we proceed

from a

list

of scalar variables just

as

we saw

and

to

perform

list.

array operations,

of scalar values to a

does not just apply to array elements. You can assign a list

list

adding or removing elements to the

some of these

to discuss

that the above assignment

as

named

when

earlier

list

list

we should

realize

of scalar variables

of scalar values to any

declaring and assigning multiple

scalar variables:

{$foo, ($foo,

$bar) $bar)

That

12); ($bar, $foo) (42,

=

last line is possible

values of the list

=

two

list

#

$foo gets 42, $bar gets 12 swaps $foo and $bar

because the

variables create the

of variables on the

that

# ;

left. I

list

list

on

the right,

—which would

slice

of an array or

list

—

that

is

evaluated

which

is

then assigned to the

— $bar

first.

is,

assigned to $foo, then $foo

leave both variables with the

Aside from accessing individual elements, a

The

right

point this out so that you don't mistakenly assume

assignments happen sequentially

assigned to $bar

on the

same

we may access what

value. is

referred to as

list

of indices into the

DATA: TYPES

AND VARIABLES

a sublist corresponding to a

array:

@foo ©bar

70

=

(10,

=

(afoo[l,2];

12,

14,

16)

;

#

@bar gets the list

CHAPTER

4

(12,

14)

;

When we

;

are accessing a slice (sublist),

we

A slice of an array

a

with a subscript

list.

is still

slices

need not be

in a consecutive order:

©foo ©bar

=

(10,

14,

=

©foo

There

12, [3

are

0

,

,

1]

two

©foo

=

array,

(11,

we

12,

=

#

©bar gets the list

10,

(16,

12)

of built-in functions for adding and removing elements

pairs

array.

For adding to or removing from the begin-

use unshif t and shift respectively:

13)

shift (©foo)

For working

or array type value. Also, these -

unshift (©foo, 10); # ©foo is now (10, unshif t (©foo, (8, 9));# ©foo is now (8, $bar

list

16)

;

from the beginning or end of an ning of an

use the © symbol in combination

$bar gets

#

;

at the

end of an

11,

13)

12,

10,

9,

11,

©foo is now

8;

array,

we

12,

13)

10,

(9,

11,

12,

13)

and pop functions

use the push

for

adding and removing respectively: ©foo

=(1,2,3);

^

push(@foo, 4); push(@foo, (5, 6));

# #

©foo is now ©foo is now

$bar

#

$bar gets

=

pop(©foo);

One

last

point to

make about

6;

comma

comma-separated

(1,

2,

3,

4)

(1,

2,

3,

4,

©foo is now

(1,

2,

3,

how

4,

5)

they are interpo-

you print an array using print ©array, no

separates the values printed. Perl will just treat the array as a list

double-quoted string

of values to be printed. However, like

print "©array", the array

between each value. Both behaviors are good ing the values of the special variables: $ list

6)

5,

array variables concerns

lated within double-quoted strings. If

space or

.

,

,

defaults,

if

will

you

print an array in a

be printed with a space

but can be changed by

the output field separator,

and

$

"

alter-

the

separator.

4.3.2 Hash variables Perl has

one other variable type that holds collections of

variable (formerly %

symbol.

A hash

known

as

an associative

array).

does not have a convenient

array can be represented as a

list,

scalar values

A hash variable

literal

is

—

the hash

prefixed with a

representation in the

way an

because the elements of a hash are stored in an

order completely independent of the order in which they were assigned.

A hash a

name,

is

like

an array that

called a key (which

LIST DATA

is

not ordered, where each value

must be

is

associated with

a string), rather than a positional index.

These

71

keys are used as subscripts to access individual elements just as indices are used as subscripts into arrays. ets,

But while array subscripts

are contained inside square brack-

hash subscripts are contained in curly braces.

Even though a hash such a

case, the list

%hash

=

('first',

is

list,

taken to be a

42,

The hash above

not a

is

a

list

'second',

can be used to assign values to a hash. In

list

of key/value

pairs:

12);

has two elements, one corresponding to the key first and

one corresponding to the key second: %hash = ('first', 42, 'second', 12); print " $hash{second} \n" # prints: 12 ;

Perl has

an alternative to the

comma operator that is

assign to hash variables, the => operator. This that

it

works the same

on the

also automatically causes the value

useful

left to

when

using

lists

to

comma except

as the

be quoted:

%hash = (first => 42, second => 12); print " $hash{second} \n" # prints: 12 ;

The like

list

two

in the first statement

pairs

still

of elements separated by a comma, and

the quotes are no longer necessary. Just

may

be interpreted

%hash

=

%hash

first

(

has four elements, but

=>

as a

42,

hash

remember

(see figure 4.3

second =>

it is

72).

it

looks

more

easier to read because

that a hash

on page

now

is

not a

list,

but a

list

;

13);

#

$hash{first}#

Figure 4.3

A

hash variable associating keys with scalar values

Because a hash the beginning or

always add a

%hash

is

not a

72

no functions

end of a hash: there

new element by simply

(first => 42, $hash{ third} = 7; =

list,

is

exist to

add or remove elements from

no beginning or end of a hash. You can

assigning a value to a

new key

in the hash:

second => 12);

CHAPTER

4

DATA: TYPES

AND VARIABLES

;;

And you

can delete a key (and

delete $hash{ first }

You can

named keys the

list

ordered

get a (

)

#

;

its

value) using the

delete function:

removes the key 'first' and its value

of the keys or the values in a hash using the appropriately

list

and values

(

do not expect these

functions. However,

)

of keys or values in any particular order. Remember, a hash list.

The keys

(

function merely returns a

)

list

to return

not an

is

of keys depending on the

order in w^hich Perl internally stored those keys.

%hash = (first => 42, second => 12); $hash{ third} = 7; ©keys = keys (%hash) print "@keys\n"; # printed: first third second

hash

Perl also allow^s list

slices,

of values by providing a

-O

similar to array slices, with

list

of keys

as a subscript to the hash.

symbol, rather than the normal % symbol, for hash

;

Here, @h_slice

hash

12)

(7,

an ordinary array and (ahash{ 'third'

,

'second'

function iterates through key/value pairs in a hash. This

done with one of the looping constructs shown Hashes are powerful

of them in examples in

4.4

}

is

the

tools for organizing sets

is

gener-

in the next chapter.

of data.

We will make heavy use

later chapters.

Context

draws a primary distinction between scalar values and

Perl

use an ©

slice.

The eachO ally

is

You

access a

slices:

%hash = (third => 7, first => 42, second => 12); ©h_slice = @hash{ third' ,' second' } # @h_slice gets '

which you may

It

values.

what type of value may be assigned

tion extends farther than just

type of variable.

list

also affects

how

are evaluated within a context that

This distinc-

to a particular

certain expressions are evaluated. Expressions

may

be either scalar or

list

(or void, but

we

won't consider that here). Consider the following:

@foo $bar

=

(11,

=

@foo;

In the

An

12,

first

13)

statement,

array expects a

list

we have

so the

ment, an array on the right typed language,

CONTEXT

this

list is is

a

list

on the

right being assigned to an array.

evaluated in a

list

context. In the second state-

being assigned to a scalar variable. In a strongly

would be a type mismatch.

How can you

assign an array to a

73

The assignment

scalar?

expecting a scalar value;

is

it is

providing scalar context for

the array. Perl has a rule for evaluating an array in scalar context: return the

num-

would be

ber of elements contained in the array. So, in the above example, $bar assigned a value of 3.

you might

Similarly,

@foo = (12) @foo =12;

The

; '

:

•

first

statement assigns a

ond statement

tries to assign just

scalar value

is

evaluated in

which

is

(12),

list

with one element to the array @f oo.

context,

list

=

(2,

3,

4)

(0,

1,

@foo);

@foo

evaluated as a

is

Perl's

produces a single element

Perl

list,

the earlier examples of array assignment:

Obar gets

#

2,

1,

(0,

3,

4)

why

list

context to any element within, which

list

in the second statement rather than as a scalar.

built-in functions return different values

which they

on

and

;

provides a

list

sec-

assigned to the array.

=

A

The

the scalar value 12 to the array. In this case, the

We saw an example of context in @foo @bar

one of two ways:

assign a scalar to an array in

is

the array

Many

depending upon the context

of in

depending

are called. If a function has different return value behavior,

context, the perlfunc pod-page entry for that function will clarify that different

behavior.

4.5

f

References to variables

Earlier

we

•

we mentioned

storage bin with a

warding address.

you

or

is

name and an

how

grams given

follows earlier

it

circle

its

you'll

is

stored.

see

that

for that vari-

examine the variable each variable

pointing to a storage bin

something

value

up the address

variable, Perl looks

sents the address associated with the variable Perl encounters

reference as a for-

of variable names and their associated

lists

chapter,

this

immediately followed by a black

Whenever

you can think of a

to the correct storage bin. If you

in

but

string, or a reference,

one. If you think of a variable as a

but the address where

own

its

WTienever you access a

name and

make

a reference to another variable in a scalar variable,

are not storing that variable's value,

addresses.

to

address, then

When you store

Internally, Perl maintains

able

number, a

that a scalar value can be a

never said what a reference

—

dia-

name

is

that circle repre-

name.

like $foo,

it

expects the

$

symbol

to be

immediately followed by something that evaluates to an address where a scalar value it,

is

then

stored. Perl checks

its

replaced by

its

f oo

is

(or set if we are assigning

74

internal scalar

address,

name

and the

lists

for the

name

f oo. If it finds

scalar value in that bin

is

retrieved

something to $foo).

CHAPTER

4

DATA: TYPES

AND VARIABLES

;

Perl allows its

you

)

to assign the address of

one

variable's storage bin, rather

value, to another variable using the backslash operator. This

than

called assigning a

is

reference to a variable:

$foo =42; $bar = \$foo; It is

_

#

important to

realize that

$bar

is

a scalar variable with

In this case, however, the value stored in that location bin.

Hence,

if

.

$bar gets address of $foo's bin

you print out the value of $bar you

will

(

—

own

storage bin.

the address of another

is

not see 42 but a representa-

tion of the address that looks like: scalar 0x8050fe4

tion consists of the type of reference

its

)

This printed representa-

.

—and

a reference to a scalar

a representation

of the address. To actually use the reference to access the contents of that storage bin,

you need

to dereference

it.

Remember

that Perl expects to find something that

an address immediately following the

resolves to

symbol before our reference

variable,

it

will

$

symbol, so

if

we

place another

$

be followed by something that resolves

to an address: '

$foo = 42 $bar = \$foo; print "$bar\n"; print "$$bar\n";

'

;

In the

name

first

'

#

#

prints the reference: SCALAR 0x8050fe4 prints: 42 (

print statement, Perl sees $bar as a $ followed by a scalar variable

that immediately resolves to an address. Perl looks

nal tables

and

up the address

uates the second dollar sign, retrieves the value, is

in

its

inter-

prints the value stored there (another address). In the second print

statement, Perl discovers a dollar sign followed by another dollar sign.

sign

:

which

is

which

an address

It first

eval-

is

followed by a valid variable name, and

as

we have

already seen.

Now the first dollar

followed by an address, so Perl follows that address, retrieves the scalar value

stored there (42),

and

prints

it

out.

Figure 4.4 shows a graphic depiction of a scalar variable containing a value,

and another

scalar variable containing a reference to that variable.

diagrams, an address

is

A reference value

denoted by a black

is

circle

As

in the earlier

pointing to a storage bin.

always a scalar value, although

it

may

refer to the address

of an array value or a hash value:

©array = (11, 12, 13) $aref = \@array; print "@$aref\n"; In this case, Perl expects the @ symbol to be followed by either a valid array

name, which corresponds to an address, or an address pointing

REFERENCES TO VARIABLES

to

an array value.

75

$scalar = 42;

•

$scalar

$s_ref = \$scalar;

•

$s_ref

A

Figure 4.4

As

reference to a scalar variable

in the previous example,

ment

above, the @ symbol

is

$aref evaluates to an address. So, in the print

state-

followed by an address that Perl uses to retrieve the

stored array value. Figure 4.5 depicts an array variable

and a

scalar variable con-

taining a reference to that variable.

@array =

(42, 13, 2);

@array 0-

$a_ref = \@array; $a_ref

•

Figure 4.5

At

A

reference to an array variable

this point,

references.

it is

only important that you understand the basic concepts of

Their usefulness won't come into play until

later chapters

with passing parameters to functions and creating data structures. references

4.

6

more

Putting

data,

76

many

We

deal

will cover

fully in those chapters.

it

together

In this chapter, you've been presented with well as

when we

all Perl's

basic data

and

variable types as

simple operators and functions for reading in data, manipulating

and displaying the

results.

You may not

CHAPTER

realize

4

it,

but already you can write a

DATA: TYPES

AND VARIABLES

;

variety of simple but complete

programs using only what has been covered so

For example, consider a program that asks for a measurement in inches and plays the equivalent measure in centimeters.

Here

is

a version of such a

with excessive comments to remind you of various operations. to centimeters using the

approximation that

1

We

far.

dis-

program

convert inches

inch equals 2.54 centimeters:

#! /usr /bin/perl -w use strict;

my ($inches, $centiineters

)

#

;

declare variables

print "Enter a measurement in inches: $inches = ; chomp {$ inches )

$centimeters

#

$inches

=

#

display a prompt

read input value from user remove newline from input value

#

;

";

*

2.54;

#

calculate converted value

print "$inches inches is approximately $centimeters centimeters\n"

You could

write

more complex programs

as well, taking

many more

values

from the standard input and calculating complex mathematical formulas using Such programs may become long because they must repeatedly

these values.

prompt

for a value

and read a

repeatedly executing the I

mentioned

and running

Perl

ters.

earlier

at

next chapter addresses ways of

to simplify such problems.

that

you

will learn far I

We will

cover

more by writing

encourage you to do the

Quite a few more functions and operators

many of them

exist in addition to

in the following chap-

are always available to you.

Use

second viewpoint on things we've already covered or to take a

some functions we

haven't yet explored.

Exercises

Write a program that asks for a weight in pounds and displays the equivalent weight in kilograms

2

and repeat here

presented here.

either to get a

look

4.7 1

same piece of code

The

Remember, the perlfunc and perlop pod-pages

them first

we have

of input.

programs than by reading about them.

exercises that follow.

those

line

(1

kilogram equals 2.2 pounds).

Write a program that calculates the gross pay of an employee. The program should ask for the hourly rate of the employee,

how many

regular hours,

and

overtime hours the employee worked. Pay for overtime hours

should be calculated

EXERCISES

how many

at

time and a half (1.5 times the regular hourly

rate).

77

CHAPTER Control structures 5.1

80

Selection statements

5.2 Repetition: loops

84

5.3 Logical operators

89

5.4 Statement modifiers 5.5

Putting

it

5.6 Exercises

together

92 92

97

78

5'

;

A program

is

a series of statements

tliat are,

by

beginning to end. This sequence of execution

of the program. Not series

tion.

strictly linear fashion.

Other problems require

some condition

In the previous chapter, explicitly address the

(or

Some problems

a series

require a choice

particular criteria or condi-

of steps to be repeated a certain number of

met.

is

we

we

discussed simple expressions but

concept of statements. In short, a statement

is

did not

an expression

combination of expressions) followed by a semicolon. For example

This context.

we

referred to as the flow of control

more courses of action, depending on

or

times or until

is

from

problems are amenable to being solved by executing a

all

of instructions in a

among two

default, executed in sequence

are

realistic

is

a statement, but

Such a statement

it

doesn't

do anything.

will generate a

assuming that the -w switch

is

just a literal value in a void

It is

warning when using the -w switch (and

being used throughout this book).

examples of statements are

foo = 12;

^

....

print "$foo\n";

'

Statements are usually written on a single

line,

but

this

the language. Occasionally, statements are too long to line.

More

is

\

;

'

not a requirement of

reasonably on a single

fit

Consider the following statement, which might have been used in the solu-

tion to the final exercise in the previous chapter:

$gross_pay = $regular_hours $hourlY_rate * 1.5;

This

is

$hourly_rate

*

a perfectly valid statement, though

$overtiine_hours

+

it is

*

not particularly readable

when

written in this fashion. This statement might be better written as

$gross_pay

$regular_hours $overtime_hours

=

Using whitespace in statement.

An

this

* *

$hourly_rate $hourly_rate

manner helps the

even better way to rewrite

$regular_pay $overtime_pay $gross_pay

= =

=

this

+ *

reader understand that this

statement

$regular_hours * $hourly_rate $overtime_hours * $hourly_rate $regular_pay + $ overt ime_pay;

Multiple statements

may

be grouped into

by enclosing them within a pair of curly

CONTROL STRUCTURES

1.5;

*

is

a single

to use three statements:

1.5;

compound

braces.

is

statements called blocks

A block also

introduces a scope on

79

variables declared within

which simply means

it,

that a variable declared in a

my

declaration within a block only exists within that block. In other words, the variable in question

my $foo

=

42

is

visible

only within that block:

•

;

.

{

my $bar - 13; print "$foo and $bar\n"

#

#

;

both $foo and $bar exist within this block

}

print "$foo and $bar\n";

Scope declaring

is

all

an issue we

is

will address

$bar does not exist here

more

which they

— think of

such variables are

Your

are pri-

entire pro-

Perl automatically putting curly braces at the

beginning and end of your source code serves to

all

are declared. Blocks can be nested.

considered a block

now we

closely in chapter 7, for

of our variables with the my declaration and

vate to the block in

gram

warning,

#

file.

Aside from introducing scope, a block

group statements into a compound statement that can be selected or

repeated with the use of control statements.

5. 1 The

Selection statements

basic selection statement in Perl (and

many

other languages)

is

the if state-

ment. This statement has the following general syntax: if

Condition

(

There

is

)

{

Block

no semicolon

}

on

after the closing brace

contains multiple statements and the structure

is

a block. Often, the block

written as follows (according the

principles laid out in chapter 2):

if

(

Condition statement; statement;

When

)

{

Perl encounters

then the block of statements

an if statement is

it

evaluates the condition. If true,

executed. Otherwise, execution skips the block

and

continues with the next statement following the block (see figure 5.1).

But what

is

and what

a condition

any expression. This expression value.

Remember,

is

true

(i.e.,

in a scalar context, the result

and

false?

The

condition

is

simply

evaluated in a scalar context to produce a scalar

Perl interprets variables

depending upon context

80

is

scalar or

list

and expressions

context).

of the evaluation

is

When

slightly differently,

something

the scalar value.

CHAPTER

5

is

A value

evaluated is

false if

CONTROL STRUCTURES

statement;

statement;

Flow diagram

Figure 5.1

undefined

it is

of

an 1£ statement

(a variable that

has no value stored in

a string containing only a zero. Every other value

my $foo if

=

$foo

(

is

it),

empty

a zero, an

string, or

considered true.

1; )

{

.

print "$foo is a true value\n"

'

;

:

r

i

,

'

'

}

,

If you

ment of:

run the snippet above

inside the if block. If

as a Perl

program,

you change the

initial

it

will execute the print state-

assignment to $foo to be one

0 (or anything that evaluates to zero; 0.0 or 0el2 for example),

'

'

or

,

'

0

'

then the if block will be skipped.

Often we do not want

to merely test a variable's value.

that value in terms of another value. In other words,

is

We

want

to evaluate

the variable's value less

than, greater than, or equal to another specific value? There are operators, called relational operators, for each tests

a

numeric

common

relations

of these

and one

tests.

These operators come

tests string relations (see table 5.1

mistake to use the wrong type of relational

test,

in

two forms: one

on page

82).

especially to mistak-

enly use a numeric test for string data. Perl will issue a warning about this

being used. (You are using -w,

SELECTION STATEMENTS

It is

if

-w

is

aren't you?).

81

Table 5.1

Relational operators

Numeric

String

$a < $b

$a

It

$a

le

$8

$b

$b

$a

$a gt $b

True

if

$a

is

$a ge $b

True

if

$a

is

greater than or equal

TO q)D

$a

== $b

$a != $b

$a eq $b

True

if

$a

is

equal to $b

$a ne $b

True

if

$a

is

not equal to $b

You can use the if statement the condition if

(

is

Condition Again, this

to choose set

true or something else if it

{

)

is

Block

}

else

{

is

Block

up

false.

choices. Perl can

do one thing

if

This form has the general syntax

}

better written as an indented structure according to principles

outlined in chapter

2.

Figure 5.2 shows the flow of control in such a structure.

statement;

statement;

TRUE

FALSE

else statement;

statement;

else statement;

statement;

statement;

statement;

Figure 5.2

82

Flow diagram

of

an if/else statement

CHAPTER

5

CONTROL STRUCTURES

,

The

following example displays one thing

something if

else if the relation

$foo

;

"

.

>

)

r' .

;

}

greater than $bar, or

is

is false:

$foo > $bar { print "$foo is greater than $bar\n" else { print "$foo is not greater than $bar\n" (

if

''

'

'

'

' '

-'O

;

!

'

:

:

.

}

Additionally,

you may

select

one of several blocks

ple selection criteria in elsif clauses (note, there

is

to execute

no

by using multi-

"e" before the "i" in the

elsif keyword), which can be inserted between an if block and an else block (see figure 5.3).

state me fit;

statement;

TRUE

BLOCK

1

TRUE

BLOCK

2

FALSE I

ELSE BLOCK

statement;

statement;

Figure 5.3

Flow diagram

of

an i£/elslf /else statement

SELECTION STA TEMENTS

83

;

;

;

we can determine

In this manner,

if

;

a value

greater tlian, equal to, or less

is

than another value: if

}

$foo < $bar { print "$foo is less than $bar\n" elsif $foo > $bar { print "$foo is greater than $bar\n" (

)

{

)

}

else

{

print "$foo must be equal to $bar\n"; }

5.2 The

Repetition: loops

other primary flow of control structure

block of code that

ify a

the loop.

A loop allows you to spec-

to be repeatedly executed a specific

is

some condition

(determinate loop) or until a program

is

number of

met (indeterminate

is

to calculate the average of ten values input

by a

user.

loop). Consider

You could

out ten pairs of statements that prompt for and accept user input. write the code once

What

and loop over

you do not know

if

you must use a loop

this case,

czW&d z sentinel

The

value,

in

it

times

Or you

write

could

10 times.

advance

how many

values will be averaged? In

to repeat the input statements until a special value,

h emtttd.

basic indeterminate loop,

which

you'll find in

many

other languages,

is

the while loop:

while

(

Condition

)

{

Here the condition executed.

Once

condition

is

Block is

the block

}

tested and, if

is

it is

true, the statements in the

block are

finished, control returns to the top of the loop

and the

The block will be repeatedly executed as long as the conOnce the condition returns a false value, execution next statement following the block. Whenever you write an

tested again.

dition evaluates to a true value. will continue

with the

indeterminate loop, you should always double-check the statements in your loop-

block to ensure that the conditional will eventually

an

infinite

Here

loop that won't stop running until you is

fail.

kill

Otherwise, you will have

the program.

an example that calculates the average of an undetermined number

of grades: # /usr/bin/perl -w use strict; my ($average, $total, my $grade = !

$count)

=

(0,

0,

0)

'

'

84

CHAPTER

5

CONTROL STRUCTURES

{

;

"

while (Sgrade ne 'q') print "Enter a grade or 'q' to quit: $grade = ; chomp $grade; if (Sgrade ne 'q' $count = $count + 1; $total = $total + $grade;

,

{

.

"

)

'

} :

,

}

# avoid division by zero if nothing entered Scount 11=1; $average = $total / $count; " print "The average is $average\n"

'

,

;

.

:

_

we first declare our variables for the average, the total, and the count of how many values will be eventually entered. These variables are initialized with values of zero, using the list assignment we saw in the previous In the example above,

chapter.

We

also declare a variable to

with the empty is

not equal,

prompt the variable.

sentinel

string.

We

hold each grade

(ne), to the string q, the

block

chomp

(

)

was entered.

add the grade

off the newline If the sentinel

to the total.

and read

initialize

this into the

determine

to

was not entered, we add one

it

to

we

grade if

the

our count and

This entire loop will be repeatedly executed until the

which point the loop

to calculate the average

and display the

while loop may

input and

and use an if statement

user enters a single q, at

A

it is

executed. Inside the block,

is

user for a grade, or the sentinel value q,

We

as

then enter the loop statement. If the value of the grade

also

is

finished,

and the program goes on

result.

have an optional continue block immediately

fol-

lowing the main loop block. while

(

Condition

)

{

Block

The continue block

is

}

continue

{

Block

executed each time the while loop continues to be

executed by default (see figure 5.4 on page 86).

much trol

in practice.

statements

WTien

we

it is, it is

The continue block

its

is

not used

usually in conjunction with additional loop con-

will discuss later in this chapter.

statement, complete with

}

However, we can use the while

continue block, to help define the next kind of loop,

the for loop:

for (initialization; condition; In this statement, the tialization expression

the loop

body

is

and

executed.

REPETITION: LOOPS

first

tests

iteration)

time the loop

is

{

Block

}

encountered,

it

evaluates the ini-

the conditional expression. If the condition

WTien the loop body

is

is

true,

finished executing, the iteration

85

statement;

statement;

FALSE

statement;

Loop Block

statement;

statement;

Continue Block

statement;

statement;

statement;

Figure 5.4

Flow diagram of a while loop statement

expression

is

evaluated,

and the condition

is

tested again.

An

example

will help

show what happens: for

(my $count = 0; $count print "$count\n";




.

and ;v.

.;

{

print "still running\n" }

while 1 print "still runningVn" (

)

-

{

-

}

Infinite loops

have no value in programming unless you can

the loop to exit with just this sort

some other statement.

Perl provides a

force

last statement to do

of thing.

while 1 { print "Enter a value: " my $input = ; chomp $ input; if $ input eq 'q' { print "You are exiting the loop\n" (

somehow

)

(

,

•

,•

:

)

last; }

print "You entered $input, here we go again\n" }

The last statement Perl provides

will force

an

exit

of the immediate enclosing loop.

two other loop control statements

ment, the next and redo statements. the loop block to be skipped

Briefly, the

in addition to the

last

next statement causes the

and the continue block

to be executed.

state-

rest

of

Control

then returns to the condition of the loop. In the case of the for loop, the loop

body

is

skipped, and the iteration expression

REPETITION: LOOPS

is

evaluated again before returning to

87

;

;

;

A

the conditional expression.

non-empty

lines in a

number of

simple example might be to count the

file:

# /usr/bin/perl -w use strict; my $ count =0; while { next if length ($_) $count++ !

(

-

,

.

)


[2] -> [0] \n" "$$aref [2] -> [0] \n" "$$aref [2] [0] \n" "$aref-> [2] [0] \n"

Notice in the

'

,

,

prints: 42

#

;

actually a reference to an

is

;•;

'

;

'Now, consider a nested structure of arrays (This

used between

is

subscript:

13,

$aref->

"

as the final value evaluates to a reference.

the arrow operator ->, which

is

may con-

how much

are to read.

anonymous

(We could

array or hash values in Perl

also create

anonymous

used in practice.) In other words,

if you

is

scalars,

by using a

sca-

but anonymous

dereference a scalar variable

that did not previously contain a reference to a value, Perl automatically creates

anonymous

value of the appropriate type and stores a reference to

my $variable; $variable-> [0] = 42; print $variable\n" print $variable-> 0 \n" "

[

]

it

;

as if

array

it

:

held a reference to an array, Perl automatically created

and assigned the value 42

CREA TING REFERENCES

in the variable:

#prints: ARRAY 0x8 04a9 6c) #prints 42

Here, the variable $variable did not contain a reference, but it

an

(

;

"

it

to the first

element of that

when we used an anonymous

array, storing a reference

145

;

to that array in the scalar variable.

As we saw

containing a reference just prints out

its

type and

This way of creating anonymous values quite useful. In fact,

we

will use this

lem given above. Here's a top

level

in chapter 4, printing out a variable

method

is

in

memory address.

called autovivification

and can be

our solution to the marking prob-

breakdown of the program:

= /usr/bin/perl -w use strict; my $data_file = 'scores.txt'; my %students; «read file and build data structure>>

.

.

.

#

!

This code.

of

We

is all

relatively straightforward, so

begin by opening our data

the

first

jump

right into the data structure

and looping through

chomp o'ing the newline off a

arrays. After

fields:

file

let's

line,

element will be the student name, the second

number, and the

last field is

to build our hash

it

we split ()

We

the score for that assignment.

is

it

into array of

the assignment

use these fields to

build the structure.

«read file and build data structure>>= open{SCORES, $data_file) || die "can't open file: while

{ chomp; my ©fields = split /:/;

.'^^^

name => 'Anne Smith', age => 35, beer => Pale Ale

{

'

,

name => 'Bill Jones', age => 21 beer => 'Dark Ale',

{

'

^

'

},

stims

=>

name => 'Sara Tims', age => 32 beer => 'Wheat Ale',

{

}

)

;

foreach my $id (keys %employees) { print " $employees { $id} {name} drinks: $employees { $id} {beer } \n" }

This snippet of code produces the following output: Sara Tims drinks Wheat Ale Bill Jones drinks: Dark Ale Anne Smith drinks: Pale Ale :

Mixed structures

8.1.3

Some

languages provide a special data type for a variable that can contain a mixed

collection of other basic data types "struct" in

things

C.

Perl's

you can

—

example the "record"

for

nested structures give you complete flexibility over the kinds of

nest.

We've already seen one mixed structure with the hash of Consider a more elaborate kind of

arrays used for the student's assignment scores.

record for each employee than that used in the example above. just a single

employee record

of records, just

my %employees

as the

=

in Pascal or the

will consider

here, but the hash could contain a multiple

number

example above does:

asmith =>

(

We

name => 'Anne Smith' age => 35, children => ['Amanda', 'Amy'], beer => Pale Ale Lager

{

[

'

'

,

'

'

]

}

)

print

"

;

@{ $employees {asmith} {children}

CREA TING REFERENCES

)

\n"

;

ttprints

:

Amanda Amy

149

;

Scope

8.2

You know

and references

that a lexical variable only exists during

diate enclosing block).

Most

to

hold a value,

importantly,

it

it

(i.e.,

no longer

also stores

memory

is still

can be released and used for something

imme-

to a variable

and

Perl sets aside

extra information about that value.

how many

things are pointing at that

and

how

it is

Perl determines

needed by the program or

else. Let's

,.,

.

if

that

memory

consider the simplest of cases:

;

{

(i.e., its

when

Well,

exists)?

called a reference count,

is

whether a value stored in

my $outer

some

maintains a count of

particular value. This

current scope

So what happens when we take a reference

that variable goes out of scope

memory

its

,

.

:

.

my

$ inner = 42 $outer = \$inner;

}

print

"

$$outer\n"

;

#

prints: 42

Now, you might be $ inner

thinking, "Hey,

how

can $outer

has gone out of scope?" That's a good question.

never referred to $ inner, able $ inner itself

is

it

just a

still

The answer

referred to $ inner 's stored value.

name

associated with a particular

$inner

refer to is

that $outer

Remember, the

memory

after

vari-

location that

When we take a reference to a variable we get a reference to the mem-

holds a value.

ory location to which depicts graphically reference count

is

what

is is

associated, not the to variable

going on before, during, and

depicted by

how many arrows

name

itself

Figure 8.4

after the inner scope.

The

are pointing at a value.

$outer %-

my $outer;

$ inner

my $inner

=

42;

$outer

=

\$inner;

$outer

print "$$outer\n";

Figure 8.4

150

$outer

Reference to a variable going out of scope

CHAPTER

8

REFERENCES I A GGREGA TE DA TA

S TR UCTURES

;

;

This

you want

ability to

,

have a reference to a variable going out of scope

to create a reference within a subroutine

while you work with

my $foo = get_ref print "@$foo\n";

—

;

(

it

)

and

store

in a lexical variable

it

before returning this reference back to

when

useful

is

main program. ...

;

12

prints:

#

3

'

sub get_ref { my $temp = [1, return $temp;

^^^.M


(' arrow syntax');

;-'•,(

'

.

(

{

,

'

.

(

'

sub

f oo

'

)

{

,

print "$_[0] \n"

;

•

;

}

To

an anonymous subroutine, you use the sub keyword followed

create

immediately by the block of code that

my $sub_ref

sub

=

will serve as the subroutine:

{

my $arg = shift @_; print $arg\n" "

'

}

$sub_ref ->

(

"

I

-

;

•

^

m anonymous");

'

References to subroutines are convenient for a variety of things, but the most

popular usage references.

is

probably for creating dispatch

tables

by creating a hash of function

Consider an interactive program that asks the user for a

command

to

execute:

my %dispatch_table

=

foo

{

bar quit q help )

=> => => => =>

sub { print "You chose 'foo'\n" sub { print "You chose 'bar'\n" \&quit, \&quit, \&help,

},

},

;

print "Enter a command (or while () {

'q'

or

'quit'

to exit):

";

chomp;

my if

$ command (

=

$_;

$dispatch_table $command} $dispatch_table $command} -> {

{

152

{

)

(

)

CHAPTERS REFERENCES / AGGREGATE DATA STRUCTURES

;

;

else { print "Illegal command:

}

print "Enter a command (or

$command\n" or

'q'

.

;

'quit'

•-

.

to exit)

"

:

}

.

,„,

.

.

,

,

'

sub help { print "The available commands are:\n"; foreach my $com keys %dispatch_table print "\t$com\n";

./

. :

{

)

{

.

'

}

:

-

sub quit exit

.

{

0; ^ •

}

'

Here we have two This

tion.

different keys in the hash referring to the

The

times, but encouraged.

mous

and

to create

when only one was

store

two

a duplicate anony-

rent lexical environment. is

when

subroutine in Perl

Such a subroutine

anonymous subroutine

that an

that

environment

sub speak { my $ saying return sub

separate, but identical, function references

really necessary.

83.1 Closures When you create an anonymous

even

would have been make

alternative

function for both the q and quit keys in the hash. In other words, Perl

would have

this

same quit func-

not only allowed, since a "thing" can be referenced any number of

is

carries

no longer

is

=

shift;

{

print "$saying $_

[

0

is

called a closure. lexical

its

in scope.

]

!

\n"

deeply

it is

;

}

bound

to

its

Another way

cur-

to say

environment around with

This

is

;

it

best shown by example:

i

}

my $batman my $robin

speak Indeed = speak (' Holy ') $robin-> mackerel # prints: Holy mackerel! $batman-> {' Robin ') # prints: Indeed Robin! =

(

'

'

)

'

;

'

'

(

)

;

;

Here, the subroutine speak assigns

it

the

first

assigned the $ saying.

syntax. ated.

will

makes a new

element of the parameter

anonymous subroutine of whatever

()

passed to

it.

It

be given to

it

as

first

an argument. Both $batman and

anonymous subroutine from speakO, but with

still

Ssaying and

then returns a

that uses that lexical variable along with the

These anonymous subroutines

Each

list

lexical variable

new

parameter

$ robin are

different values of

are then called using the

arrow dereference

contains the original value of $saying with which they were cre-

Thus, even though the referenced subroutines are called in a different scope

REFERENCES TO FUNCTIONS

153

than where they were created, they act

them

—

as if

The

they were

still

—

,

;

•

in terms of any lexical variables used within

within the same scope in which they were created.

we

kinds of things closures are good for are somewhat specialized, but

will consider

one particular usage

here: creating a stream based

on

a particular

mathematical function.

You may or may not be the Fibonacci numbers.

number

in the series

is

familiar with a mathematical series of

The

first

two Fibonacci numbers

2.

0,

The

first

1,

1,

We

2,

ten Fibonacci

3,

1

numbers 21,

13,

8,

5,

,

is

also

1

and the fourth, the

,

n fibo(n-2)

= =

We

iterative

if

+

can translate

lated the Fibonacci

what

result

of

1

+

1

that position

this definition into a

simple recursive subroutine that calcu-

We could also cre-

for a given position in the sequence.

to be able to print out the first five such

that calculates the Fibonacci

times

—more

if

it's

number

tinue the sequence

sequence

One

it

later.

And,

—probably

answer

numbers

to store

still,

would be repeating

array, a cache, for

for position

a recursive function

Then, the program would have

its

more

is

each time

it

A subroutine

to be called at least

for each position in the

list.

calculated the next position in the

a lot of computational

the best in this case

that have already been

—

is

work

already performed.

to create a separate storage

computed and have

from where

it left

the subrou-

off

to use closures to provide a steady stream of Fibonacci

bers that can be continued at

But

numbers, then do some

n would have

—once

quickly.

position in the sequence in order to con-

tine utilize this array to continue the sequence

alternative

is

if n == 0 or n == 1 if n > 1

fibo(n-l)

number

number at

type routine that accomplished the same task but

we wanted

An

next

34

other things, then print out the next five numbers in the sequence.

five

The

can envision a recursive definition for the nth Fibonacci number in the

fibo{n) fibo{n)

an

1.

are

sequence: for any position n in the sequence, the Fibonacci

ate

and

called

obtained by adding together the two previous numbers. So

the third number, the result of 0 + is

are 0

numbers

num-

any time:

# fibonacci stream generator: sub new_f ib_streain { my ($current, $next) = (0, 1); return sub{ my $fib = $ cur rent, ($current, $next) = return $fib;

($next,

$current

+

$next)

}; }

154

CHA P TER

8

REFERENCES I AG GREGA TE DA TA

S TR UCTURES

•

# create two new fibonacci streams my $fib_streaml = new_f ib_streain my $fib_stream2 = new_f ib_streain

#

print out first

f oreach

(

1

.

.

5

5

-

(1

.

.

10)

"

\n"

(

)

;

•

.

:

,

.

'

•

:

1 • .

(

)

"\n";

,

(

)

,

...

•

2

";

"

,

;

'

;

"

.

(1..5)

,

{

print out next

f oreach

:"

'

fibonacci numbers from stream

print $f ib_stream2-> print

..>

,,

.

print out first 10 Fibonacci numbers from stream

f oreach

#

)

;

{

)

print $f ib_streaml->

#

• :

(

5

.,

-,

-

-

,

.

fibonacci numbers in stream

-

/

•;

.-

1

{

print $f ib_streaml->

(

)

"\n";

,

-

.,,

.-..l

,

-,,

.

}

When two

the new_f ib_streain(

defines

lexical variables

anonymous subroutine fianction again creates

returns a

new

function

)

is

called,

within that scope.

It

it

new

creates a

scope and

then defines (and returns) an

that uses those lexical variables. Calling the generator

an entirely new scope with

its

own

and

lexical variables

closure that uses those variables. In this way,

you can

up

set

as

also

many

completely independent Fibonacci stream closures as you want. Closures are something of an advanced topic, so

we

are only introducing the

concept here.

8.4 Nested structures on the fly Imagine a

of employee data, with one employee record per line recording

file

employee ID number, 142al3 971a22 131b21 119dl7 12 3al2 666s66 777q42 If

first

name,

last

name, department, and type

John Doe Sales :pt Jane Doe Operations ft Amanda Smith: Sales :pt Frank: Cannon: Support :pt Ron: Gold: Support :pt Lucy :Kindser: Operations ft :Bob:Norman: Sales ft :

:

:

:

:

:

:

or part time):

(fiiU

'

"

'

'

:

;

-

:

.

.

:

.

c -?

:

:

:

:

we wanted

loop through

it,

to read this

file

and

splitting each line

create

an array of

on the colons

arrays,

we could simply

to produce an array.

We

could

then push a reference to that array into our main array:

NESTED STRUCTURES ON THE FLY

155

;

;

;

# /usr/bin/perl -w use strict; open(FILE, 'employee.dat')

;

!

die "can't open file: $!";

|

|

# build structure my ©employees; while {

)

{

chomp;

my ©fields = split /:/; push ©employees, \@fields; .•

}

;

,

print info from structure foreach my $person (©employees) { print "Name: $person->[l] $person-> print "Department: $person-> [3 \n" #

[2

]

";

,

]

}

This can be simplified

mous

fiirther

by using the split function inside an anony-

array constructor:

my ©employees while (

)

{

'

chomp; push ©employees,

'

split {/:/)

[

];

}

You can use any expression constructor,

and the expression

inside an

will

be evaluated in a

evaluation will be the contents of the In the case of data of this #! /usr/bin/perl -w use strict open (FILE, employee dat .

'

sort,

anonymous

list

new anonymous

a hash of arrays

context.

The

result

hash)

of the

array.

• .

'

)

||

die "can't open file: $!";

build structure my %employees; while my ©fields = split /:/; = shift ©fields; my $id $employees $id} = [©fields]; )

anonymous

may be a better choice for a structure:

#

(

array (or

-

{

^ :

{

}

print info from structure foreach my $id (keys %employees) print "ID = $id. Name = $employees { $id} ->

#

{

[

0

]

\n"

}

156

CHAPTER

8

REFERENCES I A GGREGA TE DA TA

S TR UCTURES

;

;

Or maybe

;

;

,

,

;

;

you'd like to read the data into a hash of hashes so that each field

could be accessed by a

#! /usr /bin/perl -w use strict; open (FILE, employee dat .

'

name:

field

'

||

)

die "can't open file:

$

!

"

# build structure my @field_names = qw(fname Iname dept type) my %employees while { chomp my ($id, ©fields) = split 1:1; @ { $employees { $id} } @f ield_names } = ©fields; {

.

^

)

{

}

print info from structure foreach my $id (keys %employees) { print "$id: $employees { $id} { f name } $employees{$id} {Iname} \n"

#

Another way to structure hash using department names

this data to generate a report as the

would be

primary key pointing to a hash of ID number

keys, which, in turn, each point to a hash of the rest of the record fields.

an idea of the structure, here %departments

=

(Sales =>

is

{

'

to create a

what part of it would look 142al3

'

=> {fname => Iname => type =>

like to build

To

you

give

manually:

'John', 'Doe' '

pt

'

'' '

,

,

},

'131b21'

=> {fname => Iname -> type =>

'Amanda', 'Smith', pt

' :

'

'

}, },

Support => {'119dl7' => {fname => 'Frank', Iname => 'Cannon', type => pt '

'

}

,

}, )

print

"

;

$departments {Sales}

And here

is

{'

13 lb21 '} {Iname} \n"

;

#

prints: Smith

one way we could build such a hash of hashes of hashes on the

# /usr/bin/perl -w use strict; open (FILE, employee .dat

fly:

!

'

'

)

||

die "can't open file: $!";

# build structure my %departments my @f ield_naines = qw( fname Iname type)

NESTED STRUCTURES ON THE FLY

;

157

2 1

;

;

;

;

;

;

;

;

while { chomp my ©fields = split 1:1; my %record; @record{@f ield_names} = @f ields 1 2 4 $departments{$f ields [3] } {$fields [0] } = {%record}; •

(

)

,,

[

,

,

]

print employee data by department foreach my $dept (keys %departments { print "$dept:\n"; foreach my $id (keys % { $departments { $dept } { my $record = $departments { $dept } $id} print "\t$id: $record-> { fname} $record-> { Iname} print " ($record->{type} \n"

#

)

}

)

{

"

)

} }

8.5

Review

Reference Creation

^

$scalar =42; $sc_refl = \$scalar; $$sc_ref2 = $scalar;

# # #

©array $a_ref $a_ref

(42,

13,

2:

\@array [®array]

# #

;

#

@$a_ref3

=

©array;

# #

(a => 42, \%hash; {%hash}

%hash $h_refl $h_ref2 %$h_ref3

=

explicit reference to $scalar's location. implicit creation of new scalar location holding value of $scalar (autovivif ication)

explicit reference to ©array's location. explicit creation of new array location holding copy of ©array. implicit creation of new array location holding copy of ©array.

b => 13) # explicit reference to %hash's location. # explicit creation of new hash location # holding copy of %hash. # implicit creation of new hash location # holding copy of %hash.

%hash;

Dereferencing print "$$sc_ref2"; # prints: print "©$a_ref3"; # prints: print "${$a_ref2} [1] # prints: print "$a_ref2-> [1] # prints: my ©ary = keys %$h_ref2; print "©ary" # prints print " $ { $h_ref 3 } {b} # prints print " $h_ref 3-> {b} " # prints

158

42 42 13 13 13 a b

;

13

;

13

CHA P TER

8

REFERENCES I AG GREGA TE DA TA

S TR UC TURES

8.6 1

Exercises

Write a routine that reads the following table into a two-dimensional such

as

array,

an array of arrays or a matrix:

three one two four five six seven eight nine

Then have

the routine transpose the rows

and columns

to

produce the follow-

ing output:

one four seven five eight two three six nine

EXERCISES

159

CHAPTER

9

Documentation 9.1

User documentation and

POD

9.2 Source code documentation 9.3 Tangling code

170

9.4 Further resources

178

160

161

164

At

this

point you have acquired the tools and concepts for creating both simple

and sophisticated programs using the

ment your programs they

are incomplete.

With each program you

ken."

Some would even

you need

write,

However, unless you docu-

Perl language.

consider

them

"bro-

both user documentation

to supply

and source documentation. User documentation

is

simply the instruction manual for using your pro-

gram. Source documentation

is

want when maintaining,

will

someone

else

you or another programmer understand code you or

revising, or just trying to

We discussed techniques for source documentation back

has written.

make

in chapter 2: trying to

the documentation

the source code as self-documenting as possible

by

using good formatting, choosing good variable names (which applies to choosing

good names

for subroutines

comments. Sometimes

and filehandles

all this is

and by using informative

as well),

not enough. Later in

this

chapter

other ways of documenting your source code using Literate

we

techniques. First, however,

standard Plain

Old Documentation (POD)

level

documentation

is,

as its

gram or module. For programs,

name

this

what outputs user

is

it

The

interface to the

module: the

format.

implies, intended for the user of the pro-

it

expects,

what options

it

essentials

might

take,

of

and

file

using the

to

is

POD

way

to provide user level

embed

markup language.

POD

enough

within your script and not worry about

underestimated. Learning to use

POD

be available in a standard form since is

as

written in

documentation

for

your

Perl

the documentation directly in the Perl source

the Perl compiler understands just well

in the Perl distribution

of functions and/or methods

availability

and return values of each of those functions or methods.

current standard

programs or modules

it

Perl's

produces. For modules (discussed in parts 3 and 4), the intended

well as the calling interface

use

documentation using

(LP)

another Perl programmer. Documentation in that case should cover the pro-

grammer

code

Programming

documentation should cover the

running the program: what arguments

will discuss

and POD

User documentation

9. 1 User

will cover creating user

we

is

all

easy

is

a simple

to ignore

it.

markup language

that

—which means you can

These two benefits shouldn't be

and means your documentation

will

of the standard documentation included

POD format.

Using

POD to include your doc-

umentation within your program means that any user of your program or module automatically has the documentation.

your documentation when in a separate text

USER

it is

You may be more

right there in the

same

likely to properly

file

as the

update

code rather than

file.

DOCUMENTATION AND POD

161

'

Let's

POD

code.

such

utility

for

POD

consider

on

own

its

way of marking up

before

we

a

as

pod2html or pod2latex) can convert the pod-source

your document using utility translators to

else for

just

first

of formatting

is

files,

a translator.

The

of tags

set

a

1

heading

-

'

2

heading

covered

lists,

.

,

........

*

is

i

-

And this is a paragraph of plain text below the second level heading

= item

small and

is

list:

This is a level

4

the various

PostScript, manpages, or

files,

This is a small paragraph of text below the level 1 heading.

=over

you can write

We will just consider the basic elements here.

This is a level

=head2

into source code

that

is

(a translator

You can then use

tags.

HTML

in Perl source

tags we'll consider are structural tags, that indicate headings,

and items within =headl

set

which there

in the perlpod pod-pa.ge.

The

one

produce LaTeX

POD

of

utility

it

program

plain text so that another

is

one or another formatting programs. The

something

embedding

discuss

.

.

.

/.

'

;

' ,

',

. .

t

..

-

^

{'I

: -

^"S'-

' '

-

•

first bulleted list paragraph = item

*

r

,^

^

second bulleted list paragraph = back

'

,

'

'

The =headl and =head2 and sub-headings. The =over

some

formatters.

lowed by an

asterisk,

tags are fairly self explanatory, they create headings 4 tag starts a

Each item

in the

list is

produces a bulleted

list,

the

list

and the =cut

tag

is

list

item.

tag ends the current section of

POD command or structure tags

paragraphs also need to flush to the

lems.)

a indent size

A numbered list can

asterisk.

POD

The =back

until another

if fol-

be created

tag ends the

=xxx

style

of

encountered.

All the

lines.

number implying

tagged with an =item tag which,

simply by using increasing digits in place of the

162

{

'

=cut

for

f,

,;„

left

need to

start at the left

margin. Plain

margin and need to be separated by blank

(Note, though, that seemingly blank lines containing spaces can cause prob-

Within a plain paragraph,

several formatting tags can be used:

CHAPTER

9

DOCUMENTATION

.

=headl Simple Formatting

Within a plain paragraph some text might be tagged as I or B or as C (presumably formatted in fixed width font) The S tag means that the text inside the tag delimiter should not be broken across lines at the spaces. .

You can enclose filenames in an F tag, index entries using X, and links with the L tag. Links are for manpage references, and a tag like: L would translate to "the blah manpage" but this added text can be controlled (see L for further information) = cut

--

Aside from structural elements and plain paragraphs, you can also create "verbatim" paragraphs

no

—where what you

interpretation of tags, etc.

You

write should get typeset as

create verbatim paragraphs

it is

with no wrapping,

by indenting each

line:

=head2 Verbatim Example This is a plain paragraph that might be wrapped by the formatter and will have B interpreted in the process. A I paragraph, perhaps showing a code example can be achieved by indenting:

#this is a verbatim paragraph my $foo = "nothing B in here"; print $foo; =cut

And

most of what

that's

bonus of POD

is

takes to write simple

it

that everything

manpage format we

documents. The added

between an =coirimand type tag and an =cut tag

ignored by the Perl compiler. Therefore, tion (in a

POD

it is

simple to write your user documenta-

will discuss next) directly

within your program or

module. By keeping your documentation inside your program you are more to

remember

to update

sure that anyone

who

it

and new

to reflect changes

receives

your program

is

features,

also receives the

many translators printing. Or the user

and you

likely

are always

documentation. This

user can then use one of the

to

ment

can view the document using the

for viewing or

perldoc

may

utility

included with the Perl distribution. (Some distributions of Perl

not include the perldoc

comes with a viewer

The supply

USER

produce a nicely formatted docu-

utility:

the MacPerl distribution, for example,

called shuck.)

standard convention for writing

at least the

minimum

embedded

POD

documentation

sections of a standard Unix-like manpage.

DOCUMENTATION AND POD

is

to

The

163

minimal

you should include

level- 1 sections that

solves the world's

problems are shown in table

Sections to include

Table 9.1

in

called foo that

9. 1.

POD documentation

Section

Description

NAME

The name

SYNOPSIS

A

brief

program

for a

program or module and

of the

usage example

of the

a

few words about what

program showing

its

it

does.

calling syntax, or a rep-

resentative sample of the functions within the module.

A more extended

DESCRIPTION

using

OPTIONS

=head2

any, put

If

them

you choose the

A

FILES

SEE ALSO

BUGS

,

'

,

.

discussion of the program, possibly with subsections

tags. a

in

of the files

A

list

of

If

you have bugs

manpages

Author's

want

There perlpod.)

omit

name and

if

none, leave this section out.

programs and/or documentation.

for related

in

your program that aren't ironed out yet,

them

If

this section.

used by the program,

list

or risk being told about

AUTHOR

here, or perhaps under the description above.

list

latter option,

list

them here

again and again...

contact information, plus any copyright statement you

to include (which also could

be under

are other relatively standard sections

You can and should add any

its

own

level

you may want

additional headings

1

heading).

to include. (See

and information about

your program that you deem appropriate.

You may include is

POD

almost anywhere within your program.

that if the compiler reads a

ment,

it

will ignore everything

finds.

Some

some

place

authors put

it

at the end,

things in Perl,

9.2

POD

it is

all

the

tag directive

up

it is

looking for a

and including the next =cut

to

up

it

to the

was

mean

state-

directive

it

throughout the source code. Like

many

Sou rce code documen tation largely

tainable code. I

new

programmer.

Source code documentation was discussed to some extent in chapter ter

basic rule

POD information at the beginning of the program;

and others mix

a choice left

when

The

about using good

style

and comments

Often those guidelines are

all

well-respected ones, not crackpots

to

2.

That chap-

produce readable, main-

you need. (Some programmers

—go

as far as to say that if

—and

your code

needs extra comments to be understood, you need to rewrite your code.) Sometimes, however, this

is

not enough. You

may want

to include detailed explanations

of certain algorithms, provide diagrams, or present the code in an order different

from the more

linear order the compiler expects. Literate

Programming

(LP) tech-

niques can be used for such things and more.

164

CHAPTER

9

DOCUMENTATION

LP

neither specific to Perl, nor necessary for

is

can be such a

LP

in

usefiil tool that

Perl,

but

it

remainder of this chapter to using

will devote the

I

programming with

your Perl programming.

Programming

Literate

Knuth

method of programming developed by Donald

a

is

in the early 1980s (Knuth, D. E. "Literate Programming." The Computer

Journal (27)2:97-1

1984).

1 1

The

essence of LP

embodied

is

in a

quote from Knuth:

Let us change our traditional attitude to the construction of programs: Instead of

imagining that our main task

on explaining

rather

The tion

basic concept

is

what

to instruct a computer

to do, let us concentrate

to

humans what we want the computer

is

that

one should be able

and the program source code together

to do. (Knuth,

file.

984.)

program descrip-

to v/rite out the

in a source

1

This can be presented in

an order suited to explaining the code to humans. The program source can be extracted

from the

file

The documentation,

and tangled together into

then,

is

the original

file,

its

which

proper order for the compiler. is

run through a process called

weaving to produce the description and code in a form ready for typesetting (usually

by LaTeX, but other

target formats such as

Quite a few LP systems

You

are already familiar

that

POD

are also a

Many

are designed for a particular

few language-independent LP systems.

with some of the syntax of one, the noweb system, created

by Norman Ramsey. Some sections of

out there.

exist

programming language. There

HTML can be used by some LP tools).

Perl

programmers use

POD as a form of LP, intermixing

POD-formatted description within the source code.

is

much

better suited to

documenting the source code

documenting the

itself

Thus, in

Personally,

interface of a

this section

we

I

feel

program than

will consider the

noweb system of LP.

Back

in chapter 3 (and again in chapter 5),

name and

define chunks of code.

we used

a simple little syntax to

That syntax comes from noweb, though we did

not use the complete noweb syntax. This syntax allowed us to break our programs

up into manageable

little

pendent of the order

in

units that

which the

back into the main program

The

(and nothing

symbol

nated

else

on

at the left

when

a

discuss in

any order we wished, inde-

particular lines of code

had

assembled

chunk of code

in

noweb begins with double

chunk name, immediately followed by an equals

that line).

A chunk of documentation

is

begun with a

margin, followed by a space or a newline.

new chunk

to be

the root chunk).

actual syntax to define a

angle brackets enclosing a

©

(i.e.,

we could

begins or the end of the

SOURCE CODE DOCUMENTATION

file is

A chunk

is

sign

single

termi-

encountered.

165

;

@

:-

;

;;

.

This is a documentation chunk in which we would explain why the following code assigns the answer to the universe (42) to the variable $foo then does other stuff and finally prints out what $foo divided by 2 is: =

my

=

$ f oo

42

;

«some other chunk>> print "$foo

is $bar\n"

2

/

@

This is another documentation chunk, in which we would explain the significance of dividing $foo by 2 if doing so had any significance, which, of course, it doesn't. "' = my $bar = $foo / 2 '

®

,

'

f:

.

,

Now, in a

file

if

the above were to represent a complete (albeit useless) program, saved

named

useless.

—on

notangle

—

nw, then running the tangler

that source

-Rchunk

notangle

as:

in noweb, the tangler

is

called

useless. nw would produce

the following output:

my $foo = 42; my $bar = $foo / 2 print "$foo / 2 is $bar\n";

Had

the placement of the

have been the same.

' .

.

"

two chunks been

The chunk

and any referenced chunks

-

^

'

.

>

.

reversed, the tangled output

command

given on the

.

line

found and printed,

is

are replaced with their definitions.

would

This means you can

begin designing your program using high level concepts as chunk names, then design and define each of the chunks in the order that makes the most sense to

—much

you

as

we

did for the

f aqgrep

and primes programs

in chapters 3

and

5

respectively.

A particular chunk in

one

place)

definition. final

to

definition

may

also

be continued

by simply using the same chunk name when

Continued chunks must occur

tangled code

(i.e.,

not fully specified

starting another

chunk

in the order they are to appear in the

—notangle simply concatenates

all

continued chunks together

produce a single chunk:

Documentation stuff. = my $foo = 42

.

.

,v

,

«another chunk»

„

. .

'

®

'

More documentation.

.

.

'

V,^

.

.

«another chunk»= my $bar

166

=

$foo

/

2

CHAPTER

9

DOCUMENTATION

;

@

then we continue defining the original chunk:

Yet more documentation..., =

print "$foo

is $bar\n"

2

/

@

Tangling the above version produces the same output ple. All the

continued component chunks of chunk are concatenated together and

then the chunk tions in the

is

chunk

represents a complete

You can

same

its

own

file

A

file.

program or module or something you want

to

given noweb source

module

write such a

the source code

testing

A

you may write a

functions to ensure they are

chunk of

fi^r

all

library

as a literate

a

might hold more than one

file

module

source

that defines several fiinc-

file.

You can

program whose purpose

working. In

way, you could even have each

this

code follow the chunk (or chunks) of module code that

module code or the

tangle out either the

Of course, we may still make sages to the screen, noting the

all

where

is

our code and Perl

name and might

Perl thinks the error

gled program that

ers

file

errors in

we

this

actually run.

is

not

really a

line be).

Hence, the problem.

compiler about what corresponding code

number

it is

is

it is

reading.

on

We

it tests,

Then you could

The problem file

Many language file.

tell

These

can use them to

located in the useles.nw

file.

is

mes-

found the error

it

that we've gone to

separate

numbers and

line

in that

will print error

number where

understand special directives that do nothing except

reading and what line

file.

code or both.

test

the trouble of writing our source code in chunks in a

be correct. Well,

also include in

to test each of the

is

thus keeping related code close together in the literate source

(or at least

with their defini-

to use as the root chunk.

notangle which code chunk

told

root chunk. For example,

the

are replaced

same manner.

tangle out into

tions.

Any embedded chunks

printed.

The -R option root

previous exam-

as the

from the tan-

name

file

will

not

compilers or interpret-

the compiler

what

file it

are useful for lying to the

tell

the compiler where the

Wlien an

error

is

encountered,

the error messages will point to the corresponding code.

In Perl, a line directive takes the form of a special

#line 13

"file" by

itself

on

a line. Actually,

it

comment

that looks like

will recognize directives

match-

ing the pattern

/'-#\s*line\s+ (\d+)

\

s*

(

\s "([""]*)") ?/

In that pattern, the $1 variable would hold the line able

would hold the

file

name. The

included, Perl uses whatever

it

number and

name

is

optional. If the

currently thinks

is

the

file

SOURCE CODE DOCUMENTATION

file

file

the $3 vari-

name

is

not

name.

167

The

noweb can be given

tangler in

and

a -L option

it

useless.

nw file

an example, a

as

notangle -Rchunk -L useless. nw

file.

Using

call to

>

xxx

would produce the following output

in a

#line

line directives

.nw source

into the tangled code referring to positions in the original

the above

emit

will

named

file

xxx:

"useless. nw"

3

my $foo =42; #line 11 "useless. nw"

my $bar = $foo / 2 #line 5 "useless. nw" print "$foo / 2 is $bar\n";

'

;

That

foo

effect, a line directive is

from a code chunk. Now,

2; (where the

/

;

with the -l option in

is,

enters or returns =

.

-

$

symbol on $foo

was an

if there is

error,

such

as

it

my $bar

missing), then running the resulting

would produce the following

tangled code as perl -w xxx

emitted whenever

errors:

Unquoted string "foo" may clash with future reserved word at useless. nw line 11. Argument "foo" isn't numeric in divide at useless. nw line 11.

So we could proceed directly to our original noweb source problem. revise,

We

and maintain the

If that

were

be beneficial. tion.

only use the tangled code to run the program.

The

write, debug,

literate source.

noweb (and other LP systems) allowed you to do,

all

original

However, there

is

to find the

file

We

.nw source

file

file

to

would

still

would be your program's documenta-

another side of the LP system

tem can weave your source

it

— "weaving." The noweb

produce LaTeX or

HTML

sys-

documentation

for

formatting and viewing. This means you can write the documentation chunks using whatever capabilities the target formatter allows such cal formulas,

HTML

diagrams,

cross-references,

lists,

and

as:

typeset mathemati-

Both the LaTeX and

indexes.

backends perform additional formatting and cross-referencing of your

actual code chunks, line options to the

and any

identifiers

you

specify,

through the use of command

noweave part of the system.

When you end a code chunk, you may use a special directive to specify a list of identifiers

—

variables, filehandles, subroutine

that chunk. In the

woven

and

all

cross-referenced

168

etc.

— considered

"defined" in

version, such identifiers will be cross-referenced

index can be produced listing defined,

names,

all

the chunks that used that identifier.

and indexed

and an

defined identifiers, the chunks where they were

Chunks themselves

for easy reference purposes.

CHAPTER

9

You may

will also

be

specify such

DOCUMENTATION

:

by following the @ symbol that ends the code chunk with a space and the

identifiers

%def

.

directive, followed

by

a space-separated

of identifiers on the same

list

line:

In a documentation chunk. Here is a code chunk which includes identifier definitions marked at the end of the chunk

«chunk>>= my $foo =42; my $bar =13; © %def $foo $bar Now in another documentation chunk. Unfortunately, because this

noweb system,

it is

book

However,

not being typeset using LaTeX and the

to be

shown

I

have created noweb source

program (shown

sophisticated version of the faqgrep

program

is

not possible to show you here exactly what the typeset documen-

tation actually looks like.

tangler

.

in chapter 13)

These

later in this chapter.

will

more

for a

files

and the simple

be available at

httpill

www.manning.com/Johnson/., where you will find a link to additional online resources for the book, including source code

(PDF) versions of the

Other

9.2. 1

One good

typeset

and

PostScript,

and Portable Document Format

documentation for the two programs mentioned.

ofLP

uses

use of an LP style of programming

teaching purposes, which

exactly

is

many of the programs you

why

I

is

the presentation of source code for

have used a form of LP

have encountered thus

far in this

when

presenting

book.

A couple of related uses arise from the fact that a single literate source file may contain the source code for more than one program, each with further elaborated.

Of what

possible use

is

this?

its

own

rectly.

program

that verifies that each

Using LP, you can create two root chunks

and one

for the test suite

lowed by

its

code

intended to

it is

time. If a

test,

component. In

for the

this way, test

wish to cor-

program or module, the program, fol-

code remains close to the

and the documentation can deal with

component needs

easily adjusted at the

—one

also

component works

— then develop each component of

related testing

chunk

Consider that you are writing a

program or module with many small components (chunks). You may write a comprehensive test

root

issues at the

to be fixed or modified, the appropriate test

same

code

is

same time.

This idea applies to

test

data as well: you

may keep chunks of code

that deal

with particular kinds of data next to chunks of data designed for testing that particular

chunk of code.

Similarly, a

program may read an external configuration

ing a set of parsing rules.

As above, the program and the

parsing data can be written in the same source

SOURCE CODE DOCUMENTATION

file

file

or a

file

describ-

external configuration or

in a parallel fashion.

169

None of this our tangling

You

time).

The

tem.

implies that literate code need be contained in a single

script given

are

fi:ee

multiple

do not need

your

to create

files

literate

match up with the multiple

to

LP

senting the source code in a logical fashion. Like Perl,

93 The

it

r

lacks

all

just described.

the formatting

the real typeset version.

LaTeX

—such

(When

We

call

^

is

:

is

program

that

would be

typeset

—

the previous chapters,

and introduce

the

like.

The

include a few

Remember, the

fijll

are available for

following program will allow

code without fetching and

many

available in

using noweb and

We will

automatically added.)

will also serve to tie together

It

is

markers so you can see what they look

to try out writing literate source

work with

the presentation only partially literate

http://www.manning.com/Johnson/.

noweb system.

literate

about giving you more

and typeset versions of the following program

plain text source at

your

design and documentation.

and cross-referencing

the literate

cross reference material

identifier definition

download

ultimately

files

to break

following section presents a simple tangle-like program that will

noweb syntax we've

you

how you approach both code

flexibility in

Tangling code

because

at

along chapter or section boundaries or whatever works best for pre-

files

freedom and

file

source code for a sys-

produced by the tangling process. Instead, you might choose sources into

(though

below in section 9.3.1 does only operate on one

to use multiple files

file

installing the actual

of the things you've learned in

a couple of new fianctions

you

haven't seen yet.

A simple tangler

9.3.1

Now that we know what the chunk definition and the

reference syntax are,

we can

build a limited tangler program to allow us to write our Perl programs using

noweb

'

intermixing code chunks and documentation chunks (we are in a

s syntax,

documentation chunk

right

now) throughout the source

We want our tangler to operate similarly to specify the root ferences.

it

to a

name you want

file

yourself

it.

The second

difference

root chunks

matically find

all

chunk names.

A root chunk

We

call

is

add two

We assume that the root chunk name

that, if

file

named

is

given, our

to their respective

program files

program outline

also the

(i.e.,

will auto-

based on their

any chunk not used inside another chunk

initial

is

running our tangler program

blah and writes the tangled code

no -R option

and print them

dif-

STDOUT so you

our tangler pqtangle for Perl Quick Tangier and write

named pqtangle. nw. Our

170

is

We

prints the tangled code to

to use for the tangled code. So,

with a root option of -Rblah creates a to

notangle, allowing a -R option to

a -l option to include line directives.

The notangle program simply

have to redirect file

chunk and

file.

definition. it

in a

our root chunk) looks

CHAPTER

9

file

like

DOCUMENTATION

— «pqtangle»= /usr/bin/perl -w use strict; >\s*$/

,:[;

;

}

push

@

{

$chunks { $1 }

}

,

"

$begin_of f set $f lie $line_no " :

:

(a

^

'-:v

When we finished reading through the chunk, we used the autovivification syntax to

push a

tion of the that are

string containing the byte offset,

chunk we

inside the inner

At

matched

while loop was

this point,

starts in the file

the one

we know

and the

line

number informa-

line

%chunks hash contains keys

values hold an array of offset/ information strings for

every location where that chunk's definition is

name, and

just parsed. In other words, the

chunk names and keys

$1 variable here

file

is

continued throughout the

which

is

now out

of scope.

the byte offset location where every

chunk

number of the

chunk

first

code

The

The one matched

in the outer if statement.

localized to that block

file.

line in that

definition definition.

We also have a record of every chunk used in another chunk and, hence, every chunk that cannot be a root chunk. We now populate our ©roots array with the root chunks we need to root

chunk name

the root chunks. since the keys are

@roots array =

($Root)

©roots

{

=

($Root)

TANGLING CODE

173

;

}

:

;

;

else { foreach my Skey (keys %chunks) { push @roots, $key if not $used{ $key) }

}

@

Printing out the root chunks for each root

do

is

simply a matter of opening a

chunk name and printing out

>= my $shebang_special = 0; $shebang_special = 1 if $line =~ m/^#!/; @

At

we need

this point,

Hne

to create a formatted

directive, substituting the

we used in the $Line_dir variable. We format this line directive in a separate function. Then we need to print out this line directive, but only if the current line is not a shebang line, or an embedded chunk reference. In those cases, we would want to print a line directive when processing that chunk.) We use a simple set of logical ORs that terminates at the first true expression, and thus only prints out the line directive when needed: correct information for the placeholders

= my $line_dir; if

($Line_dir) { $line_dir = make_line_dir $line_nijmber $f ilename) $line =~ m/"\s*>\s*$/ || $shebang_special print PROGRAM $line_dir "

;

,

(

.

|

|

"

,',

;

,

,

'

}

• .

we have

Since

and define our

it

literate

,

,

here.

just

used the make_line_dir

This example also

(

illustrates the

. ,

function,

)

we should go ahead

point about being able to write

source in the order that makes sense for discussion.

First, let's

add

to

the subroutine definitions chunk:

=

Now

the function to format our line directive

operations. file

'

The

function

is

$line_dir variable and assign

variable,

which holds the

to lexical variables.

it

of substitution

number and

the

We then declare a new

the value of our file-scoped $Line_dir

line directive string

with placeholders.

replace the placeholders with their proper values

$line_dir

a simple set

passed parameters for the current line

name, which we immediately assign

lexical

is

Finally,

we simply

and return the value of the

variable:

«suJb make_line_dir>>= sub make_line_dir {

176

CHAPTER

9

DOCUMENTATION

;

;

my $line_no, $f ile) = @_; my $line_dir = $Line_dir; $line_dir =~ s/\%L/$line_no/ $line_dir =~ s/\%F/$f ile/ $line_dir =~ s/\%\%/%/; $line_dir =~ s/\%N/\n/; return $line_dir;

;

' ;

(

-

,

—

;

' .

,

}

@

In order to tangle out our chunk,

ing the chunks in the line

first

That

place.

we is,

when

use a loop similar to that used

we

does not match a chunk terminating

pars-

continually loop as long as the current

We

line.

must make

sure

we

read in

we would be looping forever on the same line. Inside the loop, the current line might be an embedded chunk reference, in which case we need to tangle out that embedded chunk. Note, we are capturing the leading whitespace if there is an embedded chunk reference, as another line in both blocks of the if /else statement or

well as the it

chunk name

—

way we can

this

call

print_chunk

the

a string representing the current indentation level so

appropriate indentation. If the line does not contain a the code line (and print out a line directive following

)

(

routine and pass

our tangled code has the

chunk reference, we will it

if it

was a shebang

print

line):

«tangle out current chunk>>= while ($line if

}

~ m/ " \@\s*$ \@\s\%def / { ($line =~ m/ \s* ?).

is

\u$l/g

/

is

—and

replace the

matched

uppercase. Let's assume the

letter in

can simply rename

letter

text

^which

is

captured

with a space, followed

document

this file as article. html.bak

—

is

in a

file

called arti-

and use the following

new version of article, html:

to create a

# /usr/bin/perl -w use strict; opendNPUT, article, html, bak open(OUTPUT, >article.html while () { if m/< [Hh] [l-3]>/ { !

'

'

)

||

'

'

(

)

||

die "can't open file: die "can't open file:

$

$

" !

;

!

"

)

s/

(

[a-z]

)

/

\u$l/g;

}

print OUTPUT $_; }

190

CHAPTER

10

REGULAR EXPRESSIONS

A more command

general version of this

line

and print the

be redirected to another

program would simply read a

resulting output

file

on standard output

given on the

so that

it

could

file:

# /usr/bin/perl -w use strict; while! { if m// { [a-z] / \u$l/g; 8/ !

)

(

'

)

(

.

,

)

'

}

print

•:' ;

}

If

you named

this

program cap_heads, you could run

it

from the

command

line like this:

perl cap_heads article html bak .

.

This way you can use edit the

program

10.2.2 There

to

modify other such documents without having

Character

class

Each of these has

ter class.

We

sho rtcu ts

Table 10.1

their use in chapter 6.

We

Escape sequences for commonly used character classes Description

\w

equivalent

any

to: [a-zA-Z0-9_l, a

to:

word character

an underscore character

letter or digit or

equivalent

[^a-zA-Z0-9_l, a

any character that

is

equivalent

to: [0-9],

\D

equivalent

to: ['^0-9],

equivalent

to:

[

not a

non-word character or underscore

letter, digit,

any single

\d

\s

character

for review:

Escape sequence

\W

commonly used

a variant to stand for the corresponding negated charac-

saw each of these and some examples of

them here

to

to replace the filenames.

are three special escape sequences that stand for

classes.

repeat

it

article.html

>

digit

any non-digit character

\n\f\r\tl,

a

whitespace character

a space, newline, formfeed, return, or tab character

\S

equivalent

10.3

to: [^ \n\f\r\tl, a

Greedy quantifiers: take what you can get

Another greedy quantifier that operates fier.

non-whitespace character

similarly to the star

is

the plus (+) quanti-

This one matches one-or-more of the previous components. You can think of

GREEDY QUANTIFIERS: TAKE WHAT YOU CAN GET

191

;

m/f (o+)bar/ is

the

same

as

as

being the same as m/f (oo*)bar/, in that matching one-or-more

matching one thing, then zero-or-more of the same thing. The pat-

m/fo*bar/ would match against the string fbar, matching and

tern

characters followed

fbar because there

The The

ters.

star

is

plus

is

f

then zero o

by bar. The pattern m/fo+bar/ would not match against

isn't at least

one o following the

f in that string.

an indeterminate quantifier that can match any number of characonly slightly determinate in that

must match

it

at least

one thing,

but could match any number of additional characters. Perl also offers a few other greedy quantifiers with varying degrees of indeterminacy. These are listed in

meaning and an example with an equivalent formula-

table 10.2 along with their

tion using constructs

we

already know:

Greedy quantifiers

Table 10.2 Quantifier

Description

?

match zero-or-one time

m/fo?bar/

equivalent to m/f (ol)bar/

{n}

match exactly

n

times

m/fo{2}bar/

equivalent to m/foobar/

{min,}

match min-or-more times

m/fo{2,}bar/

equivalent to m/foo+bar/

match

max}

{min,

In the All the

at least

first

all

much

grouped alternation means

most max times

)bar/ might seem strange.

(o|

match an o or match nothing.

is

last

greedy quantifiers and will as

at

example above, the equivalent m/f

ordering of the alternatives in the are

min times, but

equivalent to m/f(ooooloooloo)bar/

m/fo{2,4}bar/

7\lso, if

the

example surprised you, remember that these

first

try to

match

as

much

as possible (or as

they are allowed) before trying lesser amounts.

10.4 Non-greedy

quantifiers: take

what you need

Often, greedy quantifiers are simply too greedy for your intended purpose. Consider trying to

match and capture

all

the text

on

a line

up

to the first occurrence of al5:

$line = "one two three al5 four five six al5 sevenVn" $line =~ m/ .*)al5/; print "$l\n"; # prints: one two three al5 four five six (

What happened? The string

192

star

and then backtracked

is

until

greedy and matched

an al5 could match.

CHAPTER

10

all

the

way

to the

What we need

is

end of the something

REGULAR EXPRESSIONS

;

that will it

match

matches

as little as possible

and then check the

of the expression to see

of the greedy quantifiers have a non-greedy form that

yet. All

the quantifier followed by a question mark.

now

rest

if

simply

is

A revised version of our example above

using a non-greedy star quantifier would be

$line

=

"one two three al5 four five six al5 sevenXn"

$line =~ m/

.

(

print "$l\n";

The

i

(

.

*?)al5/; #

prints: one two three

*?) tries to

acter followed

match zero

characters followed by an al5, then

by an al5, and so on

until

it

finally

one char-

matches fourteen characters one

three and succeeds in finding a following al5. The other non-greedy ver-

two

and operate

sions of the quantifiers are given in figure 10.1

10.5

in a similar manner.

Simple anchors

An anchor is

a

form of zero-width

This means

assertion.

matches not a character,

it

but a position with certain properties. You have already seen two such elements in chapter 6: the

can be used to match

(caret)

can be used to match the end of a you've already seen

string.

at the

beginning of a

string,

and the

$

Another anchor type regex element that

the word-boundary element \b. This matches at a position

is

between a word character (\w) and a non-word character (\w.) or between the beginning or end of a string and a \w character. To get an idea of what

match a position

rather than a character,

let's

it

means

to

consider another simple example

depicted graphically.

we

In figure 10.5 strings foo

(between the

step through

running the pattern m/\bfoo\b/ against the

bar and foodbar. At step start

of the string and the

1,

\b matches at the start of the string

f character) in

both

cases.

Because

this

zero-width assertion, the pointer remains pointing at the same position in the get string. In order to

on

the string,

first

show

we advance

the regex

components

in the place

the pointer to the next regex

component down below the

regex.

This

is

simply

\b and the f regex element both are successful at the

The

pointer then advances along in the usual

hit the final \b. In the first case, there

the o

and the space

is

a

is

word-boundary

In the second string, the position

lies

again a

a

tar-

where they match

component but drop

the

my way of showing that the

first

position in the string.

manner

in each string until

we

match because the position between

position.

Thus

the regex succeeds at step 6.

between an o and a

d,

which

characters, so the regex fails at this point. (Note: although not

SIMPLE ANCHORS

is

are

shown

both word

in the figure.

193

\b]»

EHa0 0 H

oj

TjiTopTolalu

a

b

0

Jo

-{iHo}QD{b}S& failure

Figure 10.5

Stepping through a pattern match with anchors

the pointer

would return

attempt to match the

first

to the

component

The word-boundary anchor at a position in a string

When on

a

beginning and the whole regex would repeatedly

has a complement, the \B anchor, which matches

between two word characters or two non-word characters.

the /m modifier (we will discuss modifiers in the next chapter)

match or substitution operator

at the start

against every position in the string.)

and end of

lines

means

it

within a multi-line string.

match only the beginning and end of a is

and

that the

$

is

used

anchors can match

The \A and

string respectively, regardless

\z anchors

of whether

it

a multi-line string or not.

The

final

simple anchor

the /g modifier

is

the \G anchor, which works in conjunction with

and anchors the match

to the last position

matched

in a repeated

match operation.

194

CHAPTER

10

REGULAR EXPRESSIONS

10.6 Until

and backreferences

Groupingy capturingy

now we

have only used plain parentheses for grouping subexpressions.

disadvantage of this technique expression

that anything

is

captured and assigned to a special variable based on the position of

is

and memory

the parentheses in the overall expression. This takes extra time

you

regex machinery, and, often,

capturing

its

expression

is

matching the

(?:

A

text.

form of parenthesization that

matched

for the

grouping a subpattern, not

are only interested in

subexpression) form. For example,

ested in capturing the

would

The

matched by the parenthesized sub-

will

only group an

you

are not inter-

if

the earlier example using m/f (u oo)bar/

text,

|

be better written as m/f(?:u oo) bar/. I

When capturing parentheses are used, cial variables

$3

$2,

($1,

.

.

.

the captured text

where the

)

(xyz)

/

the string foobarbaz, $2

These

string xyz.

left

to

would contain the

variables

may

string bar,

and $3 would contain the

be used within the replacement part of a substitu-

These

from within

strings

is

exited.

another pattern match successfully matches or the

This

is

useful for extracting particular bits of data

of text. (We saw examples of this sort of thing in chapter

Using capturing parentheses in

a pattern also

same pattern using the

able later within the

approach to searching a

for

file

tern such as m/\b(\w+) \s+\l\b/i. This

makes the captured

back to previously matched

multi-line strings

string to read a

words even line.

if

one

This

Remember

file

is

—such

characters, followed

at the

as

when

we

tells

the special $/ variable

end of one

possible because

line

we used

line

and the other

is

at the

word boundary following

backreferenced text here

is

the

match opera-

set to still

an empty

catch double

beginning of the

the \s sequence instead of just a space.

that the \s sequence represents the character class

placed a

is

—we can

two words may be separated by one or more of any of those that

[

\n\f \r\t] so the

characters. Also note

the backreference. This ensures that the

not simply the beginning of a larger word such

perfectly logical string This

a

by whatever word

catch doubled words that might differ in case. If used

by paragraphs instead of line by

is

text.

double words would be to use a pat-

was matched by the capturing parentheses. The /i modifier

we can

text avail-

would match something resembling

word followed by one-or-more whitespace tor to ignore case so

6.)

... escape sequences.

\3

\2,

\1,

are called backreferences because they refer

A simplistic

next

special variables

but automatically localized within their immediate enclosing block. They

current scope or block

on

pattern m/

did match against a target string, then $1 would contain

will retain their values until either

These

If the

right.

tion or in statements following a successful pattern match. are global,

of occurrence of

digits reflect the order

the subexpressions themselves counting from

(foo (bar)baz)

stored in a set of spe-

is

as in the

thistle is bristly.

GROUPING, CAPTURING, AND BACKREFERENCES

195

;

A

program that makes use of

this pattern to locate

doubled words and to highlight them somehow can be #

!

as

paragraphs containing

simple as

/usr/bin/perl -w

use strict; =

$/

";

read files in paragraph mode

#

while { print if s/ \b \w+ (

)

(

(

)

\s+

\1

(

)

\b/ * $1*$2 * $3 * /gi

)

}

We captured the first occurrence of the word, the second occurrence of the

word

into three separate variables so

the text with a few asterisks inserted to also

used the /g so that

we could

the intervening whitespace, and

make

the doubled

we could

words stand

replace

out.

We

highlight multiple occurrences of doubled words

within a paragraph. Jeffrey Friedl gives a more involved version of this program in his

book^ that allows an intervening tag such

bled words, uses

ANSI

an

HTML tag and

escapes to highlight the text,

lighted lines rather than the

improvements

as

whole paragraph. You

between the dou-

prints out only high-

encouraged to add similar

are

above version of the program.

to the

Prime number regex

10.6.1

we developed a program to list all the prime numbers from 2 to N (where N was a number entered by the user of the program). That program was straightforward and relatively efficient. Here we will show another program to list Back

in chapter 5,

prime numbers, one that

is

neither straightforward nor efficient, but nonetheless a

marvelous example of something (of what we're just not If

you

visit

and search the comp.lang.perl.misc

http://www.dejanews.com

archives for the terms "Abigail"

and "prime,"

you'll eventually find a rather surpris-

ing usage of regular expressions to determine if a given a frequent poster to the comp.lang.perl.misc (as far as

I

know)

as a clever little one-line

natures. Since then,

sions

it

and with a few

you search the

has been

archives.

primes from 2 to

N

The

(where

/usr/bin/perl -w use strict; my $N = shift @ARGV;

N

you

following is

number

newsgroup and

program

in

this

is

the group

are sure to find quite a is

prime. Abigail

is

example originated

one of Abigail's sign-off sig-

commented on within

variations, so

sure).

on

few

a

few occa-

articles

an extended version that

when

lists all

the

an argument to the program):

#!

1

Friedl, Jeffrey.

196

#

get the number

Mastering Regular Expressions. Sebastopol, CA: O'Reilly and Associates,

CHAPTER

10

1

997.

REGULAR EXPRESSIONS

;

(my $number = 2; $number my ($dir, $file) = / # default initial path $dir 11= return ($dir, $file) (

'

.

'

)

;

}

This version version

is

a

much

is

little faster

simpler overall.

A quick benchmark shows

that the

first

(around 18%) than the regex version. So unless you were

going to be doing a large number of such operations, the simplicity of the regex version probably outweighs any efficiency concerns your program might have.

The substrO data

files

—

files

function

where each

is

also

field

commonly used

of data

starts in the

the same width for every line (or record) in the

might be a better choice

this type

character group designation followed by

and

3.

We

file.

is

(The unpack {) function

fields.

The

data consists of a four-

measurement data with

have already identified

fields

field

occurs.

Now we simply want

print as comma-separated data for use in another program:

to extract only the

widths of 2,

where missing data

we will

# /usr/bin/perl -w use strict; while () chomp my ©fields = (substr($_ substr $_ substr $_ substr ($_

column

of task though.) In the following example, we

have some fixed column data with a few missing

3, 3, 2, 3, 2, 2, 2, 2,

to pick apart fixed

same column position and

columns of complete

data,

which

!

(

(

)

0,

4)

,

9,

3)

,

17,

2)

25,

3)

substr 4, substr $_, 14, substr $_, 21,

2)

,

(

3;

(

2;

;

print join(',', ©fields print \n" "

}

DATA 120B2212 110622 116953 13 632101 1021911793 3929090 220b26 220b29125111 118952934 096 220bl81231182811596233 63 0093 140D2611810821112882831 092 140D23 1062011291293833096

An

interesting thing

function:

you do not

happens when you take a reference to the substr

get a reference to the literal substring

itself,

()

but to the given

region of the string:

my $string = 'foobar'; $ref = \substr $string, print $$ref \n" (

"

210

1,

4); #

prints

:

ooba

CHAPTER

11

WORKING WITH TEXT

.

$string = 'scoolly' print "$$ref\n";

prints: cool

#

Here, the reference in $ref

.

not to the particular substring ooba, but to the

is

four-character shce of $string, starting at position after

we

new string to of this new string.

11.4

second character). So,

now

$string, our reference

assign a

character shce

(the

1

refers to the four-

Translating characters

Another situation that often operation

is

and seems hke a good choice

arises

translating characters.

string into underscores.

One

Assume you want

obvious method

is

to

for a substitution

change

spaces in a

all

to use the substitution operator

with the /g modifier: $_ = 'this is a string'; /_/g; print; # prints: s/

'

-

'

;

•

"

-

this_is_a_string

"

The

translation operator (tr//) accomplishes the

same

task:

'this is a string'; tr/ /_/;

$_ =

print;

#

The

first

prints: this_is_a_string

thing to realize about the tr// operator

first

part as a regular expression:

first

part

is

a

list

treats

is

both portions

that

it

as lists

does not treat the

of characters.

of characters for which to search, and the second part

The

a corre-

is

of replacement characters: tr/SEARCHLiST/REPLACEMENTLlST/. By

sponding

list

default,

operates

it

it

on the $_

variable,

but

it

can be bound to any variable using

the binding operator:

tr/abc/cab/; tr/a-z/A-Z/;

# # #

replace a with c, b with a, and c with b. replace lower case letters with corresponding uppercase letters

$string =~ tr/A-Z/Z-A/;

# # #

You can

replace upper case letters in $string with their counterparts in a reversed alphabet

use this as an easy

method of doing

encoding scheme where the alphabet

maps

that a

rotl3

(

)

to

n and b maps

to o

is

ROT 13

—

encoding

a simple

divided into two halves and swapped so

and

function to encrypt a string, then

vice versa. call it

You can

again

call

the following

on the encrypted

string to

get the original text back:

TRANS LA TING CHARA CTERS

211

;

sub rotl3 { my $ string = shift; $string =~ tr/a-zA-Z/n-za-mN-ZA-M/ return $string; }

The tr// found. is

When

the replacement hst

replicated as the replacement

$count

tr/a//;

=

#

tr/aeiouAEIOU/ /

=

When ter

;

the replacement

of the replacement

tr/a-z/ABC/

This allows you to count characters in a

string:

$count gets number of 'a' characters in $_ $count gets number of vowels in $_

list is

it

are used, the search hst

'

shorter than the searchlist, then the last charac-

repeated to equalize the two

lists:

b to B, c to C and all other lowercase letters translate to C as well

a to A,

#

;

list is

#

characters in the search hst that

empty and no modifiers

is

list.

#

$count

number of

function returns the

#

Three modifiers may be used with the tr// operator,

in the

same way that

modifiers are used with the match and substitution operators: /c, /d, and /s

(which stand for complement, delete, and squash, respectively).

The

/c modifier

words, the

list

that, instead

same

of

all

means

that the searchlist

size as the searchlist, all list

taken as a complement

characters not in the given searchlist.

of replicating the

the replacement

is

last

The /d

character in the replacement

—

in other

modifier means

list

until

it is

the

matching characters that do not have a counterpart in

are deleted

from the

target string.

The

/s modifier

means

to

squash consecutive matching characters with one copy of the replacement character.

tr/aeiou/ * /c tr/aeiou/x/d; tr/aeiou/ /cd;

#

lis;

#

;

tr/

I

sions.

a

would

The

# #

like to stress again that the

row followed by

1

a

a b with xyz.

It

replaces each a with an x, each asterisk with a y,

z.

Exercises

Write a function that returns a such case

tr/ / operator does not use regular expres-

expression tr/a*b/xyz/ does not replace zero-or-more a characters in

and each b with

11.5

replace all non-vowels with an asterisk replace a with x and delete all other vowels delete all non-vowels replace consecutive spaces with a single space

as:

"The the way

list

of all doubled words (two words repeated

to...") in a string.

A doubled word may have different

and be separated by any amount of whitespace including an embedded

newline.

212

CHAPTER

11

WORKING WITH TEXT

2

Write a regex to substitute every occurence of the word apple with orange only

if is

followed by a space and the word peel.

Do

not change the apple in

pineapple. 3

Write a function that prints out a summary of the frequencies of each vowel in a string. For example, if passed the string

discontent, a e

3

o

3

u

1

it

would

This is the winter of our

print:

0

14

EXERCISES

213

CHAPTER Working with

lists

215

12.1

Processing a

12.2

Filtering a

12.3

Sorting

12.4

Chaining functions

12.5

Reverse revisited

12.6

Exercises

list

217

list

lists

217 221

223

224

214

12

;

an important and powerfijl feature of the Perl language, so

Lists are as

no

surprise that, just as with strings, Perl has a

few

list

it

should come

manipulation tools up

its

sleeve.

In earlier chapters, we've seen the essential built-in functions for working

with

arrays

and

to

name

exists

(

joining

,

lists

chapter, list

)

we

—

popO,

a

as well as a

shift

examine a few

map

grep

)

,

uses of the

reverse

(

12,1

Processing a

(

(

)

,

()

functions.

( )

We

more

will also consider

function.

)

(

-

-

list action

on each

;

This should probably be your

first

choice

•

_

when you need

,

.

ele-

^

'

)

}

to create a

this

built-in functions designed explicitly for processing

and sort

©list foreach my $item { # do something with $item

it

making or

for

and joinO functions. In

The standard way to process a list of data, or to perform some ment of a list, is to iterate through the list in a f oreach loop:

data, but

keysO,

unshiftO,

(),

few functions and operators

the range operator, and the split

will

data: the

—pushO, few—

hashes

-

.

to process a

-S-'-

of

list

does have certain limitations. Consider a simple case where you want

new

array that contains the value of each element of an existing array

multiplied by a factor of two:

my @list =(1,2,3); my @new_list; foreach my $item @list push @new_list, $item (

print "@list\n"; print "@new_list\n"

The map

(

)

# ;

#

.

{

)

*

2

;

prints: prints:

_

12

3

4

6

2

,

function allows us write the preceding code

assignment from one

list

more

directly as a

list

to another:

my ©list = (1, 2, 3 my @new_list = map $_ * 2 ©list; print "(ilistXn"; # prints: 12 print (anew_list\n" # prints: 2 4 )

,

"

The map

;

{

)

3 6

function has two basic forms:

map BLOCK LIST map EXPR, LIST

PROCESSING A LIST

215

:

The block

or expression

is

evaluated once for each element in the

ment, and the return of the hinction

Each time the block or expression value in the is

is

evaluated, the $_ variable

is

an

of each such evaluation's

list

the element in the

alias to

set to the

is

list,

argu-

results.

current

but changing

it

not recommended under most circumstances.)

When

a block

curly braces)

following

first

argument

(a series

you do not use

comma

a

is

of statements enclosed in

the value of the

last

statement

between the block argument and the

list:

@new_list

map

=

The map

(

)

{

alias to

*

$_

this

@list;

2}

may

function

how you might do an

used as the

is

the return value of each evaluation

,

in the block. Also,

is

$_

(Actually,

list.

the

is

list

be used to transform a

also

f oreach

with a

the current element in the

in place.

list

loop (remembering that the loop variable list):

.

^

=(1,2,3);

my ©list

foreach my Sitem $item *= 2;

.

#

©list { same as: $item = $item

#

prints:

(

Consider

)

*

"i

2;

:

}

print "@list\n";

2

4

6

. , ,

It is

hide the

more

not wise to use real object

map {$_ print "@list\n";

*

In this version, value that

is

is

(

receives in the

)

isn't

list; it

#

prints:

it

is

-,

2

4

...

.,

:

6

,

perfectly clear that list

@list

is

being assigned a

new

list

value.

limited to returning just a single element for each element

can return a scalar or a

=

qw/one two three/;

=

map

{

'"

~' '

from an array where each array element @key_list my %hash

array:

.

a modification of its previous

The map

)

,

©list;

2}

(

unmistakably changing the contents of the

=(1,2,3);

=

much because it can tend to function allows a The map

too

of the code in the indirection.

direct assignment that

my ©list @list

this "aliasing" feature

,,

,

$_ =>

This also has the

1

effect

}

of

is

list

value.

Consider

initializing a

it

hash

taken to be a key and given a value of

1

@key_list;

filtering

out any duplicate elements in the key

list

array because there can be only one of each key in a hash.

216

CHAPTER

12

WORKING WITH LISTS

Filtering a

12.2

list

Often we don't want to process a

ments that meet some grep

(

criteria.

we want

list;

Another

to filter

—

it

that

get

is,

ftinction, similar in syntax to

map

(

,

)

the

is

ftinction:

)

grep BLOCK LIST grep EXPR, LIST

' '

Unlike the map

element in the

list,

ftinction,

)

(

which returns

a value (or a

in turn.)

This function

is

list

of values)

ft)r

every

of elements for which the block or

this ftinction returns the list

expression evaluates to true. (Again, the $_ variable list

the ele-

all

commonly used with

is

assigned to each value in the

a regular expression as

its first

argument:

my @list = qw/one two three four/; my @new_list = grep m/'^t/, ©list; print ©new_list\n" # prints: two three "

;

Think of grep

(

)

as a filter that allows

through only things that pass a

the case above, only those elements for which the regex m/'^t/

ments that grep

(

start )

with a t

—

are passed

by no means limited

is

of the standard

FAQ answers

through to the new

unique elements in an

element.

The grep

{

)

filter

ele-

:

array:

,

'

•

create a hash to

— those

argument. Here's one

my @array = qw/one two two three four three two/; my %seen; my ©unique = grep {! $seen{$_}++} ©array; print "@unique\n";

Here we use the block form and

true

In

list.

to using a regex as a first

for extracting the

is

test.

_

count occurrences of each

here allows only those elements that

we have not

seen

already.

12.3

Sorting

Perl's built-in

sort

(

)

lists

function

is

versatile,

allowing you to supply a function (or

block) that performs the comparisons or simply to use the default comparison routine,

which

uses stringwise comparisons.

The

basic

form of the function

is

sort SUBNAME LIST sort BLOCK LIST sort LIST

SORTING LISTS

217

To

an array of strings, you can simply use the default sorting routine:

sort

©list = qw/one two three four five/; ©list = sort ©list; print "@list\n"; # prints: five four one three two

When

you want

how sorting

is

to provide a different sorting

accomplished.

Any sorting method must compare two

time to each other and determine or equal to the second element. care of figuring out

When

time. pairs

which

if

the

first

element

While sorting the

pairs

element

is

is

list,

the sort

you supply a comparison method, the sortO

-1 if the first

is

method using

elements

at a

(

)

function takes at

any given

fianction places these

Your comparison function

smaller, 0 if they are equal,

(remember the cmp and

larger

the default sort

element

$b.

to realize

larger than, smaller than,

of elements need to be compared

of elements into the localized variables $a and

must return

method you need

and

1

if

the

first

operators). For example, to duplicate

stringwise comparison,

you could use

©list = qw/one two three four five/; ©list = sort { $a cmp $b } ©list; print "©list\n";

And,

to

do

it

as a subroutine,

you could use

©list = qw/one two three four five/; ©list = sort stringwise ©list; print "©list\n"; sub stringwise $a cmp $b;

" ' '

•

"

{

}

To ©list

sort a

list

numerically,

you would use

=(3,4,2,9,1);

= sort { $a $b } ©list; print "@list\n"; # prints: 12

©list

To

3

4

9

reverse the sense of the sort order,

you simply swap the two

special sort

variables:

©list = (3, 4, 2, 9, 1) ©list = sort { $b $a } ©list; print "©list\n"; # prints: 9 4 ;

218

3

2

1

CHAPTER

12

WORKING WITH

LISTS

5

9

;

As you know, the keys often

want

to retrieve

;

in a hash are not stored in

them

in

some

any particular order, but you

sorted fashion:

Andrew => 35, Sue => my %fainily = foreach my $key (sort keys %family) print $key is $f amily{ $key} \n"

39,

(

Joseph => 14, Thomas =>

7

)

;

{

"

}

END this prints:

Andrew is 3 5 Joseph is 14 Sue is 3 9 Thomas is

'• 35, Sue => 39, Joseph => 14, Thomas => foreach my $key sort $f amily { $b} $f amily { $a} } keys %fainily) print "$key is $f amily $key} \n" {

(

..,.(.;.',

{

7

)

{

{

}

.,

END this prints Sue is 3 9 Andrew is 3 5 Joseph is 14 Thomas is 7

-

J •

:

r

-

.. ,

.

Sometimes, there

is

more than one

Consider a colon-separated data to sort

age

by

last

name, then by

file

first

field in the

of first names,

name

(if

the

last

data that you wish to sort.

last

names and

names

ages.

We

want

are equal), and, lastly,

by

(if all else is equal):

'

# /usr/bin/perl -w use strict; my Odata = ; my ©sorted = sort myway @data; print @sorted; !

sub myway { (split /:/,

$a) [1]

cmp (split /:/, I

(split /:/,

$a) [0]

(split /:/,

$a) [2]

$b)[l]

I

cmp I

;

(split /:/,

$b)[0]

(split /:/,

$b)[2]

i

}

DATA Sue Johnson :

:

3

Andrew Johnson Bill Jones 37 Bill Jones 3 6 Mike Hammer 45 :

:

:

:

:

:

:

3

:

SORTING LISTS

219

|

This makes use of a (or take a slice of) a

use of the

list

(logical |

list facility

just as

OR)

you can with an

array.

you can

The example above

entire function

OR'd

expressions that are

(cmp returns zero), the expression

on

The

operator.

discussed yet:

is

subscript

is false,

elements of the pair of lists (the

to numerically

the data into

split

and we do the next expression

first

names). Again,

compare the third element of the

if

compare

to

pair of lists (age).

The

opera|

of the

com-

first

comparisons are equal.

if all

not a very efficient way to perform such multiple

is

we go

they are equal,

tor short circuits (see chapter 5) so this subroutine returns the result

parison that does not return zero or returns zero

lists

pair of lists. If they are equal

|

This

makes

also

a single Perl statement

we

together. First,

and compare the second elements of that

at the colons

first

we have not

|

made up of three

the

that

comparisons.

field

For every pair of elements that need to be compared (which can be a large number of comparisons), we are performing between two and can greatly improve this

if

by each element of those

we

split

on the

six splits

anonymous

the data once into

We

data.

then sort

arrays,

arrays:

# /usr/bin/perl -w use strict; my ©data = ; my ©sorted; ©sorted = map { [$_, split /:/] } ©data; ©sorted = sort myway ©sorted; ©sorted = map { $_->[0] ) ©sorted; print ©sorted; !

sub myway { $a->[2] cmp $b->[2] $a->[l] cmp $b->[l] $a->[3] < = > $b->[3]

'

•

'

'"' '

. -

.

-

..

.

.

.

|

'

'

II

.

_

'

;

.

...

}

DATA Sue: Johnson: 39

Andrew Johnson Bill Jones 37 Bill Jones 36 Mike Hammer 45 :

:

:

:

:

...

:

35 ;

,,.

.

^

—

,

,

,

.

,

,

,,

In this example, we've

first

array for each line of data. This first

element, and the

next three array.

.

.

.;

:

:

the

> '

fields.

The

list

used the map

anonymous

of fields (the

resulting

list

(

)

function to create an

array contains the actual line of data as

result

of splitting the

of anonymous arrays

We then sort this array of anonymous arrays

is

in the

line

of data)

myway

(

)

sub, dereferenc-

we want to compare. Finally, we extract just ment of each anonymous array (the data line itself) in another map {

©sorted array contains

just the lines

of data

as the

assigned to the @sorted

ing each particular field

that the final

anonymous

now

)

the

first ele-

function so

in the sorted order

we wanted.

220

CHAPTER

12

WORKING WITH

IISTS

Chaining functions

12.4

.

i

1

One

of the most famous Perl idioms

after

Randal Schwartz. The Schwartzian Transform implements the sorting idea

called the "Schwartzian Transform,"

is

named

above in a more compact fashion by chaining the three map, sort, map operations

we

together into a single statement. Before

what chaining

sider

Chaining

is

tackle that particular idiom,

con-

let's

in the first place.

is

simply using the

results

of one operation or ftinction

work through

into another operation or function. Try to

as the

input

the following simple

example:

/usr/bin/perl -w use strict; my ©unique; my %seen; while! { #

'

!

';

'/.J.;:,-

^

v

,

;

•

)

chomp;

push ©unique, grep

$seen{ $_} ++

!

,

split

'

';

}

print "@unique\n"; DATA this is one line of data this is another line of data this is the last line of data

You might have guessed words three

'

that this

program

creates

an array of

how

works?

We

see

chained statement more understandable for a

push

(

grep

©unique,

Looked into

and a

resulting

it

(

!

at this way, the

list

push

(

split(

,

ditional expression

(

and a

function.

)

list.

from the split

()

The

'

the unique

help to

make

the

reading:

')

)

);

function has two arguments: the array to push

)

of things to push into that

from the grep

resulting

$seen {$_}++

first

all

have chained together

may

functions in a single statement. Parentheses

list

,

.

But do you

in the given data.

^

.

array.

The grep

list

(

)

The second argument also has

the

list

two arguments: the con-

argument to the grep

fianction

is

(

)

function

is

the

(using the special case of splitting

list

on

whitespace).

Most

often

you

will

not see chained functions with

all

those parentheses,

let's

look at the original version again:

push ©unique, grep

!

$seen{ $_} ++

CHAINING FUNCTIONS

,

split

'

';

221

9 5

The way one function

5

;

to understand chained functions at a time.

Here we could read grep

hst of words, fiker that hst through the

onto the @unique

Now

let's

is

to read

this in (

Enghsh

right to left

Une into a

as "spht the

and push the resuking

function,

)

them from

hst

array."

consider the Schwartzian Transform and the

method

sorting

last

given above:

#

!

/usr/bin/perl -w

use strict

my ©data

'

;

'

•

:

j,

;

=

my ©sorted

=

map

$_->[0]

{

}

sort myway

map

split /:/]

[$_,

{

Odata;

}

print ©sorted; sub myway

{

cmp $b->[2]

$a->[2]

$a->

[1]

cmp $b->

[1]

$a->

[3]

$b->

[3]

...

'

'

||

I

I

'

_

;

~ '

'

DATA

;

Sue Johnson 3 Andrew Johnson Bill Jones 37 Bill Jones 3 6 Mike Hammer 4 :

:

:

:

:

:

:

:

3 . ,.

.

,

.

^

:

Notice series

:

is

how we

have reversed the order of the map

evaluated from right to

anonymous

array,

then the resulting

myway, and the sorted returns the

first

left. First,

list is

(

calls

)

because the chained

each element of @data

list

is

turned into an

of these anonymous arrays

passed to the leftmost map

element of each anonymous

array.

We

(

)

is

sorted

function, which simply

could have even done the

whole sorting chain using a block instead of a named subroutine: my ©sorted

=

map

$_->[0]

{

sort

}

{

$a->

[2]

cmp $b->

[2]

cmp $b-> [1] $a->[3] $b->[3] $a->

|

|

I

I

[1]

}

map

222

{

[$_,

split /:/]

}

©data;

CHAPTER

12

WORKING WITH

LISTS

;

12.5

Reverse revisited

The reverse

(

function

)

reverse a scalar,

only used

is

context sensitive. While we've only used

you should be aware

that

it

takes a

as its

list

argument.

We

have

like this:

it

$string = 'halb'; $string = reverse $string; print $string; # prints: blah Here, the function expect because catenates

thus far to

it

all

we

taking $string as a one element

is

called

^

list.

It

does what

we

in a scalar context. In scalar context, this function con-

it

of its arguments into a single string and reverses that

string.

Consider

the following: '

©array = 'blah' Oarray = reverse @array; print (aarray\n" # prints: blah (

"

In a

;

context, such as this example, the reverse

list

order of the this,

•

;

)

list,

With

leaving each element unchanged.

the resulting

list is

a

function reverses the

)

(

one element

list

such

as

unchanged:

©array = one two three ©array = reverse ©array; print "©arrayXn"; # prints: three two one $string = reverse ©array; print "$string\n"; # prints: enoowteerht {

'

,

'

'

'

,

'

'

)

But what do you suppose the following

produce?

will

$string = 'halb'; print reverse $string;

The print 0 reverse 0

is

function takes a

performed in a

list

list

context,

—

printed in reverse order. This explains the the conunifyO subroutine in chapter 10. to use the

scalar

{

)

provides a

i.e.,

and the

bug

To

I

single

list

element

context list

—

so the

($string)

is

mentioned previously regarding

get the intended meaning,

function to explicitly put the reverse

(

)

you need

into scalar context:

$string = 'halb'; print scalar reverse $string;

The reverse

(

)

function can be used to print a

file

in reverse order (by lines):

print reverse ;

REVERSE REVISITED

223

;

It

can also be used to invert a hash (so long

unique) to create a

new hash

as the values

of the hash are

that has the values of the former hash as

its

keys and

the keys of the former as the values:

Jan => 1, Feb => 2, Mar => 3, Apr => 4, May => 5, Jun => 6, Jul => 7, Aug => 8, Sep => 9, Oct => 10, Nov => 11, Dec => 12 %num2mon = reverse %inon2nuin; $num2mon{ 3 \n" print " $mon2nuin{Mar } # prints: 3, Mar %mon2nuin =

(

)

}

,

12.6 1

2

224

;

Exercises when

Write a function

that,

by the hash

Write the same thing in one

keys.

given a hash, returns the

Modify the one-line version above

of hash values sorted

line using a

to also filter out

CHAPTER

list

12

map

any value

(

)

less

function.

than 25.

WORKING WITH

LISTS

CHAPTER

13

More I/O commands

13.1

Running

13.2

Reading and writing from/to external commands

13.3

Working with

13.4

Filetest operators

13.5

faqgrep revisited

13.6

Exercises

external

directories

229

230

233

225

228

226 227

)

In chapter 6,

we

buih-in open

(

)

covered the basics of reading from and writing to a function. This

You can

write data.

not the only way for your programs to read or

is

output of external programs, run external pro-

also capture the

grams (which might write data to their contents.

using the

file

files

or elsewhere), and open directories and read

This chapter takes us on a brief foray through these alternate I/O

mechanisms.

Running external commands

13. 1

Running an you are

external

program may not seem

an I/O operation, especially

like

program data or receiving

are not sending that

output. Nevertheless, you

its

communicating with the world outside your program, causing programs

run and, perhaps, data to be read from a

two mechanisms

Perl has

you

and exec

the system 0

(

)

files

or the console.

running external commands or programs when

functions.

difference between the

program

or printed to

to be

immediately interested in capturing the output of those commands:

are not

The

for

file

if

two

to replace the currently

is

Each of these

that the exec

running

Perl

(

will )

run an external program.

function causes the external

program while the system () func-

tion spawns another shell process to run the given

program and waits

for

it

to

complete before continuing. system (' Is ') # runs the 'Is' command and waits for it to complete print "Still runningXn"; # will print when 'Is' finishes ;

exec Is # substitutes 'Is' command for current running script print "Still runningXn"; # will only print if 'Is' failed (

'

We

'

)

;

can detect

failure in a

manner

similar to our tests of the

open

with one significant difference: the system () returns 0 for success

and an

error code for failure.

To

test for failure,

you need

(

)

call,

but

(a false value)

to use the logical &&

operator with the die statement:

system! 'Is') So,

die "hmm,

what happens

'Is'

command failedXn";

to the output

from the command? In both

cases, the stan-

dard filehandles are inherited from the Perl program, and the output goes to STDOUT. In the second example above, as indicated in the comments, the print

statement will not be executed cess has call

if

the exec

(

)

was

successful. Because the

new

pro-

completely replaced the current Perl program, nothing after the exec

(

can be executed.

Why would

you want

to

run external programs using these functions? Well,

even though you can write routines in Perl to do pretty

226

much

anything an external

CHAPTER

13

MORE I/O

;

;

command

On

could do,

it is

Unix systems, there

used for such things

sometimes simpler to

of command

are a variety

file

a large

Perhaps your program

files.

amount of data

and remove duplicate elements from before

like to sort

# code that writes lots of raw data to $tinp_f ile exec ("sort $tinp_file unique > $ f inal_f ile " )

|

commands.

line utilities exist that are often

and finding

as sorting, searching,

has just collected and printed to a

just use the external

that

you would now

exiting the program: ...

#

;

Or, similarly, say you wanted to do the same thing to an existing reading

in

it,

which

case

you would use the system {)

could continue after running the given detail regarding these fianctions

-f

command. The

and how they process

fiinction so

perldocs offer a

their

arguments

system and perldoc -f exec). More often you want

output of external commands.

Let's

look

at

some

file

before

your program little

(see

more

perldoc

to capture or read the

aspects of these last operations.

Reading and writing from/to external

13.2

commands Perl also provides

mechanisms

to

run external commands, to collect or read their

output, or to send data from your Perl program into the standard input of an external

command.

Backtics are the simplest

gram.

The

syntax

is

mechanism

for collecting data

to simply enclose the external

from an external pro-

command

in reverse (or

open-

ing) single quotation marks, also referred to as backtics

$listing ©listing

=

$listing ©listing

=

=

=

'ls\'Is';

#

#

'dir'; 'dir';

# #

$listing has output as single string ©listing has output as array of lines same as above on DOS same as above on DOS

In scalar context, backtics collect as a single string. In list context, the

meaning of "line" Alternately,

open

(

)

is

and return the output of the given command

output

returned as a

is

dependent on the current value of the

you can open

a

file

function by giving an external

list

of lines (where the

special $/ variable).

handle onto an external process using the

command

open(DIR, 'Is I') II die "can't fork: while 0 { chomp print "$_" if -s $_ 5000;

$

followed by a pipe as an argument:

!

"

}

close DIR

II

die "failed $!";

READING AND WRITING FROM/TO EXTERNAL COMMANDS

227

;

Here we open the Is process and pipe one

line at a

it

;

into our

file

;

handle so we can read

time and print only the names of files that are over 5000 bytes in

(see section 13.4).

Note, catching open pipe failures

is

not straightforward

—

size

please

see perlfaqS for a solution to this problem.

We can also open up a whole pipeline of processes, the exec

(

such

as the

one we used

in

example above:

)

open(SORTED, "sort $tmp_file while { print; (

|

uniq

|")

die "can't fork:

||

$

!

"

)

}

close SORTED

||

die "problem with SORTED:

!

$

"

Here we have opened the sort program on the put to the uniq our

utility to

handle so

file

we can

remove duplicate read

by

line

it

file

and,

lines,

$tmp_f lie, piped

finally,

its

out-

piped that output to

line.

This piping mechanism works either way but only one way

at a time.

We can

write data to an external process as well by using a leading pipe symbol:

open{OUT, "I sort

while { print OUT; (

|

uniq

>

$f inal_f ile"

)

die "can't fork:

|

|

$

!

"

)

-

'

-

}

die "problem with OUT: $!";

close OUT I

I

In this case, utility,

tems.

and

The

133

we

our data to the sort command, then to the uniq

are sending

finally redirecting

utilities available

to a

it

file.

These

on your system may

Working with

are standard utilities

on Unix

sys-

differ.

directories

Although we gave a few examples above of using external commands (is or dir) to obtain directory listings, Perl also has a built-in set

reading,

and closing

directories (directory handles)

opendir(DIR, /home/ajohnson my ©listing = readdir DIR; closedir DIR; '

And,

if

use the grep

you wanted (

)

'

)

||

to print out

function to

filter

of functions for opening,

and reading

their contents.

die "can't: $!";

all

the

files

with a

extension,

.txt

the output of the readdir

(

)

you could

function:

opendir(DIR, '/home/ajohnson') || die "can't: $!"; my Olisting = grep /\.txt$/, readdir DIR; closedir DIR;

228

CHAPTER

13

MORE

I/O

;

.

One readdir selves.

;

thing to remember though

(

)

"

;

that the directory entries

is

do not contain leading path information,

Thus, you couldn't try to

just the actual entries

open one of the

just

produced by

them-

because chances are

files

it

doesn't exist in your current directory.

my $dir = /home/aj ohnson/public_html opendir(DIR, $dir) || die "can't: $ my ©listing = grep /\.html$/, readdir DIR; closedir DIR; foreach my $file ©listing die "can't: $ # open(FILE, $file) || # must use full pathname to the file open(FILE, "$dir/$f ile" die "can't: || # more stuff '

'

!

(

)

"

•

'

,.

,

'

{

!

won't work

#

;

"

.

$

)

.

i.-

^

;

!

;

,

,

" ;

,

.

}

Of course, how do we a

file.

really

might be a directory

It

know

(or a

if

the $file in the example above

FIFO or

a socket).

The

filetest

is

really

operators are

often used in conjunction with reading directories to determine what kind of entity a particular directory entry really

13.4

is.

_

Filetest operators

There are

several filetest operators that can

particular directory entry. Table 13.1

used such

tests.

(See

Most of these

test is

on page 230 shows many of

perldoc perlfunc

for the

complete

list

of file

the

commonly

test operators.)

return a simple true or false value and are often used in condi-

tional expressions or

then the

be used to find out information about a

grep

{

expressions. If a filename or

)

file

handle

is

not given,

performed against the filename contained in the default variable

($_):

,

$dir = /home/aj ohnson/bin opendir(DIR, $dir) die "can't: $ " my ©listing = grep -f "$dir/$_", readdir DIR; closedir DIR; '

'

!

|

|

The

-M, -A,

and -c

tests

return an age in days (fractional) relative to the start

of the current program. Therefore, to started,

you could

test

if

As a simple example, tories

(

entries in the

readdir

-m 'filename'
$in-> $max]

-.v-V

'

,

'

"

[

}

($in->[$i], }

$in->[$max]) =

(

$

in-> $max] [

,

$in->[$i]);

'

}

Another simple sorting routine

ment of the

array

and consider

element in the array and insert first

two array elements.

SORTING

We

it it

is

a sorted

into

leave

the insertion sort. Here

it

its

list

of length

1

.

We

correct position in the

where

it is

if it is larger

we

take the

first ele-

then take the second list

comprised of the

than element

1

,

or

we

283

;

put

it

into position

third element position.

14 13 4 13 4 13 4 12 3 3

2

5

2

5

2

5

2

4

5

and move element

by finding

Here

5

1

;

its

1

inserted, inserted, inserted, inserted,

1

4 5 2

position. Similarly,

we add

the

proper position and moving any higher elements up one

are the intermediary results

[$i+l] = $in->[$i];

4

5

>

$val){

(3, 1, 4, 5, 2):

sorted sorted sorted sorted

]

;

$i = $i

-

1;

}

$in->[$i +1]

=

$val;

} }

Our

final

simple sorting algorithm

is

called the bubble sort because larger ele-

ments "bubble up"

to the top (or end) of the array. In this routine,

each element of the

array,

if

the

first

moved

We

element

to the

is

comparing

it

list

and the

rest

continue making such passes until

the array

14 13 4 13 4 13 4 13 4 3

5

is

14 13 4 13 2 12 3

284

Let's

doing

of the array

we

don't

consider one pass

is

so, the largest

slightly closer to

make any swaps

on our

array of (3,

element

is

being sorted.

that indicate that 1, 4, 5, 2):

2

5

2

5

2

5

2

2

5

Now, 3

now sorted.

step through

with the next element and swapping the two

larger than the second. In

end of the

we

5

2

2

5

4

5

4

5

[0];

288

to

the heap while the current element

greater,

and D)

the heap, restoring the heap property

index 0 in the heap

because any nodes further

which child node

C

by one;

needs to be passed two parameters: a reference to

same routine at

is

down through

2),

with,

and the current element

will use this

size

what the implementation of the pushdown

at

To begin

rather than Just assuming

we

size

looping (size

node and decreasing the heap

last

the

for the

we

array.

children nodes and set the

heap until eventually our heap

shown

is

last ele-

no longer a heap because the

elements, and our swap completes the sorting of the array.

pushdown 0 routine

this

in the array.

still

on our new smaller six-element heap.

this smaller

To turn

of the heap-array. This routine uses a

1

current element to the node with which

store

no longer con-

is

not larger than both of its children. To

is

named pushdown

a routine

we

with the

1

decrease the heap size from 7 to 6 so the last element in the array it is

thing to

first

end of the

in the heap, thus putting the largest element at the

sidered as part of the heap, even though

in

an example, we store 7

as

in element 0 of the array because there are seven elements in the heap.

heap-array into a sorted array,

is

build a heap from an input array,

of the heap there. Using the heap in figure 17.3

the size

The

partially sorted.

how we might

how we might produce

that the

is

consider

it is

CHAPTER

.

17

,

ALGORITHMS AND DATA STRUCTURING

{

;

while($i $child] $child++

$heap-> $child+l


[$i] >= $heap-> $child] $heap-> $child] ($heap-> [$i] = $heap-> $child] $heap-> $i $i = $child;

if

(

[

{

)

[

last

}

.

' ]

[

,

,

-.

)

[

,

;

)

}

7

6

-

12

8

10

8

1

2

Figure 17.4

10

6

7

4

9

6

6

4

5

6

7

0

7

4

9

12

6

4

5

6

7

The action

of pushing

6

10

down

8

how we

unshiftO

build

it

into a heap

its size

from the bottom up.

7, 10, 8, 12, 6). Figure 17.5

after unshifting the size

shows

onto the

4

9

12

4

5

6

7

9

7

3

4

4

6

in

12

5

5

7

the heap

the heap-array once

will build a heap-array

take our ordinary array,

7

an element

Now that we know how we will sort figure out

10

8

12

from an ordinary into

Let's

•

its first

it's

built,

array.

we need

To do

0),

consider an array containing

this array in

we

this,

element (element

to

and

(4, 9,

binary tree form and in array form

array.

Obviously, this binary tree does not satisfy the heap property. But you'll note that if

we

call

causes the 7

pushdown

and the 12

(

)

on node

3, the last

small heap. Similarly, calling pushdown

swapped turning 1,

{

)

3 along with

on node 2

it

children

its

causes the 9

that subtree into a proper heap. Finally, calling

the root node, works as

HEAP SORT

Node

to be swapped.

parent node in the structure, this is

now

and the 10

a

to be

pushdown on node

did in our previous example: the 4 in node

1

is

289

{

Array Representation

4 I

shown

Ordinary array

swapped with the 12 now swapped with the 7

we can

Finally,

in

node

in

I

57

heap and array form

in

node 6;

10| 8 |12| 6

I

I

0

Figure 17.5

7

9

12345

7

node 3

3;

is

tested; the

and we have created

4 we

loop to swap the

put in node 3

heap from our original

a

is

array.

construct a heap sort algorithm that sorts an array in place by,

using one loop to build the heap from the bottom up.

first,

just

and

first

Then we

use a second

nodes of the heap, to reduce the heap

last

size,

and

to

restore the

heap property on the new smaller heap that remains. The algorithm,

which

the pushdown

calls

(

shown above,

routine

)

sub heap_sort { my $heap = \@_; unshift @$heap, scalar @_; for (my $i = int $heap-> 0 pushdown $heap, $i) [

(

]

$i >= 1;

2);

/

is

$i--)

{

;

(

}

for{my $i = $heap->[0]; $i >= ($heap->[l], $heap->[$i]) $heap->[0] --; pushdown $heap, 1)

$i--)

2; =

(

$heap-> $i] [

-

;

(

,

-

$heap->[l]); -

.

.

}

shift @$heap;

,,

,

,

.

,

'

'

'

}

'

Earlier

I

said that this sorting routine has a

N

log(base2) N). Well, log(base 2) it

runs in

N

*

h time, where h

is

roughly the height of the heap, so

,000,000, h

is

only 20. Thus,

it is

more underlying work than other tainly not

doing

it

as often:

of benchmarks for various

1000

sizes

*

we can

*

say

the height of the heap. You'll notice that the

is

height of the heap grows slowly relative to N. For 1

running time based on (N

N

= 1000,

h

is

10,

and

easy to see that even if the heap sort

routines, as

1000

is

far

N grows

large, the

more than 1000

for is

heap sort

* 10.

N=

doing is

cer-

A quick series

of arrays of random numbers produced the follow-

ing rough timings:

290

CHA P TER

17

ALGORI THMS A ND DA TA

S TR UC TURING

N = Bubble Took: Insert Took: Select Took: Heap Took:

5

N = Bubble Took: Insert Took: Select Took: Heap Took:

5

N = Bubble Took Insert Took Select Took Heap Took:

0.05 seconds

seconds 0.01 seconds 0.03 seconds 0

.

02

0.18 0.0 6 0.0 6 0.05

seconds seconds seconds seconds

N = 000 19.27 seconds Bubble Took: Insert Took: 4.84 seconds Select Took: 5.2 6 seconds Heap Took: 0.7 6 seconds

0

seconds seconds seconds seconds

4.79 1.21 1.31 0.34

00

N 5000 Bubble Took (way too long) Insert Took 122.11 seconds Select Took 132.48 seconds Heap Took:

4.43 seconds

Of course, The

the goal here was not to create the fastest sort routine in Perl code.

built-in sort

shown

(

function can sort a good deal faster than any of the routines

)

here. (For example, the built-in sort routine sorts a

list

of

size

5000

in

about 0.29 seconds on the same machine that produced the above timings.)

No, the goal of

chapter was to use sorting algorithms as a context to

this

introduce you to alternate ways of structuring your data that can lead to improved algorithms. ter

in

heaps

We

have also touched upon some basic terminology you will encoun-

further studies of abstract data structures

—

as well as

—nodes,

trees,

binary

trees,

an informal introduction to comparing the order of growth of

running times in different algorithms.

We

will

encounter some of these concepts

again in the following chapters.

17.4 1

Exercises

Rewrite the pushdown

(

)

routine to use recursion rather than a while loop to

push an element down the heap. Will the heap sort or 2

3

7\n alternate

way

sorted

built

its

work

in a

make

little

help or hurt the running time of

difference?

to build a

list.

this

heap

is

by insertion

—

recall

how

insertion sort

Write a routine that builds a heap by insertion. This will

bottom up

fashion.

Can you

think of other problems besides sorting where a heap or heap-like

structure

might be

EXERCISES

useful?

291

CHAPTER

18

Object-oriented programming

and abstract data structures OOP?

18.1

What

18.2

OOP in Perl

18.3

Abstract data structures

18.4

Stacks, queues,

18.5

Exercises

is

293 295 301

and linked

314

292

lists

301

— Perhaps you've heard of object-oriented programming (OOP) sometime during the past decade.

You might have heard

haps that

it

is

indeed have

its

that

bunch of horse hooey, or

just a

it is

the greatest productivity advancement since caffeine.

and

share of vocal proponents

detractors. Fortunately,

per-

OOP

does

we can hap-

and make up our own minds.

pily ignore the extremists

This chapter will begin with a brief overview of OOP in general, to give you a feel for

the subject

will settle right

down

OOP

features to begin building classes

our programs. Then

in

we'll use classes

and

We and

objects to cre-

a few well-known abstract data structures.

you

If

are already familiar with the concepts

gramming, you may want

on

few new fancy terms to your vocabulary.

to introduce a

into using Perl's

and using them

objects ate

and

Peri

OOP

(straight to the

references, so, if

POOP

as

were). Perl's

it

you had any trouble understanding

review chapter 8 and the perlref pod-page.

5.00503, there

is

and jump

to skip the next section

makes use of

you might want

to

In recent releases of Perl, version

Entire books could be written about object-oriented

might use

effectively.

it

tutorial

on

Perl's references.

many such books have been written. book you are now reading is also publishing a book

on object-oriented programming using this

book.

rather abbreviated

I tell

programming and how one

In fact, a great

Indeed, the publisher of the

started,

capability

What is OOP?

18.1

time as

OOP

pro-

straight to section 18.2

references,

which provides a short

also a perlreftut,

OOP

and terminology of

you

this

Perl that should

come out around

only so you understand that

and informal introduction

to

OOP

here

I

the

same

can only present a

— enough

to get

you

but not the whole messy enchilada.

To begin

with,

let's

take a look at

some

the terminology that

is

commonly

used in OOP-speak: abstraction, encapsulation, inheritance, and polymorphism. Big words, but not difficult to grasp. We've already touched upon the

when we

discussed functions and subroutines in chapter 7.

turn as they

come up

—

Typically

we

We will discuss

each in

at least so far in this call

book

—we approach

a

programming problem

procedural or one of algorithmic decomposition

identifying the tasks that need to be accomplished to solve the problem. If

is,

are given a

problem, we tend to focus on the verbs in the problem statement

in other words, the actions that

In

some

cases, as

look more closely before

two back

again in the following discussions.

from a perspective we can that

first

we

need

to be

performed on the

data.

with the heap sort routine in the previous chapter,

at the data to consider

how

it

we may

might be organized or structured

decide on a processing approach.

WHAT IS OOP?

293

— )

In an

OOP

approach to a problem, dividing and structuring the data space

a central concern.

We want

to identify the things

is

with which we will be working.

we tend to focus on the nouns in the problem statement and how we might model them using different data structures and functions.

In this case,

back to our childhood and use a few well-known sentences

Let's take a trip

from

book

children's

OO

to illustrate the

who don't remember, you should know that Spot is a

approach.

who

run." For those

or

books,

dog).

program

to

do animation

is

Now let's

say that

we want

to write a

move

start

sketching out a run

(

a picture of Spot around the screen while animating

would need

to

know

quite a lot about

how

represented graphically. Consider that the next page of our story says, "See

Dick run" (Dick two

never read this particular series of

we might immediately

Spot's legs. Obviously, this subroutine

Spot

begin with "See Spot

for an online version of this book.

In a traditional approach,

procedure that would

Let's

legs to

is

a

human). Our run

animate while Spot has

spot_run() and dick_run() or run (spot) messier

still if

—

(

)

won't

four.

Now we

has only

need either two subroutines

or one big run() subroutine called as run (dick)

that contains the code to

we had

work with Dick because he

do

either animation.

Things would get

other creatures that were going to run.

OOP

we might first identify the nouns. Spot and Dick, and their behaviors. In figure 18.1, we show one way we might begin to think about our data types. Notice that in this diagram we have also Looking

at this

from an

perspective,

added category names, "human" and "dog."

Human

Dog

name: Dick

name: Spot

number

number

of legs: 2

runO

barkO runO

jumpO

jumpO

taIkO

Figure 18.1

If we

of legs: 4

Modeling Dick and Spot

have modules that define such data types, then in our main book anima-

we need only use these modules to create a Spot object and a Dick object. Then we can ask each object to run on the appropriate pages of the book. What we have done is created abstractions for our data humans and dogs. We call these abstractions classes. When we use an abstraction to create a specific instance of a thing for example, creating an instance of a Dog, called Spot we tion program,

—

—

call that

We have also used encapsulation here. Each class encapbehaviors of the objects defines. We usually refer to the

instance an object.

sulates the data

294

—

and the

CHAPTER

it

18

OOP AND ABSTRACT DA TA STRUCTURES

data as the attributes or properties of the object, and the behaviors as methods. latter are really just

We

The

ordinary functions.

could have created a more general

tained the "name" and

"number of legs"

could have defined the other two

approach would use inheritance

—

that

is,

and a run

attributes

classes

Mammals

class called

method. Then we

)

Mammals. This

types of

special

as

(

that just con-

each special subtype inherits the proper-

of its parent class. This approach would also involve polymorphism because each

ties

subtype's

run

)

(

method would have

Polymorphism means that children

to be redefined for that particular subtype.

classes

can

alter their properties

and methods so

they are not identical to their parents.

You

can't really appreciate

fiirther ado, let's get

creating a class,

This

until

you

class defines

methods)

it,

so without

back to programming.

this

you

how

are defining a

the data

is

whole new data type

stored,

data type can perform.

how it

using array indices.

You

also

is

accessed,

Think of the

to assign data to particular places in the array later

actually start doing

OOP in Perl

18.2 By

OOP

know several

to use in

and what functions

array data type

and how

hash and access those values

tions defined to

work on

know how important and

The

18.2.1

later.

(i.e.,

—you know how

to access their values again

functions defined to

know how You also know how

shift, push, pop; unshift, splice. Similarly, you pairs to a

your programs.

arrays:

to assign key/value to use several func-

hashes: exists, each, keys, values. useful these data types can be for

work on

And you

already

many purposes.

basics

how do we create a class in Perl? We begin by using the package declaration to define a new namespace, the same way we did when building an ordinary module. So,

This package/ module will contain the definition of our in a

we

file

of the same name

as the

class.

We will store all

this

package but with a .pm extension added, just

as

did for ordinary modules.

package Student;

Here we have

started the definition of a class

vide us with a Student data type.

when making The

first

classes

because

OOP

We

do not have

named to

Student. This will pro-

worry about any exporting

modules should not export anything.

thing this class has to define

is

a

method of

creating a

new Student

we can use in our programs. Such a method is called a constructor method. We can name this method anything we want, but most people prefer to call it new This method will return a reference to the underlying data structure it object that

(

)

.

OOP IN PERL

295

creates.

bless

(

Not just any )

been specially tagged by

reference, but a reference that has

function. This

^/fi-^/w^

mechanism

sub new { my $class = shift; my $self = { } = undef; $self -> {name $self-> { courses } = bless $self, $class; return $self;

OOP capability.

of Perl's

,.

.

.

at the heart

is

Perl's

;

}

[

]

,.

;

'

}

:

When

a constructor

familiar with

the arrow

is

is

invoked using an arrow syntax that

— {Student->new(

'

argl

'

'arg2'))

,

actually passed to the function as the

arguments back one position in the argument have shifted off the vided a couple of this

first

initial

values for a name

hash reference, and returned

it.

By

the package

to a

particular hash reference belongs to the package Student object. If

you

argument

leave off the second

we

before

we

hash, pro-

in this hash, blessed

—

is

it

bless

to the

default to the current package/class, but using the second for other benefits, as

name

new anonymous

Perl will always

it,

soon be very

argument, moving the given

and course key

blessing

you'll

In the constructor above,

list.

name, created a reference

class

—

,

(

know that this now a Student

function,

)

argument

will

it

leaves

room

will see shortly.

We said that a class also defines the behaviors of the object in question, so let's give our Student object the ability to

The

tell

us

who

it is

and what course

it is

taking.

following two functions go in the Student package:

sub name { my $self = shift; $self -> {name} = shift if @_; return $self->{naine} "

'-

'

•

.

•

'.i

^ ,

;

'

'

}

'

' '

sub courses { my $self = shift; = @_ if @_; (a{$self->{courses} return @ { $sel f-> courses }} }

{

-

;

,

}

In Perl,

when you

call

an

object's

method, using the arrow syntax shown

above for the constructor, the object reference first

argument

argument into

to the function. So, in the a variable that

wanted. That variable

296

now

we

usually

itself is

automatically passed as the

two functions above, we

name $self but could

holds the reference to the hash.

CHAPTER

18

shift off the first call

We

anything

we

can access any

OOP AND ABSTRACT DA TA STRUCTURES

;

;

;

value in this hash reference in the usual ways. Above, fields if the

functions are passed arguments, or

ments were passed. Some people prefer

we

we

set the values for these

just return the values if no argu-

and

to create separate functions for setting

retrieving object attributes. If we

have the above package saved in a

statement of just 1

final

chapter 16,

we can

to return a true

;

use this

new

named Student.pm and included a value as we did with our modules in file

data type in a program:

# /usr/bin/perl -w use strict use Student; my $student = Student->new $student->naine Bill Jones'); $student->courses Math 'English'); print $student->naine "\n"; print join(' ', $student->courses !

{

)

"A :

;

'

{

{

'

'

(

)

,

{

We because

)

)

could have also accessed the

we know

#

,

that a student

is

just a

,

"\n";

name

#

prints: Bill Jones prints: Math English

or courses of the student directly

hash reference.

We

$student->{naine} to get the student's name, but this

WTien you use an tions.

object,

you should

access

it

could have said print

is

only through

not a good practice. its

documented func-

This way, the underlying structure of the object can be changed in the future

without affecting your program. Perhaps in the future we Student its

•'

will decide to

an array reference rather than a hash reference.

class to use

change the

We will change

methods accordingly:

package Student; sub new my $ class = shift; my $self = $self->[0] = undef; $self->[l] = []; bless $self, $class; return $self; {

[

]

,

' .

^

}

sub name { my $self = shift; $self->[0] = shift if @_; return $self->[0]; }

sub course { my $self

= shift; (a{$self-> [1] } = ©_ if

return @{$self->

[1]

(a_;

}

}

1;

OOP IN PERL

297

;

;

,

)

)

our programs had been accessing the name and courses of the student

If

by

objects

directly accessing the

hash keys, the programs would no longer work.

However, by only using the documented accessor functions, our programs can continue to work correctly regardless of how

we change

the underlying data struc-

ture in the class:

print $student-> {name} print $student->naine {

)

,

"\n";

#

,

"\n";

#

no longer works still works as advertised

Notice one additional thing about using objects that can be demontrated

with a simple script using our original, hash-based Student

class above:

"

/usr/bin/perl -w use strict; use Student; my $student = Student->new $student->name Bill Jones'); $student->courses Math English my $h_ref = {name => 'Bill Jones', course => 'English'}; #

.

!

.

(

,

)

(

'

(

'

'

print print print print

ence

ref

(

'

'

"$student\n" ref $student "\n"; "$h_ref\n"; ref($h_ref), "\n";

#

;

{

)

#

,

#

#

)

Student=HASH 0x80c44cc Student HASH 0x8 OdlbbO HASH

prints: prints: prints: prints:

(

(

we know the underlying data structure of a Student is a hash reference, we also know that it is not just an ordinary hash referit's a hash reference that also knows what class (package) it belongs. The

You can class

,

see that although

— )

function returns the type of reference for an ordinary reference as well as

the class-name of a blessed reference to create

more general constructor

an object).

(i.e.,

We

can use this information

functions:

package Student; sub new { my $type = shift; my $class = ref ($type) $type; => undef, my $self = name courses => |

|

{

[ ]

'

>

return bless $self,

$class; -

} ,

#

other methods.

.

.

1;

We

can

call this

constructor in the normal fashion or as an object

method

using an existing object:

298

CHAPTER

18

OOP AND ABSTRACT DATA STRUCTURES

;;

my $studentl = Student->new $studentl->name Bill Jones'); my $student2 = $studentl->new (

)

;

-j..,n---r::^[i.:^,

.,

'

{

,

(

important to

It is

of $studentl.

It is

)

realize that

a completely

$student2 in the above example

new

is

(and empty) Student object of

its

$studentl object was only used to access the constructor method.

The

provide any additional parameters to the constructor.

now

tests

whether

existing object. If

ref

(

)

was called using the

was

it

from an

object,

name

or

constructor

if it

method

was called from an

name by

gets the class

it

does not

It

using the

Inheritance

you have

a general class such as our Student class above,

specific classes directly

new

create entire also

called

class

own. The

function.

18.2.2 If

it

not a copy

want a

from

it

you can derive more

using inheritance. This means you do not have to

classes that duplicate parts

of existing

classes. Let's say that

This student

special type of Student to represent a part-time student.

can only be registered for a In Perl,

we implement

maximum

we

of three courses.

inheritance using a special array called the ©ISA array.

This array must be a package global variable, not a

lexical variable so, if

you

are

using the strict pragma inside your class modules, you will have to declare this variable using the

of the

class calls a

use vars pragma

method and

that

will also search start

any

The @ISA

When

©ISA array to

class definition,

array holds the

names

an object of your derived

exist in that object's

classes listed in those packages'

our new Student

from the parent

to inherit.

method does not

Perl searches the classes within the

To

(see below).

from which you want

classes

try to locate that

©ISA arrays

package, then

method.

Perl

as well.

we can simply

inherit everything

class:

package PT_Student; use strict; use Student; use vars '@ISA'; @ISA = qw(Student);

,

1;

We now Student

have a

class.

new

Because

classes listed in the

class called

to find

method

# /usr/bin/perl -w use strict; use PT_Student; my $pt_stud = PT_Student->new

that

is

exactly the

same

as

our

does not define any methods, Perl searches the

this class

©ISA

PT_Student

calls:

!

OOP IN PERL

(

)

299

$pt_stud->naine

'

(

John Smith');

$pt_stud->courses (qw/Math English Biology Chemistry/); $pt_stud->courses print join(' "\n"; '

(

,

You can class,

ance ent

and we

—

we

we want

parent;

course

didn't have to rewrite

But,

don't

,

class

behaves just the same as our Student

new

the code in this

all

PT_Student

want our PT_Student

by creating

this

class.

This

class inherits its functionality

a

new courses

from

inheritits

most three courses

par-

as its

in

its

function for the part time

)

(

is

be exactly the same

class to

to allow a part-time student to have at

We can do

list.

)

PT_Student

see that this

in other words, the

class.

)

student.

sub courses

my $self if

•'; '

•

-

{

=

(@_ > 3)

-

•

shift;

/

,

'

•

{

die "part time students can only have

courses. \n";

3

}else{

@{$self->{course}

}

@_ if @_;

=

"

\

'

}

return @{$self->{courses}

Now

you

,.

.

everything about part-time students

dents, except that if

'

.

;

}

' -

try to set the course

is

the

list

to

part-time student will die with an error message.

same

as that for regular stu-

more than

three courses, the

You might want

thing other than having the student die just for trying to take

more

haps you would only want to issue a warning message and return a

By

redefining the courses

(

)

function,

to

do some-

courses. Per-

false value.

we have used polymorphism

derived class has a slightly different shape, or functionality, than

its

parent

— our

class.

Figure 18.2 shows the relation between the Student and PT_Student classes.

A PT_Student IS A Student with a modified Student

courses

(

)

method.

PT_Student

name: ^ ISA

courses:

nameO coursesO

courses!)

Figure 18.2

300

Relation

between Student and PT_Student

CHAPTER

18

OOP AND ABSTRACT DATA STRUCTURES

Abstract data structures

18.3 In the

last

chapter and the previous sections, you've learned a

think about your data in a more abstract

way

(heaps, trees, students)

we

resenting your data as objects with behaviors. In this section,

Stacksy queuesy programming book

Virtually any

will

both are useful to

is

Even though

know so you

no exception. Stacks

their functionality

structure in

your everyday

life.

perhaps you took

computer programming

free.

is

much

the same as a stack in

Perhaps you have a stack of books lying next to your desk, and this

very book off the top of that stack.

from reading, you might place

When

book back on top of the

this

top. In real

life,

lifting several

you might

books

at a

ing your back or both. single items

also give a

Out

risk

stack

from only the top of the

a break

This describes

things from the

from the bottom, or

toppling your stack or injur-

A stack in the programming world limits you to

placing or

stack.

the operation of adding to a stack as pushing an element

and the removal operation

name

book out of the

time off the top, but you

We generally refer to stack,

try slipping a

you take

stack.

—you only add and remove

the fundamental property of a stack

First

is

Stacks

A stack data

onto a

continue our

can see examples of building

simple objects and better appreciate what Perl gives for

removing

rep-

that even mentions abstract data structures will

are elementary data structures.

largely built into Perl,

18.4.1

and about

to

and linked lists

almost always give examples of stacks and queues. This book

and queues

how

OOP techniques while exploring basic abstract data structures further.

practice with

18.4

about

little

to this ordering

as

popping an element from the

of placement and removal with a

(LIFO). Figure 18.3 depicts the basic stack and push(itenn)

its

stack.

We

stack: Last In,

operations.

popO

stack

Figure 18.3

Graphic representation of a

STACKS, QUEUES,

AND LINKED

stacl
now back to plain, now some bold and bold italic < em> text . And lastly, here is emphasized text containing < em> even more emphasized text, in which case you would probably want the word containing in the previous phrase to be in plain fonts again. :

:

:

you were parsing such

If

when you

hit a tag.

would you switch into nested states

pushing any new

text,

you would not want

What would you do when you

to?

You need

to be able to

state

you enter onto the

hit the

remember

and work your way back out

is

now your

a stack,

Whenever you

hit

is left

state

you move

you can keep

an end

tag,

you

on the top of the

current state.

You may suddenly wonder what already allow this kind of behavior?

many

What

tag?

earlier states as

can simply pop the current state off the stack. Whatever stack

ending

With

again.

stack.

to simply switch states

languages are nothing at

arrays in other languages

is

all

You

all like

this fuss

is

about. Don't

are right; they do.

But

Perl arrays. Usually, all

Perl's arrays

arrays in a great

you can do with

allocate a size for the array, then store

and

retrieve val-

ues using array indices only (no pushing, popping, splicing, or dicing). Perl's arrays are different

and convenient because they can grow or shrink on demand, and they

have the functionality of stacks built right in

as well as

and the functionality of

queues, as you will see shortly.

So do we need to bother with creating our it is

easy to

do and, by doing

so,

viding a size limit to the stack

we

we can add

if

desired

a

own

little

stacks in Perl?

Not

often, but

extra functionality, such as pro-

and automatically producing warnings

if

reach the bottom or top of the stack. Besides, creating stacks gives us a chance

to demonstrate the use of inheritance

302

CHAPTER

18

when we

create our

queue

object.

OOP AND ABSTRACT DATA STRUCTURES

To keep

things simple,

we

use

Perl's arrays to

implement our stack on the

but on the outside we just have a stack object that might have an optional

inside,

and provides only the following functions: push, pop, top, is_empty,

size limit

and is_full. The top function merely returns the top element out removing

it.

This

is

when you want

useful

to

compare the current

the previous state

without having to pop the previous

them, and push

back on again.

We

it

module

use another

function

—

module

as you'll see shortly.

To begin

ple constructor to return a reference to

()

line in

function

—from

as

inside our object's

our main program that called these

we start our package and create a siman anonymous array as the blessed object: with,

package Stack; use Carp; sub new my $tYpe = shift; my $class = ref($type) $type; my $max_size = shift; my $self = [$max_size]; return bless $self $class;

,

^

{

|

with

compare

allows us to issue warnings using the

or errors using the croak

methods. These warnings point to the methods,

state

state off the stack,

our stack object, the Carp module that comes

in

part of the Perl distribution. This

carpO

in the stack with-

,

-t

,

..

" . _

|

...

,

' •

,

_

>

We now have an anonymous array as an object with a maximum size attribute stored in its first position. We can construct our two test methods to test if the stack empty or full. We assume that, if the maximum size 0 (no size was given is

when always #

is

the object was created), fail

we want

a limitless stack so the full test should

in that case.

$stack->is_empty

(

)

;

returns true if stack is empty

sub is_empty { my $self = shift; return !$#$self; }

# $stack->is_full returns true if stack is full sub is_full { my $self = shift; return 0 unless $self->[0]; return {$#$self == $self->[0]); (

)

;

}

Wliat the heck which,

is

when used on an

$self, our object,

is

STACKS, QUEUES,

!$#$self? Well,

!

array, gives us the

a reference to

AND LINKED

an

array.

LISTS

is

just the logical not operator,

index of the

last

element of that

Thus, is_empty

{

)

$#,

array.

simply returns the

303

{

;

of the

logical negation

value),

!

{ {

;

;

—

index of the array

last

0 returns true. Similarly,

value and

!

With

if

the last index

is

is,

if

the last index

is

greater than 0, then

0

(a false

it is

a true

true return false.

these simple tests in place,

tions easily

that

by

first testing

we can now implement our remaining

func-

our stack for the appropriate condition, then using the

tures already built into Perl's arrays to

do the

rest.

The

of module looks

rest

fea-

like this:

pushes $item onto stack if stack not full # $stack->push $item) sub push { my $self = shift; my $itein = shift; if ($self->is_full carp "Stack is full:"; return ;

(

{

)

)

'

}

„,^,

,

. ,

push @$self, Sitem; }.

$stack->pop pops the top item from the stack if not empty sub pop { my $self = shift; ; if $self ->is_empty { carp "Stack is empty:"; return; #

(

)

;

'

•

{

{

)

)

•

-

}

,

return pop @$self; }

returns the value of the top element if not empty # $stack->top sub top { my $self = shift; if ($self->is_empty() carp "Stack is empty:"; return; (

)

;

)

}

^

•

return $self-> [$#$self

]

-

;

-;

.'

-• ,

'

}

"

'

1;

'

END

Now we to test

its

save this in a

file

named

Stack.pm,

and we write a simple

little

script

functionality:

#! /usr /bin/perl -w use strict use Stack; my $st = Stack->new 4 #test push to overflow .

•

-•

;

{

(

for(3, 5,2,

,

,

,-.

)

)

9, 11)

print "pushing: $_\n" if $st->push $_) (

}

304

CHAPTER

18

OOP AND ABSTRACT DATA STRUCTURES

;

:

;

if $st->pop print "popped: 9\n" print "pushed: 42\n" if $st->push 42 \n" print 'top is: ', $st->top (

)

(

"

(

)

" ,

\n"

-i

;

-

.

,

:

.5)

,

'

""

;

,

#test pop to underflow

ford.

?

.

)

,

;

,

,

,.

-

{

print 'popped:

'

,

$st->pop

" {

,

)

\n"

'i'

'

;

'

;

••

)

print $st->top

,

{

)

"

\n"

This script produces the following output: perl stack.pl pushing: 3 pushing 5 pushing: 2 pushing: 9 Stack is full: at stack.pl line 7 popped 9 pushed: 42 top is: 42 popped: 42 Popped: 2 popped: 5 popped: 3 Stack is empty: at stack.pl line 16 Popped Stack is empty: at stack.pl line 18

'

$

, ;

,

:

running?

how

notice

Had we

the carp

(

)

-

!

,

,

(

)

_

_

.

,

.

.

.

messages point to the line in the script

used ordinary warn

„

^

:

Now,

,,

calls,

the

first

we

are

message would have been

stack is full: at Stack. pm line 26.

which wouldn't help us lem

lies

because

modules' croak

that's

{

)

locate the

where we

is

a

accepts, parses,

little

our

script,

which

and then

round and square,

than our

we can

test script.

One

to check for

let's

assume that

to be used

this

die

(

)

The Carp function.

example of using a

Consider a program that

program allows two kinds of paren-

—presumably

so that the person entering the

them from mis-entering

as a first test for a valid

equation

is

braces:

3+[(4*[9-2]-l)/2] 3+[(4*[9-2)-l]/2) STACKS, QUEUES,

where the prob-

evaluates simple mathematical expressions involving

of things you might want to do

mismatched

Perl's

give an

expression can alternate between brace types to help keep equations.

is

are attempting to overflow the stack.

a full parser here,

trivial

less

basic arithmetic. Further, theses,

in

function provides a similar alternative to

While we won't write stack that

problem

AND LINKED

is correctly nested is incorrectly nested

LISTS

305

;

;

A simple subroutine

;

;

{

{

When

stack.

a closing bracket

from the stack

to see if it

will

encountered,

it

in

brackets) encountered onto the

can pop the

last

opening bracket

of the correct type. Such a routine also catches instances

is

of missing brackets. For

is

(left

;

work through each token

using a stack can be used to

the statement and push any opening brackets

;

readability, these equations are nicely

spaced out, but

we

split on nothing to allow for equations that are not spaced out. The following

script provides the subroutine plus a helper routine for printing errors:

#

!

/usr/bin/perl -w

use strict; use Stack;

my $expressionl my $expression2

='3+[{4*[9-2]-l)/2]'; ='3+[(4*[9-2)-l]/2)';

check_braces $expressionl) check_braces $expression2 (

)

(

sub check_braces { my $expr = shift my $st = Stack->new my $pos = 0 " my $valid = 1; #assume validity my $ token; foreach $token (split //, $expr) { if ($token =~ m/\ \ [/) $st->push($token) }elsif ($token =~ m/\) \] /) { die not_valid{$token, $expr, $pos) if $st->is_empty my $prev = $st->pop{); {' unless $token eq ') && $prev eq or && $prev eq $ token eq " die not_valid($token, $expr, $pos) ( )

'

'

-

"

'

'

'

(

,

,

|

..

I

'

(

)

'

(

[

]

'

'

'

'

)

}

:

-

}

.,.,„!'.,;,,.

,

;

^

/

$pos++ .'I

}

$token = $st->top(); die not_valid $token, $expr return 1; (

sub not_valid { my $token, $expr $pos = @_; my $ptr = x 19 x $pos return new() $queue->is_empty $queue->is_full

,

.

•

(

(

-

'

)

'

' ,

)

i

$queue->enqueue $item) shoves $item into queue function rather we are merely renaming Stacks push than inheriting it: ;

(

{

sub enqueue { shift->push shift {

)

"c'*.

)

;

,

.

-

:

,

}

#$queue->dequeue removes and returns front of queue sub dequeue { my $self = shift; if $self ->is_empty carp ref($self)," is empty:"; return; (

)

;

;

(

{

)

)

;

,.;

'

{

•

-

-

?

.

,

,

.

,

,

.

,,^.j.„

•

'

,.

.

,

'

'

}

return splice (©$self

,

1

,

1)

'^j

;

.

;

"

}

,

# $queue->f ront returns front of queue sub front { my $self = shift; if $self ->is_empty carp ref($self)," is empty:"; return; (

)

^

{

)

,-

(doesn't remove)

;

(

;

,

^

)

'

} ,

return $self->[l];

,

'

=

i"^

}

1;

END

'

/

The only ing "Queue

'

thing really different here

is

empty",

it

is

the carp

says ref ($self)

is

(

)

empty.

function on an object returns the object's class name.

308

CHAPTER

18

statement. Rather than say-

Remember

We

that the ref

()

have to go back to the

OOP AND ABSTRACT DATA STRUCTURES

{

;

;

;

;

;

;

Stack module and change those carp

word stack

instead of hard-coding in the

$self being used in Stack's functions

is

carp

(

making

we can now run

statement,

)

in the messages because

no longer

ing the example above in Queue.pm and classes

statements to also use this technique

)

(

sometimes the

a stack but a Queue. After sav-

the

minor changes

to the Stack

the following test script:

#! /usr /bin/perl -w use strict; use Queue;

my $q = Queue->new for(3,2,4,9,ll) $q->enqueue $_)

(

4

)

(

}

print $q->dequeue {),"*** \n" $q->senqueue 42 " print $q->front ***\n" {

)

,

(

ford.

.5)

)

{

print $q->dequeue

, (

"

)

*\n";

}

print $q->f ront

(

)

which produces the following output

(the asterisks are only to help differentiate

different print statements):

Queue is full: at queue.pl line

7

3*** 2*** 2

*

4

*

9

*

42

*

Queue is empty: at queue.pl line 15 Queue is empty: at queue.pl line 17

18.4.3 It is

Linked lists

hard to appreciate

Linked

lists

and

that Perl gives

are another freebie. In

static in nature.

array

all

You

that's the

state at the

needed

many

for free

only array you get to use. isn't

a

at least

within the

STACKS, QUEUES,

What

built-in data types.

how

if

you

LISTS

big

you want your

aren't sure

problem because

how

big your

Perl itself takes care

of

grow and shrink

as

array that can

memory limits of your

AND LINKED

its

languages, structures such as arrays are

you by providing you with a dynamic

—

with

beginning of the program

array will need to be? In Perl, this this for

you

computer.

309

new memory on demand, linked lists can be used to solve such dynamic problems by providing a way of pointing to this new memory. Obviously, Perl can allocate new memory on demand during runtime. You can always create new variables in Perl, and Perl can point to this new memory through references to new variables, or anonymous structures. So, while As long

as the

language

is

able allocate

not often needed in most Perl programs, you can create linked Also, while the linked

list

may

structure

a linked

is

list?

in Perl readily.

not be that useRil, the same techniques

can be used to create other structures such

So what

lists

as trees.

Consider that you have to read in a variable number

of simple inventory records (part-number:name:quantity) and you want to be able to search the

do

list

for certain fields. Easy, right? Well,

without using an array or hash to hold the entire

it

use small

anonymous

say that

let's

list

now you

although you can

record as hash

record as array

or #

p_num => 144, name => pencil, quantity => 7,

[

144 'pencil',

#

,

#

#

,

7,

#

}

•

]

:

Graphically these records could be represented as in figure 18.4, where

you have some

fields, regardless

still

arrays or hashes to hold individual records as in

{

ply assume

have to

storage device with slots

of whether you also store the

Generic Record

Specific Record

part_number

144

part_name

pencil

field

you can use

names

we

sim-

to hold the different

[keys]

along with them.

quantity

Figure 18.4

The

Graphical representation of inventory record

slots that

contain the field data could hold any scalar data.

one of these structures structure,

why

^

is

just a scalar value. So, if we

can have three

fields in

each

not another, or even two more?

In figure 18.5, each structure holds two additional reference to the next structure (if any)

ous structure

A reference to

(if

any).

The

fields,

one containing a

and one containing a reference

to the previ-

small black circles are just our reference depiction from

chapter 8, and the arrows are meant to point to the whole next (or previous) structure,

not just one

field.

"link" (a reference) to

310

its

Each node, or individual record-structure, contains a next node and

CHAPTER

18

its

previous node.

OOP AND ABSTRACT DA TA STRUCTURES

—

,

Specific Records

Generic Record

part_number

&&

1

part_name quantity

pencil

pen 11

•

• Records with additional pointer

Figure 18.5

we had

have access to

a reference to the this

first

node and, by

node, and so on, until also

9Q1

7

Next

If

w

undef

Prev

we

node, perhaps stored in a variable, then

reference,

its

field

because

it

called a linked

is

is

We

undefined.

the references in each node's "previous"

only thing holding the different records together as a link them. Hence, this

list.

we

next node, and that node's next-

node whose "next"

hit a

work backwards following

fields

list

Actually, this

could

field.

The

are the references that is

a double-linked

list

has links in each direction.

In the above description, I've only described creating a linked

hold just a key you associate with your data,

ing your record.

items in the

data,

The key

of structures

A more general approach would be to use a key field— to

that contain the data itself

which would hold your

list

most

field

likely as

as

—and

a data field

an anonymous hash or array represent-

then your search

is

with a hash

field

when looking

for particular

list:

A node in the linked list

previous key data next

(reference to previous item),

=> => => =>

:

. ,

,j,,„

(your key) (your data), (reference to next item),

"

)

In will

some

cases, the

key

itself

might be the only

have a key and a record to go with

it.

data, but in

Such a record

is

many

cases,

you

called the satellite data

was not pertinent previously because our stacks and

for the key. Satellite data

queues did not need to support a search operation.

The methods

following package to insert

new nodes

emptiness, and return the

do not need singly linked

node

—

list

to traverse the list.

is

a partial implementation of a linked

into the

list,

search the

of the stored records

list

in

both directions,

list

(i.e.,

this

list

for a given key, test for

dump

the

list).

STACKS, QUEUES,

Since

we

package just implements a

Each node knows the next node, but no node knows

say that five times

supporting

its

previous

fast.

AND LINKED

LISTS

311

;

package Llist; sub new { my $tYpe = shift; $type; my $class = ref ($type) my $self = { } return bless $self, $class; |

|

}

All our

new

function does

anonymous

representing with an

and returned and

The

real

work

routine here that

my $data

=

This

?

will is

you

done by the insert

(

anonymous hash)

(i.e.,

blessed

list.

method.

)

is

are

One

our insertion

line in

haven't seen before looks like this:

{

operator

node

hash. This

be the base node for our

def ined $_

:

empty node, which we

create a completely

is

is

[

0

]

)

$_[0]

?

$key;

:

called the ternary operator

else clause in an expression.

general form

Its

and operates rather

like

an if /

is ^

(condition) ? (this expression) (that expression) returns: this expression if condition was true returns: that expression if condition was false :

The above line of code tests if $_ $data. If not, we assign $key to $data my $data because false,

=

it is

shift

|

|

0

[

]

is

...

defined. If so,

instead.

We do

we

not simply use

$key;

possible that the value

we

are shifting

is

0,

which would evaluate

and we would wind up assigning $key instead of the

value of 0. In the ternary conditional, to see if

it is

true.

To do our

—and,

assign that value to

Thus we avoid

insertion,

we

test to see if the

perfectly valid data

argument

is

defined, not

problem.

this potential

we need

as

to consider

two

cases:

Our

first

node, self,

is

we need only copy our key and data into it or our first node is not empty. In the second case, we insert by creating a new node and copy the first nodes data and next pointer into this new node. Then, we add our new key and data into the first node and stick the new node into our first node's next field. In this way, the list grows like a reversed stack, with new eleempty

—

thus, the

list is

empty, and

ments being pushed onto the front of the

node

Each node

actually contains

its

next

object:

sub insert { my $self my $key my $data

312

list.

=

= =

shift; shift; def ined {$_[ 0

CHAPTER

]

)

18

?

shift

:

$key;

OOP AND ABSTRACT DATA STRUCTURES

; {

if

(

{

;

;

;

;

;

} ;

;

$self ->is_empty = $key; $self->{key} $self->{data} = $data; $self->{next} = undef; (

)

)

}else{

$node = $self ->new = $self -> {key} $node->{key} $node-> {data} = $self -> {data} $node-> {next } = $self -> {next (

$self->{key} $self->{data} $self -> {next }

)

$key; $data; = $node; = =

}

return

1;

Testing

if

We do

by

this

the

list is

empty

requires only that

testing to see if the

key

field

is

we

test if

the

first

node

is

empty.

not defined.

sub is_empty { return Idefined shif t->{key} }

able

The search and dump-list methods are similar because they both must be to traverse the list. The difference between the two methods is that the search

will

end and return the data associated with that key

is

looking.

if it finds

The dump method must continue through

the key for which

the whole

it

list:

sub search { my $self = shift; my $key = shift; return 0 unless defined $key;

while (1) return $self -> {data} if $self->{key} eq $key; last unless defined $self -> {next } $self = $self->{next} {

}

return

0

sub dump_list { my $self = shift; my @list = ($self->{data} while (1) last unless $self -> {next } $self = $self->{next} push Olist $self -> {data} )

,

}

return @list; }

1;

END

STACKS, QUEUES,

AND LINKED

LISTS

313

Notice

new

in

that, unlike

data with keys

found item.

the

first

keys

—by

with a hash, there

we have

We

already used.

nothing preventing us from sticking

Our

search

method

will

only return

could change our insert routine to disallow identical

searching to see

first

is

if

the key already exists

—

or to replace the data of

the key if that key already exists in the list rather than adding a new node. (Again, we would have to search the list to find the right node, if any.) The following exercises allow you to add further functionality to this object.

18.5 1

Exercises

Use perldoc

perl toot to read

object-oriented

what you

Tom

programming with

Christiansen's excellent tutorial

view the

Perl (or

Also take a look at the perlobj and perlbot pod-pages.

3

The

4

linked

list

object could benefit from a

rather than the values.

The main this,

you

Add

need to search the

list.

method

a dump_keys

thing missing from our linked

first

out of the

if that's

list

(

)

list is

that

method a

dumps

to this object.

method

to find the node.

the keys of the

to delete a node. For

Then you must

splice

it

This requires that you keep track of the previous node because

to splice the current

current node's next

314

page

prefer to use to read the documentation).

2

list

HTML

on

node you need

to set the previous node's

next

field to the

field.

CHAPTER

18

OOP AND ABSTRACT DATA STRUCTURES

CHAPTER More

19

OOP examples

19.1

The heap

19.2

Grades: an object example

19.3

Exercises

as

an abstract data structure

330

315

320

316

,

we

In this chapter,

heap

class,

and

begin by returning to our heap data structure and implement a

discuss

some of it

example of creating a few example we used

make

From

classes.

We

then turn to a more practical

these classes,

beginning of chapter

at the

from

reports

applications.

we can

revisit

and extend the

building a system to query and

8,

a data base of student assignment

and exam

grades.

The heap as an abstract data structure

19.1

may wish

Before tackling this section, you structure

and the algorithms we used

to familiarize yourself with the heap

in chapter 17 to create a

heap and pull items

off the top of the heap.

Heap

For our use the

first

will again use

We

—

also

in this case, the

an anonymous subroutine we can use to compare two

as well as

keys in the heap.

We will

an array to store our heap.

element of the array to store additional information

of the heap,

size

we

class,

begin by defining our package and setting up a private hash

of comparison functions.

package Heap; use strict;

my

%coinp =

str rstr num rnum

{

)

:

=> => => =>

$_[0] $_[!] $_[0] $_[1]

cmp cmp

$_[!]}, $_[0]}, $_[!]}, $_[0]}, •

;

This hash

private to the

is

expect the caller of our new

comparison routine to

and

{return {return {return {return

sub sub sub sub

.

Heap

package, no other package can access

We

constructor to supply an argument indicating which

( )

str and rstr are for string comparisons in normal

use.

num and mum.

reverse sorted order, similarly for

default to using

it.

If

no routine

is

specified,

numeric comparisons:

we

«

sub new { my $this = shift; my $class = ref ($this) |$this; my $comp = shift 'n\im' my $self = size => 0, { comp => $comp{$comp} |

(

|

)

|

;

[

}, ]

;

return bless $self $class ,

'

;

_

•

}

This constructor has with a hash reference in

set

up our

its first

the heap and a reference to the

316

initial

empty heap

as

an anonymous array

position. This hash reference contains the size of

anonymous subroutine

CHAPTER

19

for comparisons.

MORE OOP EXAMPLES

;

;

;

Unlike our heap model in chapter the heap

We

on demand

will first create a

—and then

ment

sub insert { my $self my $key my $data my $node

call

1

we wish

7,

to be able to insert items into

rather than building a heap out of an existing

node out of the arguments passed

in

—

of items.

list

and a data

a key

ele-

another method to do the actual insertion:

""

shift; shift; = def ined $_ 0 ? shift = { key => $key, data => $data,

"'

=

,

=

[

(

]

)

$key;

:

'

(.i

)

''

'

{

-

.

,

);

$self->_insert_node $node)

,

,

'

.r;

,

'

-

;

, _

}

V',.

tp^"'

Using an underscore the class. Such

method

to

start

actual insertion

has the effect

moving up the

element

if it is

just a

convention to mark some functions

methods should never be

do the

heap, which

is

leaf

We first increase the size of the tree. We then

onto to our binary

down one

node, copying each parent node

this final

smaller than the current key.

than the current node,

from outside the package. Our

as follows.

new

of adding a

from

tree

works

called

as private to

we have found

WTien the next parent node

is

larger

the place in the heap to insert the node,

which we do. sub _insert_node { my ($self, $node) = @_; my $i = ++$self-> [0] {size} my $comp = $self-> [0] {comp} while $i > 1 and $comp-> $self-> [parent $i) {key} $self->[$i] = $self-> [parent {$i) $i = parent $i

*"

;

(

(

(

]

,

$node-> {key } [0] {size} < return;

our

don't put the top element at the

We still need to put something in

take the last element of the heap

in

and push

it

down

the top posi-

using the push-

17.

'

"

1)

'

:'"

"

""

{

}.

318

CHAPTER

19

MORE OOP EXAMPLES

;

;

my $top = $self-> [1] {data} my $node = pop @$self; $self-> [0] {size}--; if

($self->[0] {size} > $self->[l] = $node;

0)

;

;

;

^

{

$self->_pushdown(l) ^

}

return $top; }

The

routine to pusli an element

down

the heap

same

the

is

as

we used

in

chapter 17, only modified to use the comparison routine.

sub _pushdovm { my ($self, $i) = my $size = $self-> [0] {size} " my $comp = $self-> [0] {comp} while{ $i ($self->[$lcid] {key},$self->[$kid +l]{key}) ,

.

.

,

'

'

;

•

•

.

.

""

'

)

(

{


= 0; last if $comp-> ($self-> [$i] {key} $self-> [$kid] {key} = ($self->[$i] $self->[$kid] $self -> $kid] $self -> $i $i = $kid; )

,

)

,

(

[

]

[

,

)

-

}

}

The all

three class

methods we use

to return the parent,

left,

and

right indices are

extremely simple one-line fianctions:

sub parent sub left sub right

{ {

{

return int($_[0] return $_[0] * 2 return $_[0] * 2

/

2)

}

}

+

1

}

1;

.

END

The

following

data and insert as the key.

We

is

a simple test script to read in a few lines of colon-separated

anonymous hashes of these want

to process these records in alphabetical order, so

heap constructor the string rstr to order.

Our heap normally puts

this idea

records into a heap using the

tell it

to

compare using

the largest element

and put the smallest element on top

on the

name

we

field

pass the

reverse alphabetical

top, so

we need

to reverse

to get proper alphabetical ordering:

THE HEAP AS AN ABSTRACT DA TA STRUCTURE

319

{

;

{

;

{

;

# /usr/bin/perl -w use strict; use Heap; !

my $heap

Heap->new

=

( '

rstr

'

)

while () chomp mY($name, $age, $beer) = split $heap->insert $name {name => age => beer =>

/:/;

$name, $age, $beer,

,

(

"

'

}

while ($_ = $heap->extract_top foreach my $key (keys %$_) print " $key :$_->{ $key} \n" {

)

)

}

print

\n"

"

; '

}

DATA

' '

Brad: 37: ale Andrew: 3 5 ale Susanna 4 0 lager John 33 stout :

:

:

:

:

A heap you can

can be used to implement what

known

as a priority

queue, where

store a Hst of things to process according to their priority.

These queues

are usually

is

dynamic; new elements are inserted while elements from the queue are

processed. In the real world,

you could consider

a hospital

emergency room

as

using a priority queue to process patients. Patients are not treated in order of

but according to the severity of their physical condition. In the computing

arrival,

world, you ing

on

may

have heard of priority queues being used to manage job schedul-

a multi-user

Different users

computer or

may

as the

have different

means of holding jobs

priorities

entered into the queues based on their priority

19.2

on the system, and

Grades: an object example

In this section,

more

we

will

no longer be dealing with standard computer science types

own

structures to use as objects

familiar kind of data processing task.

Recall the

problem given

at the

beginning of chapter

report of assignment grades for each student in a

generalized version of the

same problem.

class.

8.

We

Here we

needed to create a

will consider a

more

We want to be able to store grades for stu-

dents in a given course and retrieve current

320

their tasks are

level.

of data structures. Instead, we will formulate our for a

in a printer queue.

summary information

CHAPTER

19

for each student

MORE OOP EXAMPLES

5

-

As

in the course. ticular

before,

we

want

just

assignment in a plain text

file

(Perhaps the exams are performed

appended

to this

one course. In

To

we

want

we

as these

assignments

on

web and

the

come

in

and

are graded.

automatically graded and

to be able to use our

program

more than

for

consider two courses: Math-101 and Math-201.

define a configuration

The format

course.

also

example,

this

begin,

We

file.)

to be able to enter a student's score for a par-

format that can be used for each

file

will specify the total score possible for

each assignment and the

value of each assignment's contribution to the final course grade. For example, in

our Math-101 course,

we may

decide that

we

will give three assignments, each

scored out of 50, but counting for only 25 percent of the final mark; and one

exam marked out of 75 and counting our configuration

file

25 percent of the

for

fields for the

Assign 1 50 25 Assign:2:50:25 Assign: 3 50 25 Exam 1 7 5 2 :

create

(Assign or of,

and the

number out of

like this:

>-

*

-

"

"

'Cf

.

-

;

.

..

:

:

:

When we math-101

marked out

:

:

:

it is

contributes toward the final grade (expressed simply as a

100). Thus, our math-lOl.cfg^Xe. looks

:

work

type of graded

Exam), the assignment or exam number, the raw score it

We

math-lOl.cfgzs, colon-separated records, one for each type of

graded work. Each record contains

amount

mark.

final

record the grades in our grade

—we need

to record the student

file

for the course

—named here

name, the assignment number

(1, 2,

or

3 for assignments, or El for the 1st exam), and the raw score the student obtained.

So part of the data Bill Anne Sara Sara Bill Bill Anne Sara Anne Bill Anne

file

for this class

might look

like this:

Jones:2:35 Smith: 3: 41 Tims 2 45 Tims 3 39 Jones 1 42 Jones:El:72 Smith: 1:42 Tims 1 41 Smith: 2: 47 Jones: 3:41 Smith:El:69 :

:

:

:

:

:

Now,

'

'

:

:

let's

look at the types of things

we have

in

have courses, students, and assignments (or exams). eral

category

contains a

GRADES:

first,

list

of

the course category. its

students. Thus,

AN OBJECT EXAMPLE

A

we

our problem statement Let's

—we

consider the most gen-

given course has a course name, and also create a

file,

with a

it

.std extension.

321

{

;

containing

the

all

we have

course,

Bill Jones Anne Smith Sara Tims Frank Worza

;

;

in a given class. So, for

'

'

,

to use this course class in our reporting

Well, keeping things simple and assuming

whole

class,

our Math-101

math- 1 01 .std containing

file

how might we want

So,

,

names of the students

the

'

;

.

we can imagine

argument:

program that

a

we

just

want

program?

to create a report for the

invoked with the course name

is

as

an

'

# /usr/bin/perl -w use strict; use Course; die "You must supply a course name.\n"; @ARGV my $class = Course->new $ARGV 0 while () chomp $class->add_student_record (split /:/) !

I

I

[

{

]

)

•

;

.

1

;

}

$class->print_report END

(

)

Remember, our data data

file is

in $argv[0]

name

of grades has the same

file

when

the program

course, iterates through the data

file

is

called.

as the course, so the

This program creates a

adding student records to the course, and

then prints out a report of the course grades. Presumably, the Course

how

to

add student records and print the

Student class

list.

class

Let's

and have

it

store a

list

new

report.

We

make our Course

of student objects

begin building our Course

class

— one

for each

knows

class use a

name

in the

class:

package Course; use Student; use strict; sub new { my $type = shift; my $class = ref ($type) |$type; my $course = shift; => $course, my $self = { course => 0, number students => { } |

}

bless $self, $class; $self ->_conf igure_course return $self;

322

(

)

CHAPTER

19

MORE OOP EXAMPLES

{

;

;

;

;

This constructor creates a Course object that contains

number of students

fields for the

name of

contains an

empty

hash reference that holds a hash of student names and the student objects.

Much

the course, and the

of the

work

real

is

done within the configuration routine we

the constructor. This routine

and the student

as well as a field that

list

is

responsible for reading in the configuration

name.

for the given course

It

list

and

creates a

new student

Thus

my %cfg; open (CFG, $cfg_f ile) while ()

list.

'

'

•

"

*

'.cfg';

.

:

die "can't open $cfg_file: I

the routine reads the

object for each student in the

sub _conf igure_course { my $self = shift; my $cfg_file = $self->{course}

file

builds a configuration hash that

holds the information about each assignment or exam.

student

near the end of

call

.

>,.,,,

•

!

$

" ;

-I

I

chomp;

my ($type, ©data) $cfg{$type} [$data $cf g{ $type" "

.

'_no

split /:/;

= [0] '

}

]

=

[

(adata[l,2]

];

++

}

.

-

-

-

close CFG; my $stud_file = $self-> { course} '.std'; open (STD, $stud_f ile) || die "can't open $stud_file: $!"; while () chomp (my $name = $_) $self-> {students }{ $name} = Student->new \%cfg, $name) $self-> {number }++

'

'

.

;

.,

.

.

.....

(

close STD; }

We

can

now add

a few accessor type fiinctions to retrieve the data in our

course object. These are pretty straightforward: # course returns the course name sub course { my $self = shift; return $self-> {course} (

)

:

}

number returns the number of students in the course sub number { my $self = shift; return $self->{number} #

(

)

:

}

#

#

student (name) returns the student object associated with the given name

GRADES:

:

AN OBJECT EXAMPLE

323

;

;

sub student my $self = shift; my $name = shift; return $self-> { students }{ $name }

;

;

;

;

{

undef;

||

}

list(): returns the sorted list of student names sub list { my $self = shift; my ©list = map { $_->[0] } sort{ $a->[2] cmp $b->[2] } map { [$_, split] } keys %{ $self-> { students )} return @list; #

}

We

need to add the functionality we saw in our main program

need to be able to add student records and print a

we

class report.

— namely, we

For these functions,

assume that the student objects themselves have functions for adding assign-

ments and printing

their

own

reports:

'

sub add_student_record my $self = shift; my $name = shift; my $student = $self->student $name) $student->add_assignment(@_) {

(

}

sub print_report { my $self = shift; my $course = $self ->course my $number = $self ->number print "Class Report: course = $course: students = $number\n" $self ->list foreach my $name ){ $self->student $name) ->print_report '

"

(

)

(

)

(

(

• ,

'

)

(

(

)

}

'

1

"

\

;

"

_END

.'

-

'

Don't forget to end your

module with a

we know that we Student constructor, and we know

shown above. At hash to the

class

this point,

will

'

true statement such as the 1

be passing the configuration

that class will need a

method

adding assignments to the student and printing a report on the student. Just

Course class

we

class

used the Student

our Student

class

our

makes use of an Assignment

will define later:

package Student; use Assignment; use strict;

324

class,

as

for

.

_

.

,

CHAPTER

19

MORE OOP EXAMPLES

{ ;

;

;

sub new { my $type = shift; my $class = ref ($type) my $cfg = shift; my $name = shift; my $self = {config name assignments

;

;

;

;

'!'' |$type;

'

|

'-h;

:

,.

,

=> $cfg, => $name, => 0,

bless $self $class; return $self; ,

'

• .

}

much new

we have fields for a reference to the configuration hash and the students' names passed when each new student is created. We also have a field to hold the number of assignments this student has There

is

nothing

in this constructor;

completed.

ing

The method to add an assignment creates new fields in the object; one holdan anonymous array of assignments, and the other holding an anonymous

array of exams.

These arrays

are

populated with

new Assignment

objects,

and the

assignment count incremented: '

sub add_assigninent { my $self = shift; my($nuin, $score) = @_; my $cfg = $self-> {config} my $type; if ($num =~ s/"E//) $type = Exam else { } $type = 'Assign' '

'

?

'

'

}

$self->{$type} [$num] = Assignment->new($cfg, $type, $num, $score) $self-> {assignments} ++ }

We

also

add a couple of accessor

fiinctions to this class to return

assignment objects (either assignments or exams). discard possibly

empty elements

We

use the

lists

grepO function

of to

in either array:

sub get_assigns { my $self = shift; return grep{$_} @ { $self-> {Assign}

}

}

sub get_exams { my $self = shift; return grep{$_} (a{$self->{Exam}

}

}

GRADES:

AN OBJECT EXAMPLE

325

;

Our

{ ;

;

function for printing a student's report

assumes that a given assignment knows to maintain a

—

mark

{

running

how

is

;

{

;

longer, but not complicated.

to print

its

own

and only needs

report

of each assignments contribution toward the

total

It

final

$f score:

sub print_report { my $self = shift; my $cfg = $self -> {conf ig} \n" print $self-> {name}

;

r

,

"

:

$self ->get_exams unless $self ->get_assigns print "\tNo records for this studentXn" return; {

(

)

(

|

)

)

|

my $f total, $a_count, $e_count) = (0,0,0); foreach my $assign $self ->get_assigns print \t $assign->print_report $f total += $assign->f score {) $a_count++; (

(

"

"

(

)

)

(

)

r

•

;

•

;

'

;

-

.

"

/

;

>

foreach my $assign $self ->get_exains print \t " $assign->print_report $ftotal += $assign->f score () $e_count++; (

"

(

)

)

{

^

;

(

)

,

'

;

.

\

' '

'

;

'

.

,,

„ -

.

}

.

.

;

.

, ^

== $a_count and $cfg->{Exam_no} == $e_count) print "\tFinal Course Grade: $f total/100\n"

if ($cfg->{Assign_no}

}else{

print print

\n"

"

"

\tIncomplete RecordXn" '

•

;

.

}

'

1;

END

'

-

'

r'^^'-

' :

;

we have our Assignment class. The constructor for this passing off the hard work to its own _assign{ function:

Finally,

simple,

is

fairly

)

package Assignment; sub new

class

.

^

{

my $type = shift; my $class = ref ($type) |$type; my $cfg = shift; my $self = {config => $cfg} bless $self, $class;

'

|

326

-

'

CHAPTER

-

•

19

:

MORE OOP EXAMPLES

;

$self->_assign return $self;

(@_)

;

;

;

;

;

.{score} print $self->{ fscore}

raw

,

:

"

,

,

/

=

";

$self -> {raw} " "/", $self->{ final} ,

"

,

:

Adjusted

=

";

," \n"

}

1;

END

GRADES:

AN OBJECT EXAMPLE

327

:

:

Now we pass

can run our original program given at the

name of our

the

it

:

same name

as well as the

and data

files

in a

$ perl report.pl math-101 Class Report: course = mathFrank Howza No records for this Bill Jones Assignment 1 raw = Assignment 2 raw = Assignment 3 raw = Exam 1 raw = 72/75 Final Course Grade Anne Smith: Assignment 1 raw = Assignment 2 raw = Assignment 3 raw = Exam 1 raw = 69/75 Final Course Grade Sara Tims Assignment 1 raw = Assignment 2 raw = Assignment 3 raw = Incomplete Record =

:

=

:

named

file

same directory

in the

We

of

as

report.pl,

of the

created.

files

and we have

file

all

three

and

We

mod-

our program:

students

101:

this section

already have the data

math-101. cfg and the math-101. std

assume we save the program ules

Math-101.

course,

start

=

4

student

Adjusted = 21 00/25 Adjusted = 17 50/25 Adjusted = 20 50/25 Adjusted =24.0 0/25 83/100

42/50 35/50 41/50 :

Adjusted = 21 00/25 Adjusted = 23 50/25 Adjusted = 20 50/25 Adjusted = 23.00/25

42/50 47/50 41/50 :

88/100

:

You'll notice that the student

in

our

file.

class list file,

Similarly, Sara

Adjusted Adjusted Adjusted

41/50 45/50 39/50

20 50/25 22 50/25 = 19 50/25 = =

name Frank Howza

has no records.

appears

but there were no assignments or exams for him in the data

Tims

has no record for her exam, so her report

incomplete. If

He

is

marked

as

,

we had another

course with a completely different set of assignments (and

perhaps different students),

we could simply

class list file for that course's

create a

new

configuration

data and run the same program on

it.

file

and

For example,

our Math-201 course might have only two assignments, both out of 50 points, but with the

first

final grade.

one making up 25 percent and the second only 10 percent of the

There

are also

two exams, both out of 75, with the

20 percent and the second exam contributing 45 percent configuration

Assign: Assign: Exam 1 Exam 2

328

file

1

:

50 25

2

:

50

:

:

:

:

75

:

20

:

:

75

:

45

would look

first

contributing

to the final grade.

The

like this:

•. ,

.

10

CHAPTER

19

MORE OOP EXAMPLES

—

,

For simplicity's sake, grades

Bill Sara Sara Anne Anne Bill Sara Anne Bill Bill Sara

now

we assume

the same class

list

applies.

The

data

of

file

appears as

Jones: 1:43 Tims 2 32 :

:

Tiins:l:44 Smith: 1 44 Smith: 2 39 Jones El 75 Tims: El: 69 Smith: El: 70 Jones 2 40 Jones :E2 75

.,

:

:

:

:

:

:

,

•

.

-

:

,

.

.

,,,

•

.

:

\.

:

Tims:E2:69

.

Anne Smith: E2: 70

Running our same program with an argument of math-201 now produces full

report for this

new

a

course:

$ perl report.pl math-201 Frank Howza: No records for this Bill Jones: Assignment 1: raw = Assignment 2 raw = Exam 1: raw = 75/7 5 Exam 2: raw = 75/75 Final Course Grade: Anne Smith: Assignment 1: raw = Assignment 2 raw = Exam 1: raw = 70/75 Exam 2: raw = 70/75 Final Course Grade: Sara Tims: Assignment 1: raw = Assignment 2 raw = Exam 1: raw = 69/7 5 Exam 2 raw = 69/75 Final Course Grade: :

:

:

:

student

Adjusted = 21.50/25 Adjusted = 8.00/10 Adjusted = 20.00/20 Adjusted = 45.00/45

43/50 40/50 :

:

:

:

94 .5/100

Adjusted = 22.00/25 Adjusted = 7.80/10 Adjusted = 18.67/20 Adjusted = 42.00/45 90.47/100

44/50 39/50

:

:

:

:

Adjusted = 22.00/25 Adjusted = 6.40/10 Adjusted = 18.40/20 Adjusted = 41.40/45

44/50 32/50 :

:

:

:

88 .2/100

Because the reporting functionality

is

built into the objects themselves,

we

can modify the program to provide an interactive query for individual students or even individual assignments

—

if

we

desired.

Here

is

a version that allows

you

to

query the data for individual student reports: # /usr/bin/perl -w use strict; use Course; !

@ARGV I

I

GRADES:

die "You must supply a course name.Xn";

AN OBJECT EXAMPLE

329

{ ;{

;

{

;

;

my $class = Course- >new $ARGV 0 ]) while () chomp $class->add_student_record split 1:1); [

{

(

}

while (1) print "Enter a student name [or '1' for list; 'q' to quit]: chomp (my $name = ) last if $name =~ m/'^qS/; \n" and next if $name eq print join " \n" $class->list if $class->student $name) $class->student $name) ->print_report } else print "no student by that name\n"; (

,

(

,

'

"

)

1 '

)

{

{

)

"

{

(

)

;

}

}

By

using a configuration

file

to define the

marking scheme for the assignments

and exams, rather than hard-coding them into

a script,

we not only

achieve the

generality to use these programs with other courses, but to change our course configuration as well. Occasionally, a teacher will decide that a particular assignment

shouldn't count for as

much

can simply reduce the

final

the values of one or

more

as originally intended.

contribution

amount

1

for that assignment

and

program

to see the

new

increase file.

The

results.

Exercises

Another handy feature to have in our grade-tracking system would be the ability to read in data

2

this system, the teacher

of the others respectively in the configuration

teacher can then simply rerun the reporting

193

With

retrieve

and print

student

is

on multiple courses and then query

a record for a given student for

registered.

Try adding

all

the data base to

the courses in which that

this feature.

Examine any programs you may have written while working through

book

to see if your data could be

modeled

in a

more object-oriented

this

fashion.

Create classes to represent the data and behaviors, and rewrite your program to use these objects.

530

.

i

,

/

CHAPTER

19

MORE OOP EXAMPLES

CHAPTER What's What's the

left?

20

left?

A lot! You have nearly reached

the end of this book, but you're not at

end of the road by any means. As Larry Wall quotes

"The road goes As

ever

on and on

stated in the introductory chapter, Perl

I

have covered a great deal in a short space, there

One we

thing

we

in Perl's

own

source code,

"

never discussed

haven't left that out altogether.

is

how

is

is

a large language, and although

to use Perl as a

Appendix

more

quite a bit

A provides

we

Perl to discover.

command

line tool.

a brief overview of

But

some

common command line switches with a few examples of running Perl command line. Appendix B provides a brief reference on a few of Perl's

of the more

from the

special built-in variables. (See the perlvar ^od-^di^c for a

We

did a

little bit

complete

of network programming using the lwp: simple module in :

chapter 14. Perl has low-level socket programming with the socket several other

ming

network

related functions, as well as a

interface via the lO

gramming, you can

Did you

ever

:

:

want

to have

it

(

)

function and

more convenient socket program-

Socket module. To find out more about network pro-

see the perlipc

time and then execute

listing.)

pod-page

(ipc for inter-process

communication).

your program read in raw source code during run-

within your program?

331

Perl's

eval

(

)

function can be used

to

do

tines.

of thing.

this sort

Read about eval

(

It

can also be used to trap errors raised by other subrou-

Advanced Perl Programming by

in the perlfunc pod-page.

)

Sriram Srinivasan^ has a very good chapter on the uses of eval Perl

can also do more than just open read and close

0 and unlink ()

can rename

ownership (chown

With

Perl,

forking), use I

keep

{

)

and

),

you can

(delete) files,

create

also

DBM databases

stressing,

CPAN

{

)

directories (mkdir

children processes

(several different flavors),

— never be

solutions. Indeed, if

(if

(

)

,

—you

and mndir

(

)

and even more

yet.

And,

for

what

it left

CPAN

you can do with

To help you

further your learning.

other Perl resources. This

landscape that

My

I

is

hope you

original plan

not an exhaustive

Perl isn't

others

—and

sider sacred. to

in the sense that

Appendix

Perl, the list

much

332

C provides a brief list of

as

I

do. I

think are

and coding of your programs.

style,

about following the rules and rigidly adhering to the conventions of I

know

So

if

I

I've

broken a few

have any wisdom

do whatever works

Srinivasan,

you never stop

was to leave off by reviewing some of what

for

you

—and

rules in this

at all to

book

impart in

to have fun doing

,

1

Perl,

merely a few signposts in a vast

list,

will enjoy exploring as

important rules or guidelines in the design,

But

all

out.

"You don't learn a natural language even once, it."

as

for easy

Larry Wall once said while writing about the natural language aspect of

learning

).

your system supports

afraid to look to

tried to catalogue everything

I

directories

contains hundreds of additional modules providing

manners of additional functionality

would be notable only

and

change their permissions (chmodO) and

and remove

fork

files

as well.

)

(

that others might con-

my final

remarks,

it is

just

it.

I

Snram. Advanced Perl Programming. Sebastopol, CA: O'Reilly and Associates, 1997.

\V'

•

CHAPTER 20

WHAT'S LEFT?

Command line switches command line switch, the -w switch, which turns on warnings. Quite a few additional command line switches exist, many of which are designed to facilitate using Perl as a command line tool. By command line tool, I mean invoking Perl directly from the command line of

You

with the most important

are already familiar

the shell

and supplying one or more statements

to perform. Consider the follow-

ing one liner:

perl -pi.bak -e

'

s/red/blue/g

'

filenames

This combines several switches and takes every occurrence of red with blue. sion. In this appendix,

switches. (See

we

It

all

the filenames given

also saves the original files

will briefly describe the

most

perldoc perlrun for additional switches and

and

with a

useful

.

replaces

bak exten-

command

line

fiirther information.)

-C

When

used, Perl will compile the script

program. This

is

a useful

out actually running $

first

and check the

step in testing your

it.

perl -c programname

333

syntax, but will not run the

program

for syntax errors with-

-e commandline may be

Takes commandline, which $ perl -e argument

'

$blah

several statements, as the script to run.

shift @ARGV; print "$blah\n"' argument

=

-P This switch causes Perl to construct the following loop around your script (whether your script

while

()

is

in a

file

or given in a -e argument):

{

your script continue { print; #

}

"

'

.

V

^

-

}

^

Hence, the following three examples are perl -p -e

$

'

s/red/blue/g

the same:

all

filename

'

';.

# /usr/bin/perl -p s/red/blue/g;

-

!

'

'

.

:

/usr/bin/perl while () { s/red/blue/g; #!

-.

-

}

continue { print; } ,

, .

:

,

.

,

.

" •

^

,

,7-;;

;

,

.^_.J,.

^

;

:

.

-n

iv

'J

:

perl -n -e 'print if m/foo/'

This prints

all

lines

^

.J.

\

-,.„r>

:

"

Like -p except without the continue block. $

;:/^

^

-

.

;

-

>

l,

filename

containing the pattern

f 00 in the file filename

-±[ extension] .

This means that

all

the

files

given on the

command

In other words, changes are written to the extension, then the original

$

files

files

line are to

be edited in place.

themselves. If given the optional

are saved with that extension:

perl -p -i.bak -e 's/red/blue/g'

filenames

'

or with the switches combined: $

perl -pi.bak -e 's/red/blue/g'

334

filenames

COMMAND

LINE SWITCHES

;

-a Used with -n or -p performed

to turn

as the first

on

mode. This causes a split

autosplit

('

')

to be

statement in the imphed loop, and the results of the split

are assigned to the array @f

.

The

following three examples are equivalent and will

print the second field in each line of data in the given

file:

perl -a -n -e 'print "$F[l]\n"' filename perl -ane 'print "$F[l]\n"' filename

$ $

# /usr/bin/perl while () { @F = split print "$F[l]\n"; !

'

/

'

-Fpattern Allows you to supply an alternate pattern to using -a).

To

perl -an -F/

split

:

/

split

on

in autosplit

mode (when

each line on colons instead of the default whitespace:

-e

'print "$F[l]\n"'

filename

This invokes the Perl debugger on the script

(see

chapter 15).

-Mmodule Allows you to use a module from the $

command

line:

perl -MCPAN -e 'shell'

Invokes Perl and

calls

use CPAN; before executing the statement shell, which,

under the CPAN pm module, puts you into an interactive .

shell

mode.

-V Prints the Perl version information.

-V

•

Prints a detailed

and

summary of the

configuration details used

when compiling

Perl

prints out the value of the @INC array.

COMMAND

LINE SWITCHES

335

9^

perlvar

Table B.1

for further information.)

Special variables

Variable

Description

$_

Default variable for input and pattern matching.

$.

The current

$/

number

of the current or last

Input record separator. Default

;

is

Output record separator. Default

$\ $"

line

' ,

V

a newline.

List separator.

Value printed between items a

double-quoted

handle read.

a newline. is

interpolated

in

file

in

string. Default

an array is

when

it

is

a space.

$0

The current program name.

$'^W

Current warning value. You can set this within a script to turn warnings off and on for particular blocks of code.

$ARGV (iARGV

.

Current

file

Command

being read from . line

arguments.

336

Table B.1

Special variables (continued)

Variable

Description

@INC

Search paths for

&F

The

%ENV

Hash of current environment variables, may be set to change the environment for spawned processes.

%SIG

Hash

ARGV

File

use and require statements.

autosplit array.

of signal handlers. (See

perldoc perlipc.)

handle that iterates over @ARGV, also specified with the empty

input operator:

STDIN

Standand input

file

STDOUT

Standard output

DATA

Special

file

DATA

SPECIAL VARIABLES

'

handle.

file

handle.

handle referring to data following an

END

or

token.

337

A

F

P

E

N

Additional resources Your

first

line

of investigation should be the documentation and FAQs that are

included with your distribution of Perl, but here are a few additional resources for learning

more about

Perl.

Newsgroups comp.lang.perl.misc.

The primary forum

for discussions

and questions regarding

the Perl language. comp.lang.perl.modules.

A forum for discussions and questions

relating to the copi-

ous existing modules as well as issues surrounding creating your comp. langperl. moderated.

modules.

A moderated forum for Perl discussions.

comp.lang.perl.tk. Discussions involving using Perl

comp.lang.perl.announce.

own

Announcements

with theTk graphical

relevant to the Perl

interface.

community.

Web pages www.perl.com. Your starting place for exploring the world of

can find links to the Perl documentation,

CPAN, and

338

lists

Perl.

From

here you

of other resources.

reference.perl.com.

A

reference

list

of modules, tutorials and other Perl-related

things.

www.perl.org.

The

Perl Institute's

and information. At the time of and was being passed on

homepage, another good place this writing, the Perl Institute

to the Perl

to find Perl

had

news

just dissolved

Mongers, but the web address

will

probably

remain the same. (If not, check the Perl Mongers page given below.) theory.uwinnipeg.calsearchlcpan-search.html.

CPAN

A

engine for searching the

search

archives.

www.pm.org. The Perl Mongers homepage. Visit here to find a Perl Mongers group in

your area or

to start

your

own

if

one doesn't

exist near you.

Books and magazines Christiansen,

Sebastopol,

Tom, Randal Schwartz, and Larry

CA: O'Reilly and

Wall. Programming Perl,

Associates, 1996. Also

book

(because of the animal on the cover), this

somewhat out of date

is

language.

It is

the text

duplicated in the included documentation.

is

Christiansen,

is

an

asset for

any

Perl

rithms.

Cambridge,

book

programmer's

Cormen, Thomas, Charles

Leiserson,

MA: MIT

Press,

as "the

is

camel book"

book on

(current to Perl version 5.003),

Tom, and Nathan Torkington. The

O'Reilly and Associates, 1998. This

and

known

the reference

2nd ed. the Perl

and much of

Perl Cookbook. Sebastopol,

chock-full of recipes

CA:

and examples

library.

and Ronald

1990. This

is

Rivest. Introduction to Algo-

an outstanding introduction to

algorithms and data structures. If you aren't interested in the analysis of algorithms, the data structures presented later are

The Perl Journal. This quarterly journal

is

still

easily

understood.

an excellent resource with

articles rang-

ing from beginner to advanced to the simply whimsical. See http://tpj.com/ for subscription details

and contents of pervious

BOOKS AND MAGAZINES

issues.

339

Numeric formats Our

standard

such

as 42,

it

number system really

means 4

and each position leftward

uses base- 10 numbers. If

are three other

binary, octal,

base 8,

number

in a

number counts

common

342

is

units 10 times (or base times)

3 hundreds and 4 tens and 2 ones.

bases used for numeric data in

16, respectively.

count up to 15 using single

a

and 2 ones. The rightmost position counts ones

and hexidecimal (usually

and base

you consider

tens

greater than the previous position. Thus,

There

-

Hexidecimal

digits, so

stand for the numbers 10 to 15.

just called hex).

The

we

is

a

little

computer

science:

These represent base

2,

odd because we cannot

use letters instead

—

the letters "a" to "f"

following table shows several numbers writ-

ten in each of these base formats.

340

R

Table D.1

Numeric formats

Decimal (base 10)

Binary (base 2)

0

0

Octal (base 8)

0

Hex (base 0

1

1

10

2

2

3

11

3

3

4

100

4

4

5

101

5

5

6

110

6

6

7

111

7

7

8

1000

10

8

9

1001

11

9

10

1010

12

a

11

1011

13

b

12

1100

14

c

13

1101

15

d

14

1110

16

e

1

1

2

1111

17

16

10000

20

10

17

10001

21

11

1

32

1

00000

40

20

42

101100

52

2a

NUMERIC FORMA TS

16)

341

glo.

absolute path.

The

the root of the

system.

alias.

file

When

full,

unadulterated directory path to a

file,

beginning with -

one variable represents another

variable,

it is

said to be an alias for

that variable.

In regular expressions, an anchor

anchor. ter,

is

a special character, or metacharac-

that matches a particular location in a string as

opposed

to

matching

a particu-

lar character.

What you

argument.

give your spouse (or child, or parent)

person what to do. Similarly, an argument routine that

array.

tells

is

when

telling that

data that you give to a program or sub-

the program or subroutine what to

work with and how

to proceed.

A type of variable that holds an ordered list of data.

autovivification.

being used

as if

it

When

something comes into existence automatically

just

by

has always been there. For example:

my $foo; $foo->{bar} ='baz';

In the second statement, $foo

is

did not, an anonymous hash

automatically created and stored in $foo so that

is

used as

if it

holds a reference to a hash. Since

it

we

can assign a key and value in that hash. backreference.

Used within

a regular expression, a backreference

is

a special

sequence consisting of a backslash followed by an integer that stands for the text

matched by a preceding

set

of capturing parentheses of the same number.

342

More

bless.

like a

baptism

blessing

really,

is

the act of dubbing a reference as

belonging to a particular package, providing a basis for

Perl's

object-oriented capa-

bilities.

A structural segment of a

block.

by curly

that are delimited in Perl

A two-valued

Boolean.

program consisting of one or more statements

braces.

(usually true or false) property or variable. Perl does not

have Boolean variables, but

it

does evaluate some expressions (such

expressions) in a Boolean context. This

sion to

real value, the

its

expression

is

A byte

functionality

from a parent

)

and tell(

class, this is

in

which

it

command

Data

of

is

segments

—

tool.

usually a

called chunks.

that can be used as an object.

deeply

bound

to the lexical environ-

explicitly passed to a

to build or create

used to create and return an object

anonymous

arrays

is

and hashes can be

program and/or

something

called a constructor.

program when

it

is

its

files.

A class

else.

The

[

]

and

method

{ }

used to

called constructors (or composers).

degree of interdependency

functions) within a

GLOSSARY

all

line

Something used

The

or

programming

Joining two or more things, usually strings or

concatenation.

coupling.

some

was generated.

invoked from the

create

—

and methods

subroutine that

command line argument.

constructor.

(often the beginning

literate

are presented in relatively small

that defines data

An anonymous

closure.

file

class.

paragraph or two, or a handful of lines of code

A module

functions, a position in a

a class that inherits

Hardcore technical jargon from the noweb

Documentation and code

ment

)

set.

Also called a derived

class.

class.

concerned with only whether the

an 8-bit piece of binary data, often representing

is

a character in the ASCII character

chunk.

while Perl evaluates the expres-

another position in the

relative to

or the previous position).

its

itself is

As used with the seek(

measured in bytes

child

that,

true or false.

te offset. file

condition

means

as conditional

among components

(data structures,

modules.

343

De Volkswagen

debug.

Beetle

sometimes called de bug. In programming,

is

Debugging

errors in syntax or logic are referred to as bugs.

the task of isolating

is

the problems and fixing the code. Telling the compiler/interpreter about something

declure/declardtion.

— Something—

rather than telling

a variable or subroutine

delimiter.

ning and end of something

To undo

A

dispatch table. (i.e.,

do something

else,

such

that

with a statement).

demarks the begin-

as a record, a field, or a string.

The quotation

Perl are that string's delimiters.

the reference in order to follow

the corresponding key

is

it

to

where

it

points.

used.

Wrapping up data and functions

encapsulation.

—

(as

as

hash table of subroutine references that can be called upon

when

dispatched)

to

usually a character or string

marks you use around a string in dereference.

it

—such

(or

methods) into a neat

little

package that has a simple interface compared with the code that actually does the

work.

The

evaluate.

act of

Any

expression.

computing the

literal,

result

of an expression.

variable, subroutine, operator, or

combination of these

that evaluates to a value.

flag.

A marker or switch

depending on

value.

A named piece

function. someplace if

its

that can be set to cause different actions to take place

else (or

of code defined in one place that can be called from

many places)

the code in question

isn't

in the

used for

its

program. Also called subroutines, especially return value.

hash.

A type of variable that holds an

heap.

A data structure that dynamically maintains a partial ordering of the data

it

unordered

list

of key/value

pairs.

contains.

here-document (here-doc). inheritance.

input.

344

multi-line blocks of text.

In object-oriented programming, acquiring characteristics (data

and/or methods) from a parent initialize.

A form of quoting large,

The

act of giving

Data that comes into

class.

an a

initial

value to a variable.

program or subroutine.

GLOSSARY

Replacing a variable with

interpolate.

its

value within double-quoted strings.

In terms of programs, an interpreter reads a program (or a compiled

interpret.

form of a program) and executes the statements contained ating strings, backslash interpretation

of characters

sequentially step through a

In a hash, the key

key.

Any

keyword.

the act of reading certain special sequences

standing for some other (usually

as

To

iterate.

is

named language

is

what you use

built-in function

list

printable) character.

of values (or a

to look

name

non

up

of key/value

pairs).

values.

(such as print, index, open) or other

A

method

or style of

emphasis on source code documentation. Various tools

programming exist to assist

that places

an author in

more human readable programs.

writing

A function that

method.

A flow of control

loop.

A package,

module.

and methods)

The

construct which can cause a statement or series of state-

some number of times.

defined in

to a

its

program

own

file,

that uses

that provides data or functions (or

it.

often represented by one or

more

special symbols.

data that comes out of a program or function.

A namespace where you can define variables

package. interfere

part of a class.

A built-in function,

Operator.

output.

is

a block) to be repeated

(i.e.,

objects

list

construct (such as while or if) in the Perl language.

literate programming (LP).

ments

therein. In terms of cre-

and functions

that won't

with the main:: program's namespace or other packages/modules that

it

uses.

parameter.

parent

See argument.

A class,

class.

functionality to

POD. programs,

The

its

standard

POD

The

from a parent

ferent shapes

GLOSSARY

markup syntax

for

embedding documentation within

Perl

stands for plain old documentation.

polymorphism. inherited

usually designed to be general in form, that provides basic

children classes.

(i.e.,

ability to class.

be different. Child classes can redefine behaviors

Thus, a parent

class

can have children of

many

dif-

they are polymorphic).

345

A

quantifier.

regular expression term referring to the special symbols that

denote some number (possibly zero) of occurrences of the previous character or subexpression.

A

queue.

data structure providing a

rather like a line at the

tion,

something in terms of

then recursion should be thought of as a

means

recursively

to

first

(FIFO) processing order,

itself

makes

spiral definition.

rigidly define at least

nism that can be repeatedly applied

one

for a circular defini-

Defining something

special case

to turn other cases into

and then a mecha-

one of the

special cases.

A pointer to the real data. Or the address where some piece of data

reference.

is

memory.

stored in

regular expression. a variety

first-out

DMV, except you'll want to process your queue faster than that.

If defining

recursion.

first-in,

A way of specifying a set of strings

of pattern-describing symbols and

The

final resulting

satellite data.

The

organization of chunks of data a key.

value of an expression or function.

A

type of value that

string, or a single character.

The

scope.

is

is

often based

on

just a small

The remaining chunk of data may be

to as the satellite data for that key.

scalar.

by using

text.

return value.

segment or piece of data called

(or substrings)

referred

.

singular in nature, like a single number, a single

A type of variable in Perl that holds a scalar value.

range or limits within which a variable

is

active

(i.e.,

exists).

Also

referred to as the visibility of the variable.

sentinel value.

when

A value

used

as a flag

or switch that can be used to determine

a process or loop should stop iterating.

Common name for the

shebang. first line

of a

Perl script

—

#

!

character pair, also called

or shell script and

contains the path to the executable interpreter

slice.

Stack.

A

many is

data structure providing

of dishes next to your

sink.

bang.

other interpreted scripts

The

—

that

often referred to as the shebang line.

(possibly non-contiguous) subset of a

A

pound

list

first-in last-out

of values. processing order, like a stack

Presumably they were stacked there one

at a

time on

top of each other, and you will then wash them one at a time starting from the top

346

GLOSSARY

of the

pile. If

you

something more

are like

like a

Standard input.

STDIN

file

me

heap or

The

however, your dishwashing structure

may

resemble

just a pile.

input stream for a program, accessible in Perl via the

handle.

Standard output.

The output stream

for a program, accessible in Perl via the

STDOUT file handle. Statement.

compare two

Telling the

computer

to

subroutine.

add two numbers,

possibly

empty

(e.g.,

the null string).

See function.

A

subscript.

as

values, or print a string.

A sequence of character data,

String.

do something, such

syntactic construct for accessing or referring to elements of an

array or hash. $array[2] uses a subscript of 2 to refer the value stored in the third

element of the array (subscripts count from

key to

refer to the value stored

substitution operator.

zero).

$hash{key} uses a subscript of

under that key in the hash.

Like the match operator but also able to replace matched

portions of the target string with replacement text.

syntax.

How various symbols can be legitimately put together in a given language.

tangle.

In literate programming, this

the

program code into a format ready

set

In literate programming, this

is

program documentation including any

the source

the process of extracting and assembling

compiled and/or interpreted.

A named location of memory where data may stored and retrieved by name.

variable.

weave.

is

to be

the process of creating the formal typecross reference information specified in

file.

GLOSSARY

347

1

Symbols !

operator 65

-> operator 145

$ARGV

@_

@ARGV

II

operator 89

123, 128

ARGV arrays 5

100

$"

71,336

-a

access

'

abstract data structures

102

heap 316

$.

101,336

linked

$/

102,336

•

'

list

301

,

69 69

associative 71

309

elements 70

queues 307

interpolation 71

336

stacks

301 multi-dimensional 142,

ActiveState 10

$1 110

algorithm 6

+ operator

327

147 nested 142

running time 286, 290

71

subscripts

searching 281

^

69

swapping elements 70

operator 65

** operator

accessor function

slices

% operator 66 && operator 89

.

111,337

assignment 69

$_ 53,88,101,104,111,336 $0 336

*

1

335

$,

$AW

103,

arithmatic operators 65

$ 71, 102,336 53, 54,

51, 102, 103,

111,336

operator 52, 89

operator 104, 198

$!

111,336

103,

alias

88, 128

arrow operator 145 anchor 106, 193

65 65

assembly language 6

$ 106, 193

operator 66

assignment 64

\A 194

7

associative array (see hash) ..

operator 94

\B 107, 194 autovivification 173

operator 65 operator 218

\b 106, 193

103

\Z 194

/

= 64,

47

=> operator 72

43,53

B

^ 106, 193

266

= operator 47, 5 = vs.

\G 194

1

,

64

\B (non-word

and operator 89

anonymous array anonymous hash arguments 123

348

boundary) 107 1 1

56 56,

\b

296

106

backreference 109, 195, 197 backslash escape 62, 105,

1

12

1

backslash interpretation 62

backslash operator 75, 143

D

E

\D 106

-e

-d 335

each 73

backstepping 188

227

backtics

\d 43, 106

backtracking 197 binary 340

DATA

binary search 282

114

blocks 79

60

numeric 61

%ENV eof

data types 60 list

data

scalar data

212

child class

307

cmp

332

exec

226

commands 265

exit

120

D

exponentiation operator 65

265

267

@EXPORT 275 @EXPORT_OK

266

q 264

expression 43, 65

R

external

s

X

267

command 227

F

264

debugging 257-268

154

the perl debugger

-F 335

262

@F

337

factorial

operator 218

debugging steps 262

135

false values

code 243

defined 101

FAQ

comments 24-28

design 33, 35

pseudo-code 36

development cycle 33 coding 40-45

structure

20-21

command line options

171,

design 35-40

maintenance 47-49 specification

34-35

file

99 handle 52,99-103

File::Basename 238

filename 99 filetest

concatenation 66

die 53, 100

concatenation operator 66

documentation 160

continue 85, 87 control statements 36

POD

I

Fibonacci 154

file

239 complement 212

80,90

33

faqgrep 49, 230

debugging 45-47

19-31

style

276

264

228,251

closures 153,

Eratosthenes, sieve of 93 error 53

watch expression 265

53

closedir

60-63

evaluated 91

1

chmod 332 chomp 42 chown 332 close

j

invoking 262

^

337

eval

chaining functions 221

characters

84

1 1

debugger 262, 264 c

105,188

, ,

Date::Manip 242, 278

333 CGI.pm 249 character class

.

eq 43

67-68

bubble sort 284

-c 45,

114

see infinite loop

strings 61

Boolean 94

c

47

endless loop

literal

296

;

_END_

data

bless

:

enclosing 105

114,337

binding 104

binding operator 43, 53

334

elsif

_DATA_

,

161-164

source code 164

operators

229

for loop 85, 101

foreach 52, 88

fork 332 fiinction

cos

278

CPAN

documents 12

235

dot 66

see subroutine

122

double-quoted strings 61

INDEX

349

input record separator 102

LWP::Simple 243

install

194

/g

loop variable 88

modules 236

Getopt

Perl 10

Long 241 Std 239 GIFgraph 244 global variables

41

int

-M 335

interpolation 42,

62

interpreted vs. compiled 9

125,127

lO Socket 331

grep 217

machine language 6 maintenance 33

275, 299, 308

@ISA

m// 43, 103 machine code 6

map 216

H h2xs 277

markup language 161 match operator 43, 103,

lom 114

,

203

hash 71

adding elements 72 deleting elements

/g 113,

key 71

keys 73, 118

key/value pairs 72

Knuth, Donald 165

73

72

values

_

heap 286

last

287

array representation as a class

/s

106,204

/x

205

\A 204 \Z 204

87

and context 206

lexical variables

hexidecimal 61,340

high

205

length 116

316

heap property 287 here-document 118

level

/o

language 12,49

:

167

linear search

282

list

context 74

list

separator 71

matrilineal

mixed

334

/i

203

if

38. 80

"

as

"

'

programming (LP) 36, 164-170

getting

example 166

installing

else 38, elsif

weaving 165 -

local

loop 36,84-89

infinite

for 85,

43

see endless loop

101

fo reach 52,

loop

84

.

infinite

input operator 65, 101, 102

until 41

context 100

-n

334

ne (not equal) 85 next 87, 118

88

indeterminate 84

inheritance 275, 299

89-91

\n 62

determinate 87

index 208

31,63, 124, 125

N

lookbehind 198

337

using 237

my

125, 126

lookahead 198

39,84

indicator

-

logical operators 43,

82

50, 237, 272,

236

purpose 278

tangled 165

import 274

@INC

235

h2xs 274

:

statement

modifier 92

149

274

creating

:

V

structures

mkdir 332 modules 272

literate

-i

286

data 60, 61

literal I

Math::Trig 278

124

line directive

language 7

190

/m 204

nested 149 slices

105

/i

K

73

84

not operator 89 notangle 166

noweb code chunks 165

while 41, 84

INDEX 350

1

continued chunks 166

precedence 65, 89

documentation

print

chunks 165

hne

168

numeric data 61

lookbehind 198

68

priority

directive

queue 320

shortcuts 191 relational operators 81

pseudo-code 36

rename 332 repetition

66

i

repetition operator

Q

require reverse

qw 68

object-oriented

programming 293 classes

294

295

polymorphism 293, 295

340

s \s

106

redo 87 references 74, 134,

53

142-158

anonymous arrays 143 anonymous hashes 143

opendir 228, 251

^

autovivification

146

or operator 43, 52, 89 ,

1

02

dereferencing 144, 158

74

scalar context

Schwartzian Transform 221, 222, 251

scope 79, 123-127

creating 143, 158

output record

63

scalar 41, 60,

assignment 75 operator 185

output field separator 7 1

1

recursion 135, 154 sill

open 52,99, 100 pipe 227

223

rmdir 332

running Perl

228,251

readdir

inheritance 293,

:

range operator 94

example 321

octal 61,

Norman 165

rand 41

encapsulation 293, 294

.

rindex 208

Ramsey,

constructor 295

275 223

scalar context

R

293

66

context 223

list

abstraction

,

-.'t

prototypes 137

push 71

205

.

108

quantifiers

o /o

1

and subroutines 125 searching 281

146

implicit

separator 102

seek 173, 175 to a variable

75

shebang

1

regex 103

P

shift

71

sieve

of Eratosthenes 93

see regular

-p

334

expressions 103

package 273, 295

%SIG 337

regular expressions 43, 103,

184-201

parameters 127

278

sin

slices

and

references

1

34

alternation 107, 185 sort

pattern 103, 104 Perl 29, 45, 207,

POD

49,

anchor 106, 193

242

and prime numbers 196

70

217

binary search 282 linear search

161-164

backreference 109, 195 sorting

formatting tags 162

backstepping 188

minimal pod-page 163

capturing 109, 195

pod2html 162

character class 188

pod2latex 162

concatenation 185

structural tags

1

62

dot

(.)

283-291

bubble sort 284

heap

sort

insertion sort

283

283

106, 185

pop 71 pqtangle 170

INDEX

33

greedy quantifiers 191 split

paragraphs 163

286

selection sort specification

verbatim

282

113, 116

grouping 185, 195 sqrt iteration

185

lookahead 198

95

square root 95

351

standard error 99

declaring 63

'

standard input 99

165-168

tangle

standard output 99

interpolation

.

;

tell

statements 79, 99

STDERR STDIN

top-down design 35 tr// 211

42, 52, 65, 99, 99,

173 list

99

STDOUT

hash 71-73

337 /c

212

/d

212

337

strict

29-31,40, 127

string

number

Is

naming 21-23, 63 scalar 60,

212

vars

286

true values 80,

90

63

60

127,275

SVERSION

conversions 67 strings

loop 88

types

tree structure

62

assignment 42

275

61 truth table 90

W

u

\W

double-quoted 61 single-quoted 62

sub 122 subroutine 122-123

and context 130

106

-w 29-31,67

undef 101

\w 106

90

unless

arguments 123, 128

unlink 332

chaining 221

unshift 71

Wall, Larry 7

wantarray 130

weaving 165, 168 closures 153

;

until

90 while 101

defining 122

names 133

-V

103,112,207 It

-

.

73

variables

assignment to 209

352

335

values

207 208

system 226

continue 85

-V 335

substitution operator 53,

substr

and input operator 101

V

invoking 122

41

..

X X operator 66

array 51, 69-71

assignment 64

.

INDEX

VilPiliitf |No 1019999 03896 770

/^'"'^'^

the.Ubrary Sale of this m«.«s «k oenef lis .

Bosion Public Library

COPLEY SQUARE GENERAL LIBRARY The Date Due Card in the pocket indicates the date on or before which this book should be returned to the Library, Please do not remove cards from this pocket.

www.mdnning.com/johnson

PROGRAMMING LANGUAGES,

PERL ...

straightforward enough for use by

the casual reader but complete

Elements of

Programming with

to stand alone as

Dg^ w- 1

YkX

an excellent

enough

first

learning tool."

—Jim Esten

I

Lead Developer

L Johnson

Andrew

WebDynamic "I

H

ere's a

complete introduction to programming using

written so

Perl,

their first

it's

accessible to those learning Perl as

—

found myself saying, Aha

THAT'S what

damn

that

"

doc was trying

Perl

so

obscvire

to say!'

—Brad Fenwick

programming language.

Software Engineer

With examples ranging from a useful utility to FAQs to a web client for tracking and charting

stock quotes to

an object-oriented student grading system,

book

a practical,

this

search the Perl

offers

you

hands-on approach to learning programming the

Xview Solutions "...

very useful to a

Perl

newcomer

to

both

and programming."

—Randy Kobes

Perl way.

Professor of Physics

What's inside

The

and design

and the software development

®

Style

•

Full descriptions of Perl's data types, variables, operators,

and control *

issues

University of Winnipeg

cycle

"Johnson this

structures

very

clear,

and that

book apart from the

—

In-depth coverage of Perl's regular expressions

is

sets

others."

Patrick Gardella

Vice President *

References and nested data structures

®

Documentation and

*

Text and

list

Literate

Whetstone Logic,

Inc.

Programming "...

manipulation

•

Debugging techniques

®

Using and writing modules

•

Object-oriented programming and abstract data structures

book I've seen so far that programming through Perl.

the only

teaches

I would certainly recommend newcomer to programming."

it

to a

—Brad Murray Senior Software Analyst

Andrew rience.

L.

Johnson has

He

more than

1

5 years

of programming expe-

Alcatel

Canada

has published articles in scientific journals and the

Linux Journal, and has taught and tutored students

in

both

beginning and advanced programming topics. Andrew has a master's degree in anthropology.

Author responds on the Web to questions from our readers -V-

Squree code available online

53495 9 '781884"777806

MANNING

$34.95 US/$50.95 Canada

ISBN l-flflM777-flD-S