Hide Notes 

Slide 1: Teach Yourself Perl 5 in 21 days David Till Table of Contents: Introduction q q q q q q Who Should Read This Book? Special Features of This Book Programming Examples End-of-Day Q& A and Workshop Conventions Used in This Book What You'll Learn in 21 Days Week 1 Week at a Glance q Where You're Going Day 1 Getting Started q q q q q q q q What Is Perl? How Do I Find Perl? r Where Do I Get Perl? r Other Places to Get Perl A Sample Perl Program Running a Perl Program r If Something Goes Wrong The First Line of Your Perl Program: How Comments Work r Comments Line 2: Statements, Tokens, and <STDIN> r Statements and Tokens r Tokens and White Space r What the Tokens Do: Reading from Standard Input Line 3: Writing to Standard Output r Function Invocations and Arguments Error Messages
Slide 2: q q q q Interpretive Languages Versus Compiled Languages Summary Q&A Workshop r Quiz r Exercises Day 2 Basic Operators and Control Flow q q q q q q q q q q q q q q Storing in Scalar Variables Assignment r The Definition of a Scalar Variable r Scalar Variable Syntax r Assigning a Value to a Scalar Variable Performing Arithmetic r Example of Miles-to-Kilometers Conversion r The chop Library Function Expressions r Assignments and Expressions Other Perl Operators Introduction to Conditional Statements The if Statement r The Conditional Expression r The Statement Block r Testing for Equality Using == r Other Comparison Operators Two-Way Branching Using if and else Multi-Way Branching Using elsif Writing Loops Using the while Statement Nesting Conditional Statements Looping Using the until Statement Summary Q&A Workshop r Quiz r Exercises Day 3 Understanding Scalar Values q q What Is a Scalar Value? Integer Scalar Values r Integer Scalar Value Limitations
Slide 3: q q q q q q q Floating-Point Scalar Values r Floating-Point Arithmetic and Round-Off Error Using Octal and Hexadecimal Notation r Decimal Notation r Octal Notation r Hexadecimal Notation r Why Bother? Character Strings r Using Double-Quoted Strings r Escape Sequences r Single-Quoted Strings Interchangeability of Strings and Numeric Values r Initial Values of Scalar Variables Summary Q&A Workshop r Quiz r Exercises Day 4 More Operators q q q q q q Using the Arithmetic Operators r Exponentiation r The Remainder Operator r Unary Negation Using Comparison Operators r Integer-Comparison Operators r String-Comparison Operators r String Comparison Versus Integer Comparison r Comparison and Floating-Point Numbers Using Logical Operators r Evaluation Within Logical Operators r Logical Operators as Subexpressions Using Bit-Manipulation Operators r What Bits Are and How They Are Used r The Bit-Manipulation Operators Using the Assignment Operators r Assignment Operators as Subexpressions Using Autoincrement and Autodecrement r The Autoincrement Operator Pre-Increment r The Autoincrement Operator Post-Increment
Slide 4: q q q q q q The Autodecrement Operator r Using Autoincrement With Strings The String Concatenation and Repetition Operators r The String-Concatenation Operator r The String-Repetition Operator r Concatenation and Assignment Other Perl Operators r The Comma Operator r The Conditional Operator The Order of Operations r Precedence r Associativity r Forcing Precedence Using Parentheses Summary Q&A Workshop r Quiz r Exercises r Day 5 Lists and Array Variables q q q q q q q q q Introducing Lists Scalar Variables and Lists r Lists and String Substitution Storing Lists in Array Variables Accessing an Element of an Array Variable r More Details on Array Element Names Using Lists and Arrays in Perl Programs r Using Brackets and Substituting for Variables Using List Ranges r Expressions and List Ranges More on Assignment and Array Variables r Copying from One Array Variable to Another r Using Array Variables in Lists r Substituting for Array Variables in Strings r Assigning to Scalar Variables from Array Variables Retrieving the Length of a List Using Array Slices r Using List Ranges in Array-Slice Subscripts r Using Variables in Array-Slice Subscripts r Assigning to Array Slices
Slide 5: q q q q q Overlapping Array Slices r Using the Array-Slice Notation as a Shorthand Reading an Array from the Standard Input File Array Library Functions r Sorting a List or Array Variable r Reversing a List or Array Variable r Using chop on Array Variables r Creating a Single String from a List r Splitting a String into a List r Other List-Manipulation Functions Summary Q&A Workshop r Quiz r Exercises r Day 6 Reading from and Writing to Files q q q q q q q Opening a File r The File Variable r The Filename r The File Mode r Checking Whether the Open Succeeded Reading from a File r File Variables and the Standard Input File r Terminating a Program Using die r Reading into Array Variables Writing to a File r The Standard Output File Variable r Merging Two Files into One Redirecting Standard Input and Standard Output The Standard Error File Closing a File Determining the Status of a File r File-Test Operator Syntax r Available File-Test Operators r More on the -e Operator r Testing for Read Permission-the -r Operator r Checking for Other Permissions r Checking for Empty Files r Using File-Test Operators with File Variables
Slide 6: q q q q q q Reading from a Sequence of Files r Reading into an Array Variable Using Command-Line Arguments as Values r ARGV and the <> Operator Opening Pipes Summary Q&A Workshop r Quiz r Exercises Day 7 Pattern Matching q q q q q Introduction The Match Operators r Match-Operator Precedence Special Characters in Patterns r The + Character r The [] Special Characters r The * and ? Special Characters r Escape Sequences for Special Characters r Matching Any Letter or Number r Anchoring Patterns r Variable Substitution in Patterns r Excluding Alternatives r Character-Range Escape Sequences r Matching Any Character r Matching a Specified Number of Occurrences r Specifying Choices r Reusing Portions of Patterns r Pattern-Sequence Scalar Variables r Special-Character Precedence r Specifying a Different Pattern Delimiter Pattern-Matching Options r Matching All Possible Patterns r Ignoring Case r Treating the String as Multiple Lines r Evaluating a Pattern Only Once r Treating the String as a Single Line r Using White Space in Patterns The Substitution Operator
Slide 7: q q q q q Using Pattern-Sequence Variables in Substitutions r Options for the Substitution Operator r Evaluating a Pattern Only Once r Treating the String as Single or Multiple Lines r Using White Space in Patterns r Specifying a Different Delimiter The Translation Operator r Options for the Translation Operator Extended Pattern-Matching r Parenthesizing Without Saving in Memory r Embedding Pattern Options r Positive and Negative Look-Ahead r Pattern Comments Summary Q&A Workshop r Quiz r Exercises r Week 1 Week 1 in Review Week 2 Week 2 at a Glance q Where You're Going Day 8 More Control Structures q q q q q q q q Using Single-Line Conditional Statements r Problems with Single-Line Conditional Statements Looping Using the for Statement r Using the Comma Operator in a for Statement Looping Through a List: The foreach Statement r The foreach Local Variable r Changing the Value of the Local Variable r Using Returned Lists in the foreach Statement The do Statement Exiting a Loop Using the last Statement Using next to Start the Next Iteration of a Loop The redo Statement Using Labeled Blocks for Multilevel Jumps
Slide 8: q q q q q Using next and redo with Labels The continue Block The goto Statement Summary Q&A Workshop r Quiz r Exercises r Day 9 Using Subroutines q q q q q q q q q q q q q q q What Is a Subroutine? Defining and Invoking a Subroutine r Forward References to Subroutines Returning a Value from a Subroutine r Return Values and Conditional Expressions The return Statement Using Local Variables in Subroutines r Initializing Local Variables Passing Values to a Subroutine r Passing a List to a Subroutine Calling Subroutines from Other Subroutines Recursive Subroutines Passing Arrays by Name Using Aliases Using the do Statement with Subroutines Specifying the Sort Order Predefined Subroutines r Creating Startup Code Using BEGIN r Creating Termination Code Using END r Handling Non-Existent Subroutines Using AUTOLOAD Summary Q&A Workshop r Quiz r Exercises Day 10 Associative Arrays q q q Limitations of Array Variables Definition Referring to Associative Array Elements
Slide 9: q q q q q q q q q q Adding Elements to an Associative Array Creating Associative Arrays Copying Associative Arrays from Array Variables Adding and Deleting Array Elements Listing Array Indexes and Values Looping Using an Associative Array Creating Data Structures Using Associative Arrays r Linked Lists r Structures r Trees r Databases r Example: A Calculator Program Summary Q&A Workshop r Quiz r Exercises Day 11 Formatting Your Output q q q q q q q q q q q Defining a Print Format Displaying a Print Format Displaying Values in a Print Format r Creating a General-Purpose Print Format r Choosing a Value-Field Format r Printing Value-Field Characters r Using the Multiline Field Format Writing to Other Output Files r Saving the Default File Variable Specifying a Page Header r Changing the Header Print Format Setting the Page Length r Using print with Pagination Formatting Long Character Strings r Eliminating Blank Lines When Formatting r Supplying an Indefinite Number of Lines Formatting Output Using printf Summary Q&A Workshop r Quiz
Slide 10: r Exercises Day 12 Working with the File System q q q q q q q File Input and Output Functions r Basic Input and Output Functions r Skipping and Rereading Data r System Read and Write Functions r Reading Characters Using getc r Reading a Binary File Using binmode Directory-Manipulation Functions r The mkdir Function r The chdir Function r The opendir Function r The closedir Function r The readdir Function r The telldir and seekdir Functions r The rewinddir Function r The rmdir Function File-Attribute Functions r File-Relocation Functions r Link and Symbolic Link Functions r File-Permission Functions r Miscellaneous Attribute Functions Using DBM Files r The dbmopen Function r The dbmclose Function Summary Q&A Workshop r Quiz r Exercises Day 13 Process, String, and Mathematical Functions q q Process- and Program-Manipulation Functions r Starting a Process r Terminating a Program or Process r Execution Control Functions r Miscellaneous Control Functions Mathematical Functions
Slide 11: q q q q The sin and cos Functions r The atan2 Function r The sqrt Function r The exp Function r The log Function r The abs Function r The rand and srand Functions String-Manipulation Functions r The index Function r The rindex Function r The length Function r Retrieving String Length Using tr r The pos Function r The substr Function r The study Function r Case Conversion Functions r The quotemeta Function r The join Function r The sprintf Function Summary Q&A Workshop r Quiz r Exercises r Day 14 Scalar-Conversion and List-Manipulation Functions q q q q q q q q q q The chop Function The chomp Function The crypt Function The hex Function The int Function The oct Function r The oct Function and Hexadecimal Integers The ord and chr Functions The scalar Function The pack Function r The pack Function and C Data Types The unpack Function r Unpacking Strings r Skipping Characters When Unpacking
Slide 12: q q q q q q q q The unpack Function and uuencode The vec Function The defined Function The undef Function Array and List Functions r The grep Function r The splice Function r The shift Function r The unshift Function r The push Function r The pop Function r Creating Stacks and Queues r The split Function r The sort and reverse Functions r The map Function r The wantarray Function Associative Array Functions r The keys Function r The values Function r The each Function r The delete Function r The exists Function Summary Q&A Workshop r Quiz r Exercises r Week 2 Week 2 in Review Week 3 Week 3 at a Glance q Where You're Going Day 15 System Functions q System Library Emulation Functions r The getgrent Function r The setgrent and endgrent Functions r The getgrnam Function
Slide 13: q q The getgrid Function r The getnetent Function r The getnetbyaddr Function r The getnetbyname Function r The setnetent and endnetent Functions r The gethostbyaddr Function r The gethostbyname Function r The gethostent, sethostent, and endhostent Functions r The getlogin Function r The getpgrp and setpgrp Functions r The getppid Function r The getpwnam Function r The getpwuid Function r The getpwent Function r The setpwent and endpwent Functions r The getpriority and setpriority Functions r The getprotoent Function r The getprotobyname and getprotobynumber Functions r The setprotoent and endprotoent Functions r The getservent Function r The getservbyname and getservbyport Functions r The setservent and endservent Functions r The chroot Function r The ioctl Function r The alarm Function r Calling the System select Function r The dump Function Socket-Manipulation Functions r The socket Function r The bind Function r The listen Function r The accept Function r The connect Function r The shutdown Function r The socketpair Function r The getsockopt and setsockopt Functions r The getsockname and getpeername Functions The UNIX System V IPC Functions r IPC Functions and the require Statement r The msgget Function r The msgsnd Function r
Slide 14: q q q The msgrcv Function r The msgctl Function r The shmget Function r The shmwrite Function r The shmread Function r The shmctl Function r The semget Function r The semop Function r The semctl Function Summary Q&A Workshop r Quiz r Exercises r Day 16 Command-Line Options q q q q q q q q q q q q q q q q Specifying Options r Specifying Options on the Command Line r Specifying an Option in the Program The -v Option: Printing the Perl Version Number The -c Option: Checking Your Syntax The -w Option: Printing Warnings r Checking for Possible Typos r Checking for Redefined Subroutines r Checking for Incorrect Comparison Operators The -e Option: Executing a Single-Line Program The -s Option: Supplying Your Own Command-Line Options r The -s Option and Other Command-Line Arguments The -P Option: Using the C Preprocessor r The C Preprocessor: A Quick Overview The -I Option: Searching for C Include Files The -n Option: Operating on Multiple Files The -p Option: Operating on Files and Printing The -i Option: Editing Files r Backing Up Input Files Using the -i Option The -a Option: Splitting Lines The -F Option: Specifying the Split Pattern The -0 Option: Specifying Input End-of-Line The -l Option: Specifying Output End-of-Line The -x Option: Extracting a Program from a Message
Slide 15: q q q q q Miscellaneous Options r The -u Option r The -U Option r The -S Option r The -D Option r The -T Option: Writing Secure Programs The -d Option: Using the Perl Debugger Summary Q&A Workshop r Quiz r Exercises Day 17 System Variables q Global Scalar Variables r The Default Scalar Variable: $_ r The Program Name: $0 r The User ID: $< and $> r The Group ID: $( and $) r The Version Number: $] r The Input Line Separator: $/ r The Output Line Separator: $ r The Output Field Separator: $, r The Array Element Separator: $" r The Number Output Format: $# r The eval Error Message: $@ r The System Error Code: $? r The System Error Message: $! r The Current Line Number: $. r Multiline Matching: $* r The First Array Subscript: $[ r Multidimensional Associative Arrays and the $; Variable r The Word-Break Specifier: $: r The Perl Process ID: $$ r The Current Filename: $ARGV r The Write Accumulator: $^A r The Internal Debugging Value: $^D r The System File Flag: $^F r Controlling File Editing Using $^I r The Format Form-Feed Character: $^L
Slide 16: q q q q Controlling Debugging: $^P r The Program Start Time: $^T r Suppressing Warning Messages: $^W r The $^X Variable Pattern System Variables r Retrieving Matched Subpatterns r Retrieving the Entire Pattern: $& r Retrieving the Unmatched Text: the $` and $' Variables r The $+ Variable File System Variables r The Default Print Format: $~ r Specifying Page Length: $= r Lines Remaining on the Page: $r The Page Header Print Format: $^ r Buffering Output: $| r The Current Page Number: $% Array System Variables r The @_ Variable r The @ARGV Variable r The @F Variable r The @INC Variable r The %INC Variable r The %ENV Variable r The %SIG Variable Built-In File Variables r STDIN, STDOUT, and STDERR r r r r ARGV DATA q q q q The Underscore File Variable Specifying System Variable Names as Words Summary Q&A Workshop r Quiz r Exercises Day 18 References in Perl 5 q q q Introduction to References Using References Using the Backslash Operator
Slide 17: q q q q q q q q q q q q References and Arrays Multidimensional Arrays References to Subroutines r Using Subroutine Templates Using Subroutines to Work with Multiple Arrays r Pass By Value or By Reference? References to File Handles r What Does the *variable Operator Do? Using Symbolic References… Again r Declaring Variables with Curly Braces More on Hard Versus Symbolic References For More Information Summary Q&A Workshop r Quiz Exercises Day 19 Object-Oriented Programming in Perl q q q q q q q q q q q q q q q An Introduction to Modules r The Three Important Rules Classes in Perl Creating a Class Blessing a Constructor r Instance Variables Methods Exporting Methods Invoking Methods Overrides Destructors Inheritance Overriding Methods A Few Comments About Classes and Objects in Perl Summary Q&A Workshop r Quiz r Exercises Day 20 Miscellaneous Features of Perl
Slide 18: q q q q q q q q q q q q q q q q The require Function r The require Function and Subroutine Libraries r Using require to Specify a Perl Version The $#array Variables r Controlling Array Length Using $#array Alternative String Delimiters r Defining Strings Using << Special Internal Values Using Back Quotes to Invoke System Commands Pattern Matching Using ?? and the reset Function r Using reset with Variables Other Features of the <> Operator r Scalar Variable Substitution and <> r Creating a List of Filenames Global Indirect References and Aliases Packages r Defining a Package r Switching Between Packages r The main Package r Referring to One Package from Another r Specifying No Current Package r Packages and Subroutines r Defining Private Data Using Packages r Packages and System Variables r Accessing Symbol Tables Modules r Creating a Module r Importing Modules Into Your Program r Using Predefined Modules Using Perl in C Programs Perl and CGI Scripts Translators and Other Supplied Code Summary Q&A Workshop r Quiz r Exercises Day 21 The Perl Debugger
Slide 19: q q q q q q q q q q q Entering and Exiting the Perl Debugger r Entering the Debugger r Exiting the Debugger Listing Your Program r The l command r The - Command r The w Command r The // and ?? Commands r The S Command Stepping Through Programs r The s Command r The n Command r The f command r The Carriage-Return Command r The r Command Displaying Variable Values r The X Command r The V Command Breakpoints r The b Command r The c Command r The L Command and Breakpoints r The d and D Commands Tracing Program Execution Line Actions r The a Command r The A Command r The < and > Commands r Displaying Line Actions Using the L Command Other Debugging Commands r Executing Other Perl Statements r The H Command: Listing Preceding Commands r The ! Command: Executing Previous Commands r The T Command: Stack Tracing r The p Command: Printing an Expression r The = Command: Defining Aliases r Predefining Aliases r The h Command: Debugger Help Summary Q&A Workshop
Slide 20: r Quiz Week 3 Week 3 in Review Appendix A Answers q q q q q q q q q q q q Answers for Day 1, "Getting Started" r Quiz r Exercises Answers for Day 2, "Basic Operators and Control Flow" r Quiz r Exercises Answers for Day 3, "Understanding Scalar Values" r Quiz r Exercises Answers for Day 4, "More Operators" r Quiz r Exercises Answers for Day 5, "Lists and Array Variables" r Quiz r Exercises Answers for Day 6, "Reading from and Writing to Files" r Quiz r Exercises Answers for Day 7, "Pattern Matching" r Quiz r Exercises Answers for Day 8, "More Control Structures" r Quiz r Exercises Answers for Day 9, "Using Subroutines" r Quiz r Exercises Answers for Day 10, "Associative Arrays" r Quiz r Exercises Answers for Day 11, "Formatting Your Output" r Quiz r Exercises Answers for Day 12, "Working with the File System" r Quiz
Slide 21: q q q q q q q q q Exercises Answers for Day 13, "Process, String, and Mathematical Functions" r Quiz r Exercises Answers for Day 14, "Scalar-Conversion and List-Manipulation Functions" r Quiz r Exercises Answers for Day 15, "System Functions" r Quiz r Exercises Answers for Day 16, "Command-Line Options" r Quiz r Exercises Answers for Day 17, "System Variables" r Quiz r Exercises Answers for Day 18, "References in Perl 5" r Quiz r Exercises Answers for Day 19, "Object-Oriented Programming in Perl" r Quiz r Exercises Answers for Day 20, "Miscellaneous Features of Perl" r Quiz r Exercises Answers for Day 21, "The Perl Debugger" r Quiz r Appendix B ASCII Character Set Credits Copyright © 1996 by Sams Publishing SECOND EDITION All rights reserved. No part of this book shall be reproduced, stored in a retrieval
Slide 22: system, or transmitted by any means, electronic, mechanical, photocopying, recording, or otherwise, without written permission from the publisher. No patent liability is assumed with respect to the use of the information contained herein. Although every precaution has been taken in the preparation of this book, the publisher and author assume no responsibility for errors or omissions. Neither is any liability assumed for damages resulting from the use of the information contained herein. For information, address Sams Publishing, 201 W. 103rd St., Indianapolis, IN 46290. International Standard Book Number: 0-672-30894-0 HTML conversion by : M/s. LeafWriters (India) Pvt. Ltd. Website : http://leaf.stpn.soft.net e-mail : leafwriters@leaf.stpn.soft.net Richard K. Swadley Publisher and President Dean Miller Development Manager Marketing Manager John Pierce Acquisitions Editor Chris Denny Software Development Specialist Copy Editor Editorial Coordinator Formatter Steve Straiger Acquisitions Manager Managing Editor Greg Wiegand Cindy Morrow Kristina Perry Assistant Marketing Manager Angelique Brittingham, Development Keith Davenport Editors Production Editor Tonya R. Simpson Kimberly K. Hannel Bill Whitmer Frank Sinclair Technical Reviewer Technical Edit Coordinator Editorial Assistants Elliotte Rusty Harold Lynette Quinn Carol Ackerman, Andi Richter Rhonda, TinchMize Gary Adair Brad Chinn Cover Designer Copy Writer Production Tim Amrhein Peter Fuller Book Designer Production Team Supervisor Michael Brumitt, Charlotte Clapp, Jason Hand, Sonja Hart, Louisa Klucznik, Ayanna Lacey, Clint Lahnen, Paula Lowell, Laura Robbins, Bobbi Satterfield, Carol Sheehan, Chris Wilcox Acknowledgments
Slide 23: I would like to thank the following people for their help: q q q David Macklem at Sietec Open Systems for allowing me to take the time off to work on the first edition of this book Everyone at Sams Publishing, for their efforts and encouragement Jim Gardner, for telling the people at Sams Publishing about me I'd also like to thank all those friends of mine (you know who you are) who tolerated my going stir-crazy as my deadlines approached. About the Authors David Till David Till is a technical writer working in Toronto, Ontario, Canada. He holds a master's degree in computer science from the University of Waterloo; programming languages was his major field of study. He also has worked in compiler development and on version-control software. He lists his hobbies as "writing, comedy, walking, duplicate bridge, and fanatical support of the Toronto Blue Jays." He can be reached via e-mail at am671@freenet.toronto.on.ca or davet@klg.com, or on the World Wide Web at http://www.interlog.com/~davet/. Kamran Husain Kamran Husain is a software consultant with experience in UNIX system programming. He has dabbled in all sorts of software for real-time systems applications, telecommunications, seismic data acquisition and navigation, X Window/Motif and Microsoft Windows applications. He refuses to divulge any more of his qualifications. Kamran offers consulting services and training classes through his company, MPS Inc., in Houston, Texas. He is an alumnus of the University of Texas at Austin. You can reach Kamran through Sams Publishing or via e-mail at khusain@neosoft.com or mpsi@aol.com. Introduction This book is designed to teach you the Perl programming language in just 21 days. When you finish reading this book, you will have learned why Perl is growing rapidly in popularity: It is powerful enough to perform many useful, sophisticated programming tasks, yet it is easy to learn and use.
Slide 24: Who Should Read This Book? No previous programming experience is required for you to learn everything you need to know about programming with Perl from this book. In particular, no knowledge of the C programming language is required. If you are familiar with other programming languages, learning Perl will be a snap. The only assumption this book does make is that you are familiar with the basics of using the UNIX operating system. Special Features of This Book This book contains some special elements that help you understand Perl features and concepts as they are introduced: q q q q q Syntax boxes DO/DON'T boxes Notes Warnings Tips Syntax boxes explain some of the more complicated features of Perl, such as the control structures. Each syntax box consists of a formal definition of the feature followed by an explanation of the elements of the feature. Here is an example of a syntax box: The syntax of the for statement is for (expr1; expr2; expr3) { statement_block } expr1 is the loop initializer. It is evaluated only once, before the start of the loop. expr2 is the conditional expression that terminates the loop. The conditional expression in expr2 behaves just like the ones in while and if statements: If its value is zero, the loop is terminated, and if its value is nonzero, the loop is executed. statement_block is the collection of statements that is executed if (and when) expr2 has a nonzero value. expr3 is executed once per iteration of the loop, and is executed after the last statement in statement_block is executed.
Slide 25: Don't try to understand this definition yet! DO/DON'T boxes present the do's and don'ts for a particular task or feature. Here is an example of such a box: DON'T confuse the | operator (bitwise OR) with the || operator (logical OR). DO make sure you are using the proper bitwise operator. It's easy to slip and assume you want bitwise OR when you really want bitwise AND. (Trust me. Notes are explanations of interesting properties of a particular program feature. Here is an example of a note: NOTE In left-justified output, the value being displayed appears at the left end of the value field. In rightjustified output, the value being displayed appears at the right end of the value field. Warnings warn you of programming pitfalls to avoid. Here is a typical warning: You cannot use the last statement inside the do statement. The do statement, although it behaves like the other control structures, is actually implemented differently. Tips are hints on how to write your Perl programs better. Here is an example of a tip: TIP
Slide 26: It is a good idea to use all uppercase letters for your file variable names. This makes it easier to distinguish file variable names from other variable names and from reserved words. Programming Examples Each feature of Perl is illustrated by examples of its use. In addition, each chapter of this book contains many useful programming examples complete with explanations; these examples show you how you can use Perl features in your own programs. Each example contains a listing of the program, the input required by and the output generated by the program, and an analysis of how the program works. Special icons are used to point out each part of the example: Type, Input-Output, and Analysis. In the Input-Output example following Listing IN.1, there are some special typographic conventions. The input you enter is shown in bold monospace type, and the output generated by the system or the program is shown in plain monospace type. The system prompt ($ in the examples in this book) is shown so that you know when a command is to be entered on the command line. Listing IN.1. A simple Perl program with comments. 1: #!/usr/local/bin/perl 2: # this program reads a line of input, and writes the line 3: # back out 4: $inputline = <STDIN>; 5: print( $inputline ); # read a line of input # write the line out $ programIN_1 This is a line of input. This is a line of input. $
Slide 27: Line 1 is the header comment. Lines 2 and 3 are comments, not executable lines of code. Line 4 reads a line of input. Line 5 writes the line of input on your screen. End-of-Day Q& A and Workshop Each day ends with a Q&A section containing answers to common questions relating to that day's material. There also is a Workshop at the end of each day that consists of quiz questions and programming exercises. The exercises often include BUG BUSTER exercises that help you spot some of the common bugs that crop up in Perl programs. The answers to these quiz questions as well as sample solutions for the exercises are presented in Appendix A, "Answers." Conventions Used in This Book This book uses different typefaces to help you differentiate between Perl code and regular English, and also to help you identify important concepts. q q q q Actual Perl code is typeset in a special monospace font. You'll see this font used in listings and the Input-Output examples, as well as in code snippets. In the explanations of Perl features, commands, filenames, statements, variables, and any text you see on the screen also are typeset in this font. Command input and anything that you are supposed to enter appears in a bold monospace font. You'll see this mainly in the Input-Output examples. Placeholders in syntax descriptions appear in an italic monospace font. Replace the placeholder with the actual filename, parameter, or whatever element it represents. Italics highlight technical terms when they first appear in the text and are sometimes used to emphasize important points. What You'll Learn in 21 Days In your first week of learning Perl, you'll learn enough of the basics of Perl to write many useful Perl programs. Here's a summary of what you'll learn in Week 1: Day 1, "Getting Started," tells you how to get Perl, how to run Perl programs, and how to read from your keyboard and write to your screen. Day 2, "Basic Operators and Control Flow," teaches you about simple arithmetic, how to assign a value to a scalar variable, and how to control execution using conditional statements.
Slide 28: Day 3, "Understanding Scalar Values," teaches you about integers, floating-point numbers, and character strings. It also shows you that all three are interchangeable in Perl. Day 4, "More Operators," tells you all about operators and expressions in Perl and talks about operator associativity and precedence. Day 5, "Lists and Array Variables," introduces you to lists, which are collections of values, and to array variables, which store lists. Day 6, "Reading from and Writing to Files," tells you how to interact with your file system by reading from input files, writing to output files, and testing for particular file attributes. Day 7, "Pattern Matching," describes pattern-matching in Perl and shows how you can substitute values and translate sets of characters in text strings. By the end of Week 2, you'll have mastered almost all the features of Perl; you'll also have learned about many of the library functions supplied with the language. Here's a summary of what you'll learn: Day 8, "More Control Structures," discusses the control flow statements not previously covered. Day 9, "Using Subroutines," shows how you can break your program into smaller, more manageable, chunks. Day 10, "Associative Arrays," introduces one of the most powerful and useful constructs in Perl-arrays-and it shows how you can use these arrays to simulate other data structures. Day 11, "Formatting Your Output," shows how you can use Perl to produce tidy reports. Day 12, "Working with the File System," shows how you can interact with your system's directory structure. Day 13, "Process, String, and Mathematical Functions," describes the library functions that interact with processes running on the system. It also describes the functions that perform trigonometric and other mathematical operations, and the functions that operate on strings.
Slide 29: Day 14, "Scalar-Conversion and List-Manipulation Functions," describes the library functions that convert values from one form to another and the functions that work with lists and array variables. By the end of Week 3, you'll know all the features and capabilities of Perl. It covers the rest of the Perl library functions and describes some of the more esoteric concepts of the language. Here's a summary of what you'll learn: Day 15, "System Functions," describes the functions that manipulate the Berkeley UNIX and UNIX System V environments. Day 16, "Command-Line Options," describes the options you can supply with Perl to control how your program runs. Day 17, "System Variables," describes the built-in variables that are included automatically as part of every Perl program. Day 18, "References in Perl 5," describes the pointer and reference features of Perl 5, including multi-dimensional arrays. Day 19, "Object-Oriented Programming in Perl," describes the objectoriented capabilities added to Perl 5. These enable you to hide information and divide your program into individual file modules. Day 20, "Miscellaneous Features of Perl," covers some of the more exotic or obscure features of the language. Day 21, "The Perl Debugger," shows you how to use the Perl debugger to discover errors quickly.
Slide 30: Week 1 Week at a Glance CONTENTS q Where You're Going In your first week of teaching yourself Perl, you'll learn enough of the basics to write many useful Perl programs. Although some experience in using a programming language will be an advantage as you read this book, it is not required. In particular, you don't need to know the C programming language before you read this book. To use this book effectively, you should be able to try out some of the features of Perl as you learn them. To do this, you should have Perl running on your system. If you don't have Perl, Day 1, "Getting Started," tells how you can get it for free. Each chapter of this book contains quiz and exercise questions that test you on the material covered in the day's lesson. These questions are answered in Appendix A, "Answers." Where You're Going The first week covers the essentials of Perl. Here's a summary of what you'll learn. Day 1, "Getting Started," tells you how to get Perl, how to run Perl programs, and how to read input from your keyboard and write output to your screen. Day 2, "Basic Operators and Control Flow," teaches you about simple arithmetic, how to assign a value to a scalar variable, and how to control execution using conditional statements. Day 3, "Understanding Scalar Values," teaches you about integers, floating-point
Slide 31: numbers, and character strings. It also shows you that all three are interchangeable in Perl. Day 4, "More Operators," tells you all about operators and expressions in Perl and talks about operator associativity and precedence. Day 5, "Lists and Array Variables," introduces you to lists, which are collections of values, and to array variables, which store lists. Day 6, "Reading from and Writing to Files," tells you how to interact with your file system by reading from input files, writing to output files, and testing for particular file attributes. Finally, Day 7, "Pattern Matching," describes pattern matching in Perl and shows how you can substitute values and translate sets of characters in text strings. This is quite a bit of material to learn in one week; however, by the end of the week you'll know most of the essentials of Perl and will be able to write many useful programs.
Slide 32: Chapter 1 Getting Started CONTENTS q q q q q q q q q q q q What Is Perl? How Do I Find Perl? r Where Do I Get Perl? r Other Places to Get Perl A Sample Perl Program Running a Perl Program r If Something Goes Wrong The First Line of Your Perl Program: How Comments Work r Comments Line 2: Statements, Tokens, and <STDIN> r Statements and Tokens r Tokens and White Space r What the Tokens Do: Reading from Standard Input Line 3: Writing to Standard Output r Function Invocations and Arguments Error Messages Interpretive Languages Versus Compiled Languages Summary Q&A Workshop r Quiz r Exercises Welcome to Teach Yourself Perl 5 in 21 Days. Today you'll learn about the following: q q q q q q What Perl is and why Perl is useful How to get Perl if you do not already have it How to run Perl programs How to write a very simple Perl program The difference between interpretive and compiled programming languages What an algorithm is and how to develop one
Slide 33: What Is Perl? Perl is an acronym, short for Practical Extraction and Report Language. It was designed by Larry Wall as a tool for writing programs in the UNIX environment and is continually being updated and maintained by him. For its many fans, Perl provides the best of several worlds. For instance: q q q Perl has the power and flexibility of a high-level programming language such as C. In fact, as you will see, many of the features of the language are borrowed from C. Like shell script languages, Perl does not require a special compiler and linker to turn the programs you write into working code. Instead, all you have to do is write the program and tell Perl to run it. This means that Perl is ideal for producing quick solutions to small programming problems, or for creating prototypes to test potential solutions to larger problems. Perl provides all the features of the script languages sed and awk, plus features not found in either of these two languages. Perl also supports a sed-to-Perl translator and an awk-to-Perl translator. In short, Perl is as powerful as C but as convenient as awk, sed, and shell scripts. NOTE This book assumes that you are familiar with the basics of using the UNIX operating system As you'll see, Perl is very easy to learn. Indeed, if you are familiar with other programming languages, learning Perl is a snap. Even if you have very little programming experience, Perl can have you writing useful programs in a very short time. By the end of Day 2, "Basic Operators and Control Flow," you'll know enough about Perl to be able to solve many problems. How Do I Find Perl? To find out whether Perl already is available on your system, do the following: q q If you are currently working in a UNIX programming environment, check to see whether the file /usr/local/bin/perl exists. If you are working in any other environment, check the place where you normally keep your executable programs, or check the directories accessible from your PATH environment variable.
Slide 34: If you do not find Perl in this way, talk to your system administrator and ask whether she or he has Perl running somewhere else. If you don't have Perl running in your environment, don't despair-read on! Where Do I Get Perl? One of the reasons Perl is becoming so popular is that it is available free of charge to anyone who wants it. If you are on the Internet, you can obtain a copy of Perl with filetransfer protocol (FTP). The following is a sample FTP session that transfers a copy of the Perl distribution. The items shown in boldface type are what you would enter during the session. $ ftp prep.ai.mit.edu Connected to prep.ai.mit.edu. 220 aeneas FTP server (Version wu-2.4(1) Thu Apr 14 20:21:35 EDT 1994) ready. Name (prep.ai.mit.edu:dave): anonymous 331 Guest login ok, send your complete e-mail address as password. Password: 230-Welcome, archive user! 230230-If you have problems downloading and are seeing "Access denied" or 230-"Permission denied", please make sure that you started your FTP 230-client in a directory to which you have write permission. 230230-If you have any problems with the GNU software or its downloading, 230-please refer your questions to <gnu@PREP.AI.MIT.EDU>. If you have any 230-other unusual problems, please report them to <root@aeneas.MIT.EDU>. 230230-If you do have problems, please try using a dash (-) as the first 230-character of your password - this will turn off the continuation 230-messages that may be confusing your FTP client.
Slide 35: 230230 Guest login ok, access restrictions apply. ftp> cd pub/gnu 250-If you have problems downloading and are seeing "Access denied" or 250-"Permission denied", please make sure that you started your FTP 250-client in a directory to which you have write permission. 250250-Please note that all files ending in '.gz' are compressed with 250-'gzip', not with the unix 'compress' program. 250- and read it for more information. 250250-Please read the file README 250it was last modified on Thu Feb 1 15:00:50 1996 - 32 days ago Get the file README 250-Please read the file README-about-.diff-files 250it was last modified on Fri Feb 2 12:57:14 1996 - 31 days ago 250-Please read the file README-about-.gz-files 250it was last modified on Wed Jun 14 16:59:43 1995 - 264 days ago 250 CWD command successful. ftp> binary 200 Type set to I. ftp> get perl-5.001.tar.gz 200 PORT command successful. 150 Opening ASCII mode data connection for perl-5.001.tar.gz (1130765 bytes). 226 Transfer complete. 1130765 bytes received in 9454 seconds (1.20 Kbytes/s) ftp> quit 221 Goodbye. $
Slide 36: The commands entered in this session are explained in the following steps. If some of these steps are not familiar to you, ask your system administrator for help. 1. The command $ ftp prep.ai.mit.edu 2. 3. 4. 5. 6. 7. connects you to the main Free Software Foundation source depository at MIT. The user ID anonymous tells FTP that you want to perform an anonymous FTP operation. When FTP asks for a password, enter your user ID and network address. This lets the MIT system administrator know who is using the MIT archives. (For security reasons, the password is not actually displayed when you type it.) The command cd pub/gnu sets your current working directory to be the directory containing the Perl source. The binary command tells FTP that the file you'll be receiving is a file that contains unreadable (non-text) characters. The get command copies the file perl-5.001.tar.gz from the MIT source depository to your own site. (It's usually best to do this in off-peak hours to make things easier for other Internet users-it takes awhile.) This file is quite large because it contains all the source files for Perl bundled together into a single file. The quit command disconnects from the MIT source repository and returns you to your own system. Once you've retrieved the Perl distribution, do the following: 1. Create a directory and move the file you just received, perl-5.001.tar.gz, to this directory. (Or, alternatively, move it to a directory already reserved for this purpose.) 2. The perl-5.001.tar.gz file is compressed to save space. To uncompress it, enter the command $ gunzip perl-5.001.tar.gz gunzipis the GNU uncompress program. If it's not available on your system, see your system administrator. (You can, in fact, retrieve it from prep.ai.mit.eduusing anonymous FTP with the same commands you used to retrieve the Perl distribution.) When you run gunzip, the file perl-5.001.tar.gzwill be replaced by perl5.001.tar, which is the uncompressed version of the Perl distribution file. 3. The next step is to unpack the Perl distribution. In other words, use the information in the Perl distribution to create the Perl source files. To do this, enter the following command: $ tar xvf - <perl-5.001.tar As this command executes, it creates each source file in turn and displays the name and size of each file as it is created. The tarcommand also creates
Slide 37: subdirectories where appropriate; this ensures that the Perl source files are organized in a logical way. 4. Using your favorite C compiler, compile the Perl source code using the makefile provided. (This makefile should have been created when the source files were unpacked in the last step.) 5. Place the compiled Perl executable into the directory where you normally keep your executables. On UNIX systems, this directory usually is called /usr/local/bin, and Perl usually is named /usr/local/bin/perl. You might need your system administrator's help to do this because you might not have the necessary permissions. Other Places to Get Perl If you cannot access the MIT site from where you are, you can get Perl from the following sites using anonymous FTP: North America Site ftp.netlabs.com ftp.cis.ufl.edu ftp.uu.net Location Internet address 192.94.48.152 Directory /pub/outgoing/perl5.0 Internet address 128.227.100.198 Directory /pub/perl/src/5.0 Internet address 192.48.96.9 Directory /languages/perl ftp.khoros.unm.edu Internet address 198.59.155.28 Directory /pub/perl ftp.cbi.tamucc.edu Internet address 165.95.1.3 Directory /pub/duff/Perl ftp.metronet.com Internet address 192.245.137.1 Directory /pub/perl/sources genetics.upenn.edu Internet address 128.91.200.37 Directory /perl5 Europe Site ftp.cs.ruu.nl Location Internet address 131.211.80.17 Directory /pub/PERL/perl5.0/src
Slide 38: ftp.funet.fi Internet address 128.214.248.6 Directory /pub/languages/perl/ports/perl5 ftp.zrz.tuberlin.de src.doc.ic.ac.uk Internet address 130.149.4.40 Directory /pub/unix/perl Internet address 146.169.17.5 Directory /packages/perl5 Australia Site Location sungear.mame.mu.oz.au Internet address 128.250.209.2 Directory /pub/perl/src/5.0 South America Site ftp.inf.utfsm.cl Location Internet address 146.83.198.3 Directory /pub/gnu You also can obtain Perl from most sites that store GNU source code, or from any site that archives the Usenet newsgroup comp.sources.unix. A Sample Perl Program Now that Perl is available on your system, it's time to show you a simple program that illustrates how easy it is to use Perl. Listing 1.1 is a simple program that asks for a line of input and writes it out. Listing 1.1. A simple Perl program that reads and writes a line of input. 1: #!/usr/local/bin/perl 2: $inputline = <STDIN>; 3: print( $inputline );
Slide 39: $program1_1 This is my line of input. This is my line of input. $ Line 1 is the header comment. Line 2 reads a line of input. Line 3 writes the line of input back to your screen. The following sections describe how to create and run this program, and they describe it in more detail. Running a Perl Program To run the program shown in Listing 1.1, do the following: 1. Using your favorite editor, type the previous program and save it in a file called program1_1. 2. Tell the system that this file contains executable statements. To do this in the UNIX environment, enter the command $ chmod +x program1_1 3. Run the program by entering the command $ program1_1 When you run program1_1, it waits for you to enter a line of input. After you enter the line of input, program1_1 prints what you entered, as follows: $ program1_1 This is my line of input. This is my line of input. $
Slide 40: If Something Goes Wrong If Listing 1.1 is stored in the file program1_1 and run according to the preceding steps, the program should run successfully. If the program doesn't run, one of two things has likely happened: q q The system can't find the file program1_1. The system can't find Perl. If you receive the error message program1_1 not found or something similar, your system couldn't find the file program1_1. To tell the system where program1_1 is located, you can do one of two things in a UNIX environment: q q Enter the command ./program1_1, which gives the system the pathname of program1_1 relative to the current directory. Add the current directory . to your PATH environment variable. This tells the system to search in the current directory when looking for executable programs such as program1_1. If you receive the message /usr/local/bin/perl not found or something similar, this means that Perl is not installed properly on your machine. See the section "How Do I Find Perl?" earlier today, for more details. If you don't understand these instructions or are still having trouble running Listing 1.1, talk to your system administrator. The First Line of Your Perl Program: How Comments Work Now that you've run your first Perl program, let's look at each line of Listing 1.1 and figure out what it does. Line 1 of this program is a special line that tells the system that this is a Perl program: #!/usr/local/bin/perl
Slide 41: Let's break this line down, one part at a time: q q q The first character in the line, the # character, is the Perl comment character. It tells the system that this line is not an executable instruction. The ! character is a special character; it indicates what type of program this is. (You don't need to worry about the details of what the ! character does. All you have to do is remember to include it.) The path /usr/local/bin/perl is the location of the Perl executable on your system. This executable interprets your program; in other words, it figures out what you want to do and then does it. Because the Perl executable has the job of interpreting Perl instructions, it usually is called the Perl interpreter. If, after reading this, you still don't understand the meaning of the line #!/usr/local/bin/perl don't worry. The actual specifics of what it does are not important for our purposes in this book. Just remember to include it as the first line of your program, and Perl will take it from there. NOTE If you are running Perl on a system other than UNIX, you might need to replace the line #!/usr/local/bin/perl with some other line indi-cating the location of the Perl interpreter on your system. Ask your system administrator for details on what you need to include here. After you have found out what the proper first line is in your environment, include that line as the first line of every Perl program you write, and you're all set Comments As you have just seen, the first character of the line #!/usr/local/bin/perl is the comment character, #. When the Perl interpreter sees the #, it ignores the rest of that line. Comments can be appended to lines containing code, or they can be lines of their own: $inputline = <STDIN>; # this line contains an appended comment
Slide 42: # this entire line is a comment You can-and should-use comments to make your programs easier to understand. Listing 1.2 is the simple program you saw earlier, but it has been modified to include comments explaining what the program does. NOTE As you work through the lessons in this book and create your own programs-such as the one in Listing 1.2-you can, of course, name them anything you want. For illustration and discussion purposes, I've adopted the convention of using a name that corresponds to the listing number. For example, the program in Listing 1.2 is called program1_2. The program name is used in the Input-Output examples such as the one following this listing, as well as in the Analysis section where the listing is discussed in detail. When you follow the Input-Output example, just remember to substitute your program's name for the one shown in the example Listing 1.2. A simple Perl program with comments. 1: #!/usr/local/bin/perl 2: # this program reads a line of input, and writes the line 3: # back out 4: $inputline = <STDIN>; 5: print( $inputline ); # read a line of input # write the line out $ program1_2
Slide 43: This is a line of input. This is a line of input. $ The behavior of the program in Listing 1.2 is identical to that of Listing 1.1 because the actual code is the same. The only difference is that Listing 1.2 has comments in it Note that in an actual program, comments normally are used only to explain complicated code or to indicate that the following lines of code perform a specific task. Because Perl instructions usually are pretty straightforward, Perl programs don't need to have a lot of comments. DO use comments whenever you think that a line of code is not easy to understand. DON'T clutter up your code with unnecessary comments. The goal is readability. If a comment makes a program easier to read, include it. Otherwise, don't bother. DON'T put anything else after /usr/local/bin/perl in the first line: #!/usr/local/bin/perl This line is a special comment line, and it is not treated like the others. Line 2: Statements, Tokens, and <STDIN> Now that you've learned what the first line of Listing 1.1 does, let's take a look at line 2: $inputline = <STDIN>; This is the first line of code that actually does any work. To understand what this line
Slide 44: does, you need to know what a Perl statement is and what its components are. Statements and Tokens The line of code you have just seen is an example of a Perl statement. Basically, a statement is one task for the Perl interpreter to perform. A Perl program can be thought of as a collection of statements performed one at a time. When the Perl interpreter sees a statement, it breaks the statement down into smaller units of information. In this example, the smaller units of information are $inputline, =, <STDIN>, and ;. Each of these smaller units of information is called a token. Tokens and White Space Tokens can normally be separated by as many spaces and tabs as you like. For example, the following statements are identical in Perl: $inputline = <STDIN>; $inputline=<STDIN>; $inputline = <STDIN>; Your statements can take up as many lines of code as you like. For example, the following statement is equivalent to the ones above: $inputline = <STDIN> ; The collection of spaces, tabs, and new lines separating one token from another is known as white space. When programming in Perl, you should use white space to make your programs more readable. The examples in this book use white space in the following ways: q q New statements always start on a new line. One blank space is used to separate one token from another (except in special cases, some of which you'll see today). What the Tokens Do: Reading from Standard Input
Slide 45: As you've seen already, the statement $inputline = <STDIN>; consists of four tokens: $inputline, =, <STDIN>, and ;. The following subsections explain what each of these tokens does. The $inputline and = Tokens The first token in line 1, $inputline (at the left of the statement), is an example of a scalar variable. In Perl, a scalar variable can store one piece of information. The = token, called the assignment operator, tells the Perl interpreter to store the item specified by the token to the right of the = in the place specified by the token to the left of the =. In this example, the item on the right of the assignment operator is the <STDIN> token, and the item to the left of the assignment operator is the $inputline token. Thus, <STDIN> is stored in the scalar variable $inputline. Scalar variables and assignment operators are covered in more detail on Day 2, "Basic Operators and Control Flow." The <STDIN> Token and the Standard Input File The next token, <STDIN>, represents a line of input from the standard input file. The standard input file, or STDIN for short, typically contains everything you enter when running a program. For example, when you run program1_1 and enter This is a line of input. the line you enter is stored in the standard input file. The <STDIN> token tells the Perl interpreter to read one line from the standard input file, where a line is defined to be a set of characters terminated by a new line. In this example, when the Perl interpreter sees <STDIN>, it reads in This is a line of input. If the Perl interpreter then sees another <STDIN> in a different statement, it reads another line of data from the standard input file. The line of data you read earlier is
Slide 46: destroyed unless it has been copied somewhere else. NOTE If there are more lines of input than there are <STDIN> tokens, the extra lines of input are ignored Because the <STDIN> token is to the right of the assignment operator =, the line This is a line of input. is assigned to the scalar variable $inputline. The ; Token The ; token at the end of the statement is a special token that tells Perl the statement is complete. You can think of it as a punctuation mark that is like a period in English. Line 3: Writing to Standard Output Now that you understand what statements and tokens are, consider line 3 of Listing 1.1, which is print ($inputline); This statement refers to the library function that is called print. Library functions, such as print, are provided as part of the Perl interpreter; each library function performs a useful task. The print function's task is to send data to the standard output file. The standard output file stores data that is to be written to your screen. The standard output file sometimes appears in Perl programs under the name STDOUT. In this example, print sends $inputline to the standard output file. Because the second line of the Perl program assigns the line This is a line of input. to $inputline, this is what print sends to the standard output file and what appears on your screen.
Slide 47: Function Invocations and Arguments When a reference to print appears in a Perl program, the Perl interpreter calls, or invokes, the print library function. This function invocation is similar to a function invocation in C, a GOSUB statement in BASIC, or a PERFORM statement in COBOL. When the Perl interpreter sees the print function invocation, it executes the code contained in print and returns to the program when print is finished. Most library functions require information to tell them what to do. For example, the print function needs to know what you want to print. In Perl, this information is supplied as a sequence of comma-separated items located between the parentheses of the function invocation. For example, the statement you've just seen: print ($inputline); supplies one piece of information that is passed to print: the variable $inputline. This piece of information commonly is called an argument. The following call to print supplies two arguments: print ($inputline, $inputline); You can supply print with as many arguments as you like; it prints each argument starting with the first one (the one on the left). In this case, print writes two copies of $inputline to the standard output file. You also can tell print to write to any other specified file. You'll learn more about this on Day 6, "Reading From and Writing To Files." Error Messages If you incorrectly type a statement when creating a Perl program, the Perl interpreter will detect the error and tell you where the error is located. For example, look at Listing 1.3. This program is identical to the program you've been seeing all along, except that it contains one small error. Can you spot it?
Slide 48: Listing 1.3. A program containing an error. 1: #!/usr/local/bin/perl 2: $inputline = <STDIN> 3: print ($inputline); $ program1_3 Syntax error in file program1_3 at line3, next char ( Execution of program1_3 aborted due to compilation errors. $ When you try to run this program, an error message appears. The Perl interpreter has detected that line 2 of the program is missing its closing ; character. The error message from the interpreter tells you what the problem is and identifies the line on which the problem is located TIP You should fix errors starting from the beginning of your program and working down. When the Perl interpreter detects an error, it tries to figure out what you meant to say and carries on from there; this feature is known as error recovery. Error recovery enables the interpreter to detect as many errors as possible at one time, which speeds up the development process. Sometimes, however, the Perl interpreter can get confused and think you meant to do one thing when you really meant to do another. In this situation, the interpreter might start trying to detect errors that don't really exist. This problem is known as error
Slide 49: cascading. It's usually pretty easy to spot error cascading. If the interpreter is telling you that errors exist on several consecutive lines, it usually means that the interpreter is confused. Fix the first error, and the others might very well go away Interpretive Languages Versus Compiled Languages As you've seen, running a Perl program is easy. All you need to do is create the program, mark it as executable, and run it. The Perl interpreter takes care of the rest. Languages such as Perl that are processed by an interpreter are known as interpretive languages. Some programming languages require more complicated processing. If a language is a compiled language, the program you write must be translated into machine-readable code by a special program known as a compiler. In addition, library code might need to be added by another special program known as a linker. After the compiler and linker have done their jobs, the result is a program that can be executed on your machine-assuming, of course, that you have written the program correctly. If not, you have to compile and link the program all over again. Interpretive languages and compiled languages both have advantages and disadvantages, as follows: q q As you've seen with Perl, it takes very little time to run a program in an interpretive language. Interpretive languages, however, cannot run unless the interpreter is available. Compiled programs, on the other hand, can be transferred to any machine that understands them. As you'll see, Perl is as powerful as a compiled language. This means that you can do a lot of work quickly and easily. Summary Today you learned that Perl is a programming language that provides many of the capabilities of a high-level programming language such as C. You also learned that Perl is easy to use; basically, you just write the program and run it. You saw a very simple Perl program that reads a line of input from the standard input file and writes the line to the standard output file. The standard input file stores
Slide 50: everything you type from your keyboard, and the standard output file stores everything your Perl program sends to your screen. You learned that Perl programs contain a header comment, which indicates to the system that your program is written in Perl. Perl programs also can contain other comments, each of which must be preceded by a #. Perl programs consist of a series of statements, which are executed one at a time. Each statement consists of a collection of tokens, which can be separated by white space. Perl programs call library functions to perform certain predefined tasks. One example of a library function is print, which writes to the standard output file. Library functions are passed chunks of information called arguments; these arguments tell a function what to do. The Perl interpreter executes the Perl programs you write. If it detects an error in your program, it displays an error message and uses the error-recovery process to try to continue processing your program. If Perl gets confused, error cascading can occur, and the Perl interpreter might display inappropriate error messages. Finally, you learned about the differences between interpretive languages and compiled languages, and that Perl is an example of an interpretive language. Q&A Q: A: Q: A: Is there any particular editor I need to use with Perl? No. Perl programs are ordinary text files. You can use any text editor you like. Why do I need to enter the chmod +x command before running my program? Because Perl programs are ordinary text files, the UNIX operating system does not know that they are executable programs. By default, text files have read and write permissions granted, which means you can look at your file or change it. The chmod +x command adds execute permission to the file; when this permission is granted, the system knows that this is an executable program. Can I use print to print other things besides input lines? Yes. You'll learn more about how you can use print on Day 3, "Understanding Scalar Values." Why is Perl available for free? Q: A: Q:
Slide 51: A: This encourages the dissemination of computer knowledge and capabilities. It works like this: You can get Perl for free, and you can use it to write interesting and useful programs. If you want, you can then give these programs away and let other people write interesting and useful programs based on your programs. This way, everybody benefits. You also can modify the source for Perl, provided you tell everybody that your version is a modification of the original. This means that if you think of a clever thing you want Perl to do, you can add it yourself. (However, you can't blame anybody else if your modification breaks something or if it doesn't work.) Of course, you don't have to give your Perl programs away for free. In fact, you even can sell your Perl programs, provided you don't borrow anything from somebody else's program. Workshop The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to give you experience in using what you've learned. Try to understand the quiz and exercise answers before continuing to the next day. Quiz 1. What do Perl's fans appreciate about Perl? 2. What does the Perl interpreter do? 3. Define the following terms: a statement b token c argument d error recovery e standard input file What is a comment, and where can it appear? Where is Perl usually located on a UNIX machine? What is a header comment, and where does it appear in a program? What is a library function? 4. 5. 6. 7. Exercises 1. 2. 3. 4. Modify program1_1 to print the input line twice. Modify program1_1 to read and print two different input lines. Modify program1_1 to read two input lines and print only the second one. BUG BUSTER: What is wrong with the following program? #!/usr/local/bin/perl $inputline = <STDIN>;
Slide 52: print ($inputline) 5. BUG BUSTER: What is wrong with the following program? #!/usr/local/bin/perl $inputline = <STDIN>; # print my line! print($inputline); 6. What does the following program do? #!/usr/local/bin/perl $inputline = <STDIN>; $inputline2 = <STDIN>; print ($inputline2); print ($inputline);
Slide 53: Chapter 2 Basic Operators and Control Flow CONTENTS q q q q q q q q q q q q q q Storing in Scalar Variables Assignment r The Definition of a Scalar Variable r Scalar Variable Syntax r Assigning a Value to a Scalar Variable Performing Arithmetic r Example of Miles-to-Kilometers Conversion r The chop Library Function Expressions r Assignments and Expressions Other Perl Operators Introduction to Conditional Statements The if Statement r The Conditional Expression r The Statement Block r Testing for Equality Using == r Other Comparison Operators Two-Way Branching Using if and else Multi-Way Branching Using elsif Writing Loops Using the while Statement Nesting Conditional Statements Looping Using the until Statement Summary Q&A Workshop r Quiz r Exercises Today's lesson gives you the information you need to write some simple Perl programs. You'll learn the following:
Slide 54: q q q q q q More about scalar variables and how to assign values to them The basic arithmetic operators and how they work with scalar variables What an expression is How to use the if statement and the == operator to test for simple conditions How to specify two-way and multi-way branches using else and elsif How to write simple loops using the while and until statements Storing in Scalar Variables Assignment In yesterday's lesson, you saw the following statement, which assigns a line of input from the keyboard to the variable $inputline: $inputline = <STDIN>; This section tells you more about variables such as $inputline and how to assign values to these variables. The Definition of a Scalar Variable The variable $inputline is an example of a scalar variable. A scalar variable stores exactly one item-a line of input, a piece of text, or a number, for example. Items that can be stored in scalar variables are called scalar values. You'll learn more about scalar values on Day 3, "Understanding Scalar Values." For today, all you need to remember is that a scalar variable stores exactly one value, which is a scalar value. Scalar Variable Syntax The name of a scalar variable consists of the character $ followed by at least one letter, which is followed by any number of letters, digits, or underscore characters (that is, the _ character). The following are examples of legal scalar variable names: $x $var $my_variable $var2
Slide 55: $a_new_variable These, however, are not legal scalar variable names: variable $ $47x $_var $variable! $new.var # the $ character is missing # there must be at least one letter in the name # second character must be a letter # again, the second character must be a letter # you can't have a ! in a variable name # you can't have a . in a variable name Perl variables are case-sensitive. This means that the following variables are different: $VAR $var $Var Your variable name can be as long as you want. $this_is_a_really_long_but_legal_name $this_is_a_really_long_but_legal_name_that_is_different The $ character is necessary because it ensures that the Perl interpreter can distinguish scalar variables from other kinds of Perl variables, which you'll see on later days. TIP Variable names should be long enough to be selfexplanatory but short enough to be easy to read and type. Assigning a Value to a Scalar Variable The following statement contains the Perl assignment operator, which is the = character:
Slide 56: $inputline = <STDIN>; Remember that this statement tells Perl that the line of text read from the standard input file, represented by <STDIN>, is to become the new value of the scalar variable $inputline. You can use the assignment operator to assign other values to scalar variables as well. For example, in the following statement, the number 42 is assigned to the scalar variable $var: $var = 42; A second assignment to a scalar variable supersedes any previous assignments. In these two statements: $var = 42; $var = 113; the old value of $var, 42, is destroyed, and the value of $var becomes 113. Assignment statements can assign text to scalar variables as well. Consider the following statement: $name = "inputdata"; In this statement, the text inputdata is assigned to the scalar variable $name. Note that the quotation marks (the " characters) on either end of the text are not part of the text assigned to $name. This is because the " characters are just there to enclose the text. Spaces or tabs contained inside the pair of " characters are treated as part of the text: $name = "John Q Hacker"; Here, the spaces on either side of the Q are considered part of the text.
Slide 57: In Perl, enclosed text such as John Q Hacker is known as a character string, and the surrounding " characters are an example of string delimiters. You learn more about character strings on Day 3; for now, all you need to know is that everything inside the " characters is treated as a single unit. Performing Arithmetic As you've seen, the assignment operator = takes the value to the right of the = sign and assigns it to the variable on the left of the =: $var = 42; Here, the value 42 is assigned to the scalar variable $var. In Perl, the assignment operator is just one of many operators that perform tasks, or operations. Each operation consists of the following components: q q The operator, such as the assignment operator (=) One or more operands, such as $var and 42 This might sound a little confusing, but it's really quite straightforward. To illustrate, Table 2.1 lists some of the basic arithmetic operators that Perl supports. Table 2.1. Basic arithmetic operators. Operator + * / Operation Addition Subtraction Multiplication Division You use these operators in the same way you use +, -, and so on when you do arithmetic on paper. For example, the following statement adds 17 and 5 and then assigns the result, 22, to the scalar variable $var: $var = 17 + 5; You can perform more than one arithmetic operation in a single statement like this one, which assigns 19 to $var:
Slide 58: $var = 17 + 5 - 3; You can use the value of a variable in an arithmetic operation, as follows: $var1 = 11; $var2 = $var1 * 6; The second statement takes the value currently stored in $var1, 11, and multiplies it by 6. The result, 66, is assigned to $var2. Now examine the following statements: $var = 11; $var = $var * 6; As you can see, $var appears twice in the second statement. What Perl does in this case is straightforward: 1. The first statement assigns the value 11 to $var. 2. In the second statement, the Perl interpreter retrieves the current value of $var, 11, and multiplies it by 6, producing the result 66. 3. This result, 66, is then assigned to $var (destroying the old value, 11). As you can see, there is no ambiguity. Perl uses the old value of $var in the arithmetic operation, and then it assigns the result of the operation to $var. NOTE Perl always performs multiplication and division before addition and subtraction-even if the addition or subtraction operator appears first. Perl does this to conform to the rules of arithmetic. For example, in the following statement: $var = 5 + 6 * 4; $var is assigned 29: 6 is multiplied by 4, and then 5 is added to the result
Slide 59: Example of Miles-to-Kilometers Conversion To see how arithmetic operators work, look at Listing 2.1, which performs a simple milesto-kilometers and kilometers-to-miles conversion. Listing 2.1. Miles-to-kilometers converter. 1: 2: 3: 4: 5: 6: 7: 8: 9: print ("Enter the distance to be converted:\n"); $originaldist = <STDIN>; chop ($originaldist); $miles = $originaldist * 0.6214; $kilometers = $originaldist * 1.609; print ($originaldist, " kilometers = ", $miles, " miles\n"); #!/usr/local/bin/perl 10: print ($originaldist, " miles = ", $kilometers, 11: " kilometers\n"); $ program2_1 Enter the distance to be converted: 10 10 kilometers = 6.2139999999999995 miles 10 miles = 16.09 kilometers
Slide 60: $ Line 3 of this program asks for a distance to convert. To do this, it prints the following text on your screen Enter the distance to be converted: Note that the \n at the end of the text is not printed. The \n is a special sequence of characters that represents the newline character; when the print library function sees \n, it starts a new line of output on your screen. (You'll learn more about special sequences of characters such as \n on Day 3.) At this point, you can enter any number you want in response to the program's request for a distance. The input/output example shows an entry of 10. Line 4 retrieves the line of input you entered and then assigns it to the variable named $originaldist. Line 5 calls the library function chop, which gets rid of the closing newline character that is part of the input line you entered. The chop library function is described in the following section, "The chop Library Function." Line 6 determines the number of miles that is equivalent to 10 kilometers and assigns this number to the variable $miles. Line 7 determines the number of kilometers that is equivalent to 10 miles and assigns this number to the variable $kilometers. Lines 8-11 print the values of the variables $miles and $kilometers. NOTE
Slide 61: Different machines handle floating-point numbers (numbers containing a decimal point) in different ways. Because of this, the numbers displayed in your Listing 2.1 output might not be exactly the same as the numbers shown here. These minor differences will appear whenever a floating-point number is printed. For more information on difficulties with floating-point numbers, refer to the discussion of round-off errors on Day 3, "Understanding Scalar Values. The chop Library Function The program shown in Listing 2.1 calls a special library function, chop. This function assumes that a line of text is stored in the variable passed to it; chop's job is to delete the character at the right end of the line of text. Consider this example: $line = "This is my line"; chop ($line); After chop is called, the value of $line becomes This is my lin Here's why Listing 2.1 uses chop. The statement $originaldist = <STDIN>; assigns a line of input from the standard input file to the variable $originaldist. When you type 10 and press Enter, the line of input assigned to $originaldist consists of three characters: the 1, the 0, and a newline character. When chop is called, the newline character is removed, and $originaldist now contains the value 10, which can be used in arithmetic operations. You'll learn more about using lines of input in arithmetic operations and about conversions from lines of input to numbers on Day 3. For now, just remember to call chop after reading a number from the standard input file.
Slide 62: $originaldist = <STDIN>; chop ($originaldist); Expressions Now that you know a little more about operators, operands, and how they both work, it's time to learn some more terminology as well as the details about exactly what Perl is doing when it evaluates operators such as the arithmetic operators and the assignment operator. In Perl, a collection of operators and operands is known as an expression. Each expression yields a result, which is the value you get when the Perl interpreter evaluates the expression (that is, when the Perl interpreter performs the specified operations). For example, in the simple expression 4*5 the result is 20, or 4 times 5. You can think of an expression as a set of subordinate expressions. Consider this example: 4*5+3*6 When the Perl interpreter evaluates this expression, it first evaluates the subexpressions 4 * 5 and 3 * 6, yielding the results 20 and 18. These results are then (effectively) substituted for the subexpressions, leaving the following: 20 + 18 The Perl interpreter then performs the addition operation, and the final result of the expression is 38. Consider the following statement: $var = 4 * 5 + 3; As you can see, the Perl interpreter multiplies 4 by 5, adds 3, and assigns the result, 23,
Slide 63: to $var. Here's what the Perl interpreter is doing, more formally, when it evaluates this expression ($var = 4 * 5 + 3): 1. The subexpression 4 * 5 is evaluated, yielding the result 20. The expression being evaluated is now $var = 20 + 3 because the multiplication operation has been replaced by its result. 2. The subexpression 20 + 3 is evaluated, yielding 23. The expression is now $var = 23 3. Finally, the value 23 is assigned to $var. Here's one more example, this time using the value of a variable in an expression: $var1 = 15; $var2 = $var1 - 11; When the Perl interpreter evaluates the second expression, it does the following: 1. It retrieves the value currently stored in $var1, which is 15, and replaces the variable with its value. This means the expression is now $var2 = 15 - 11 and $var1 is out of the picture. 2. The Perl interpreter performs the subtraction operation, yielding $var2 = 4 3. $var2 is thus assigned the value 4. NOTE An expression and a statement are two different things. A statement, however, can contain a Perl expression. For example, the statement $var2 = 4; contains the Perl expression $var2 = 4 and is terminated by a semicolon (;). The distinction between statements and expressions will become clearer when you encounter other places where Perl statements use expressions. For example, expressions
Slide 64: are used in conditional statements, which you'll see later today. Assignments and Expressions The assignment operator, like all Perl operators, yields a result. The result of an assignment operation is the value assigned. For example, in the expression $var = 42 the result of the expression is 42, which is the value assigned to $var. Because the assignment operator yields a value, you can use more than one assignment operator in a single expression: $var1 = $var2 = 42; In this example, the subexpression $var2 = 42 is performed first. (You'll learn why on Day 4, "More Operators," in the lesson about operator precedence.) The result of this subexpression is 42, and the expression is now $var1 = 42 At this point, 42 is assigned to $var1. Other Perl Operators So far, you have encountered the following Perl operators, which are just a few of the many operators Perl supports: q q The assignment operator, =. The arithmetic operators +, -, *, and /. You'll learn about additional Perl operators on Day 4.
Slide 65: Introduction to Conditional Statements So far, the Perl programs you've seen have had their statements executed in sequential order. For example, consider the kilometer-to-mile conversion program you saw in Listing 2.1: #!/usr/local/bin/perl print ("Enter the distance to be converted:\n"); $originaldist = <STDIN>; chop ($originaldist); $miles = $originaldist * 0.6214; $kilometers = $originaldist * 1.609; print ($originaldist, " kilometers = ", $miles, " miles\n"); print ($originaldist, " miles = ", $kilometers, " kilometers\n"); When the Perl interpreter executes this program, it starts at the top of the program and executes each statement in turn. When the final statement is executed, the program is terminated. All the statements in this program are unconditional statements-that is, they always are executed sequentially, regardless of what is happening in the program. In some situations, however, you might want to have statements that are executed only when certain conditions are true. These statements are known as conditional statements. Perl supports a variety of conditional statements. In the following sections, you'll learn about these conditional statements: Statement if if-else if-elsif-else Description Executes when a specified condition is true. Chooses between two alternatives. Chooses between more than two alternatives.
Slide 66: While and until Repeats a group of statements a specified number of times. Perl also has other conditional statements, which you'll learn about on Day 8, "More Control Structures." The if Statement The if statement is the simplest conditional statement used in Perl. The easiest way to explain how the if statement works is to show you a simple example: if ($number) { print ("The number is not zero.\n"); } The if statement consists of (closing brace character): This statement consists of two parts: q q The code between the if and the open brace character ({). The code between the { and the }. The first part is known as a conditional expression; the second part is a set of one or more statements called a statement block. Let's look at each part in detail. The Conditional Expression The first part of an if statement-the part between the parentheses-is the conditional expression associated with the if statement. This conditional expression is just like any other expression you've seen so far; in fact, you can use any legal Perl expression as a conditional expression. When the Perl interpreter sees a conditional expression, it evaluates the expression. The result of the expression is then placed in one of two classes: q q If the result is a nonzero value, the conditional expression is true. If the result is zero, the conditional expression is false. The Perl interpreter uses the value of the conditional expression to decide whether to execute the statements between the { and } characters. If the conditional expression is true, the statements are executed. If the conditional expression is false, the statements
Slide 67: are not executed. In the example you have just seen, if ($number) { print ("The number is not zero.\n"); } the conditional expression consists of the value of the variable $number. If $number contains something other than zero, the conditional expression is true, and the statement print ("The value is not zero.\n"); is executed. If $number currently is set to zero, the conditional expression is false, and the print statement is not executed. Listing 2.2 is a program that contains this simple if statement. Listing 2.2. A program containing a simple example of an if statement. 1: 2: 3: 4: 5: 6: 7: 8: 9: } print ("This is the last line of the program.\n"); print ("Enter a number:\n"); $number = <STDIN>; chop ($number); if ($number) { print ("The number is not zero.\n"); #!/usr/local/bin/perl
Slide 68: $ program2_2 Enter a number: 5 The number is not zero. This is the last line of the program. $ Lines 3, 4, and 5 of Listing 2.2 are similar to lines you've seen before. Line 3 tells you to enter a number; line 4 assigns the line you've entered to the variable $number; and line 5 throws away the trailing newline character Lines 6-8 constitute the if statement itself. As you have seen, this statement evaluates the conditional expression consisting of the variable $number. If $number is not zero, the expression is true, and the call to print is executed. If $number is zero, the expression is false, and the call to print is skipped; the Perl interpreter thus jumps to line 9. The Perl interpreter executes line 9 and prints the following regardless of whether the conditional expression in line 6 is true or false: This is the last line of the program. Now that you understand how an if statement works, you're ready to see the formal syntax definition for the if statement. The syntax for the if statement is if (expr) { statement_block }
Slide 69: This formal definition doesn't tell you anything you don't already know. expr refers to the conditional expression, which evaluates to either true or false. statement_block is the group of statements that is executed when expr evaluates to true. If you are familiar with the C programming language, you probably have noticed that the if statement in Perl is syntactically similar to the if statement in C. There is one important difference, however: In Perl, the braces ({ and }) must be present The following statement is illegal in Perl because the { and } are missing: if ($number) print ("The value is not zero.\n"); Perl does support a syntax for single-line conditional statements. This is discussed on Day 8. The Statement Block The second part of the if statement, the part between the { and the }, is called a statement block. A statement block consists of any number of legal Perl statements (including no statements, if you like). In the following example, the statement block consists of one statement: print ("The value is not zero.\n"); NOTE
Slide 70: A statement block can be completely empty. In this statement, for example: if ($number == 21) { } there is nothing between the { and }, so the statement block is empty. This is perfectly legal Perl code, although it's not particularly useful Testing for Equality Using == So far, the only conditional expression you've seen is an expression consisting of a single variable. Although you can use any expression you like and any operators you like, Perl provides special operators that are designed for use in conditional expressions. One such operator is the equality comparison operator, ==. The == operator, like the other operators you've seen so far, requires two operands or subexpressions. Unlike the other operators, however, it yields one of two possible results: true or false. (The other operators you've seen yield a numeric value as a result.) The == operator works like this: q q If the two subexpressions evaluate to the same numeric value, the == operator yields the result true. If the two subexpressions have different values, the == operator yields the result false. Because the == operator returns either true or false, it is ideal for use in conditional expressions, because conditional expressions are expected to evaluate to either true or false. For an example, look at Listing 2.3, which compares two numbers read in from the standard input file. Listing 2.3. A program that uses the equality-comparison operator to compare two numbers entered at the keyboard. 1: #!/usr/local/bin/perl
Slide 71: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: } 12: print ("This is the last line of the program.\n"); print ("Enter a number:\n"); $number1 = <STDIN>; chop ($number1); print ("Enter another number:\n"); $number2 = <STDIN>; chop ($number2); if ($number1 == $number2) { print ("The two numbers are equal.\n"); $ program2_3 Enter a number: 17 Enter another number: 17 The two numbers are equal. This is the last line of the program. $ Lines 3-5 are again similar to statements you've seen before. They print a message on your screen, read a number into the variable $number1, and chop the newline character from the number Lines 6-8 repeat the preceding process for a second number, which is stored in $number2.
Slide 72: Lines 9-11 contain the if statement that compares the two numbers. Line 9 contains the conditional expression $number1 == $number2 If the two numbers are equal, the conditional expression is true, and the print statement in line 10 is executed. If the two numbers are not equal, the conditional expression is false, so the print statement in line 10 is not executed; in this case, the Perl interpreter skips to the first statement after the if statement, which is line 12. Line 12 is executed regardless of whether or not the conditional expression in line 9 is true. It prints the following message on the screen: This is the last line of the program. Make sure that you don't confuse the = and == operators. Because any expression can be used as a conditional expression, Perl is quite happy to accept statements such as if ($number = 5) { print ("The number is five.\n"); } Here, the if statement is evaluated as follows: 1. The number 5 is assigned to $number, and the following expression yields the result 5: $number = 5 2. The value 5 is nonzero, so the conditional expression is true. 3. Because the conditional expression is true, this statement is executed: print ("The number is five.\n"); Note that the print statement is executed regardless of
Slide 73: what the value of $number was before the if statement. This is because the value 5 is assigned to $number by the conditional expression. To repeat: Be careful when you use the == operator Other Comparison Operators The == operator is just one of many comparison operators that you can use in conditional expressions. For a complete list, refer to Day 4. Two-Way Branching Using if and else When you examine Listing 2.3 (shown previously), you might notice a problem. What happens if the two numbers are not equal? In this case, the statement print ("The two numbers are equal.\n"); is not printed. In fact, nothing is printed. Suppose you want to modify Listing 2.3 to print one message if the two numbers are equal and another message if the two numbers are not equal. One convenient way of doing this is with the if-else statement. Listing 2.4 is a modification of the program in Listing 2.3. It uses the if-else statement to print one of two messages, depending on whether the numbers are equal. Listing 2.4. A program that uses the if-else statement. 1: 2: 3: 4: 5: print ("Enter a number:\n"); $number1 = <STDIN>; chop ($number1); #!/usr/local/bin/perl
Slide 74: 6: 7: 8: 9: 10: print ("Enter another number:\n"); $number2 = <STDIN>; chop ($number2); if ($number1 == $number2) { print ("The two numbers are equal.\n"); 11: } else { 12: 13: } 14: print ("This is the last line of the program.\n"); print ("The two numbers are not equal.\n"); $ program2_4 Enter a number: 17 Enter another number: 18 The two numbers are not equal. This is the last line of the program. $ Lines 3-8 are identical to those in Listing 2.3. They read in two numbers, assign them to $number1 and $number2, and chop their newline characters Line 9 compares the value stored in $number1 to the value stored in $number2. If the two values are equal, line 10 is executed, and the following message is printed: The two numbers are equal.
Slide 75: The Perl interpreter then jumps to the first statement after the if-else statement-line 14. If the two values are not equal, line 12 is executed, and the following message is printed: The two numbers are not equal. The interpreter then continues with the first statement after the if-else-line 14. In either case, the Perl interpreter executes line 14, which prints the following message: This is the last line of the program. The syntax for the if-else statement is if (expr) { statement_block_1 } else { statement_block_2 } As in the if statement, expr is any expression (it is usually a conditional expression). statement_block_1 is the block of statements that the Perl interpreter executes if expr is true, and statement_block_2 is the block of statements that are executed if expr is false. Note that the else part of the if-else statement cannot appear by itself; it must always follow an if. TIP
Slide 76: In Perl, as you've learned, you can use any amount of white space to separate tokens. This means that you can present conditional statements in a variety of ways. The examples in this book use what is called the one true brace style: if ($number == 0) { print ("The number is zero.\n"); } else { print ("The number is not zero.\n"); } In this brace style, the opening brace ({) appears on the same line as the if or else, and the closing brace (}) starts a new line. Other programmers insist on putting the braces on separate lines: if ($number == 0) { print ("The number is zero.\n"); } else { print ("The number is not zero.\n"); } Still others prefer to indent their braces: if ($number == 0) { print ("The number is not zero.\n"); } I prefer the one true brace style because it is both legible and compact. However, it doesn't really matter what brace style you choose, provided that you follow these rules: q The brace style is consistent. Every if and else that appears in your program should have its braces displayed in the same way.
Slide 77: q q The brace style is easy to follow. The statement blocks inside the braces always should be indented in the same way. If you do not follow a consistent style, and you write statements such as if ($number == 0) { print ("The number is zero"); } you'll find that your code is difficult to understand, especially when you start writing longer Perl programs Multi-Way Branching Using elsif Listing 2.4 (which you've just seen) shows how to write a program that chooses between two alternatives. Perl also provides a conditional statement, the if-elsif-else statement, which selects one of more than two alternatives. Listing 2.5 illustrates the use of elsif. Listing 2.5. A program that uses the if-elsif-else statement. 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: print ("Enter a number:\n"); $number1 = <STDIN>; chop ($number1); print ("Enter another number:\n"); $number2 = <STDIN>; chop ($number2); if ($number1 == $number2) { print ("The two numbers are equal.\n"); #!/usr/local/bin/perl 11: } elsif ($number1 == $number2 + 1) {
Slide 78: 12: print ("The first number is greater by one.\n"); 13: } elsif ($number1 + 1 == $number2) { 14: 15: } else { 16: 17: } 18: print ("This is the last line of the program.\n"); print ("The two numbers are not equal.\n"); print ("The second number is greater by one.\n"); $ program2_5 Enter a number: 17 Enter another number: 18 The second number is greater by one. This is the last line of the program. $ You already are familiar with lines 3-8. They obtain two numbers from the standard input file and assign them to $number1 and $number2, chopping the terminating newline character in the process Line 9 checks whether the two numbers are equal. If the numbers are equal, line 10 is executed, and the following message is printed: The two numbers are equal. The Perl interpreter then jumps to the first statement after the if-elsif-else statement, which is line 18.
Slide 79: If the two numbers are not equal, the Perl interpreter goes to line 11. Line 11 performs another comparison. It adds 1 to the value of $number2 and compares it with the value of $number1. If the two values are equal, the Perl interpreter executes line 12, printing the message The first number is greater by one. The interpreter then jumps to line 18-the statement following the if-elsif-else statement. If the conditional expression in line 11 is false, the interpreter jumps to line 13. Line 13 adds 1 to the value of $number1 and compares it with the value of $number2. If these two values are equal, the Perl interpreter executes line 14, which prints The second number is greater by one. on the screen. The interpreter then jumps to line 18. If the conditional expression in line 13 is false, the Perl interpreter jumps to line 15 and executes line 16, which prints The two numbers are not equal. on the screen. The Perl interpreter continues with the next statement, which is line 18. If you have followed the program logic to this point, you've realized that the Perl interpreter eventually reaches line 18 in every case. Line 18 prints this statement: This is the last line of the program. The syntax of the if-elsif-else statement is as follows: if (expr_1) { statement_block_1 } elsif (expr_2) { statement_block_2
Slide 80: } elsif (expr_3) { statement_block_3 ... } else { default_statement_block } Here, expr_1, expr_2, and expr_3 are conditional expressions. statement_block_1, statement_block_2, statement_block_3, and default_statement_block are blocks of statements. The ... indicates that you can have as many elsif statements as you like. Each elsif statement has the same form: } elsif (expr) { statement_block } Syntactically, an if-else statement is just an if-elsif-else statement with no elsif parts. If you want, you can leave out the else part of the if-elsif-else statement, as follows: if (expr_1) { statement_block_1 } elsif (expr_2) { statement_block_2 } elsif (expr_3) { statement_block_3 ... } Here, if none of the expressions-expr_1, expr_2, expr_3, and so on-are true, the Perl interpreter just skips to the first statement following the if-elsif-else statement.
Slide 81: NOTE The elsif parts of the if-elsif-else statement must appear between the if part and the else part Writing Loops Using the while Statement The conditional statements you've seen so far enable the Perl interpreter to decide between alternatives. However, each statement in the Perl programs that you have seen is either not executed or is executed only once. Perl also enables you to write conditional statements that tell the Perl interpreter to repeat a block of statements a specified number of times. A block of statements that can be repeated is known as a loop. The simplest way to write a loop in Perl is with the while statement. Here is a simple example of a while statement: while ($number == 5) { print ("The number is still 5!\n"); } The while statement is structurally similar to the if statement, but it works in a slightly different way. Here's how: q q q First, the conditional expression located between the parentheses is tested. If the conditional expression is true, the statement block between the { and } is executed. If the expression is false, the statement block is skipped, and the Perl interpreter jumps to the statement following the while statement. (This is called exiting the loop.) If the statement block is executed, the Perl interpreter jumps back to the start of the while statement and tests the conditional expression over again. (This is the looping part of the while statement, because at this point the Perl interpreter is executing a statement it has executed before.) The statement block in the while statement is repeated until the conditional expression becomes false. This means that the statement while ($number == 5) {
Slide 82: print ("The number is still 5!\n"); } loops forever (which is referred to as going into an infinite loop) if the value of $number is 5, because the value of $number never changes and the following conditional expression is always true: $number == 5 For a more useful example of a while statement-one that does not go into an infinite loop-take a look at Listing 2.6. Listing 2.6. A program that demonstrates the while statement. 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: } 13: print ("End of loop.\n"); } $count = $count + 1; $done = 0; $count = 1; print ("This line is printed before the loop starts.\n"); while ($done == 0) { print ("The value of count is ", $count, "\n"); if ($count == 3) { $done = 1; #!/usr/local/bin/perl
Slide 83: $ program2_6 This line is printed before the loop starts. The value of count is 1 The value of count is 2 The value of count is 3 End of loop. $ Lines 3-5 prepare the program for looping. Line 3 assigns the value 0 to the variable $done. (As you'll see, the program uses $done to indicate whether or not to continue looping.) Line 4 assigns the value 1 to the variable $count. Line 5 prints the following line to the screen This line is printed before the loop starts. The while statement appears in lines 6-12. Line 6 contains a conditional expression to be tested. If the conditional expression is true, the statement block in lines 7-11 is executed. At this point, the conditional expression is true, so the Perl interpreter continues with line 7. Line 7 prints the current value of the variable $count. At present, $count is set to 1. This means that line 7 prints the following on the screen: The value of count is 1 Lines 8-10 test whether $count has reached the value 3. Because $count is 1 at the moment, the conditional expression in line 8 is false, and the Perl interpreter skips to line 11. Line 11 adds 1 to the current value of $count, setting it to 2. Line 12 is the bottom of the while statement. The Perl interpreter now jumps back to line 6, and the whole process is repeated. Here's how the Perl interpreter continues from
Slide 84: here: q q q q q q q q q q q q Line 6: $done == 0 is true, so continue. Line 7: Print The value of count is 2 on the screen. Line 8: $count is 2; $count == 3 is false, so skip to line 11. Line 11: 1 is added to $count; $count is now 3. Line 12: Jump back to the start of the loop, which is line 6. Line 6: $done == 0 is true, so continue. Line 7: Print The value of count is 3 on the screen. Line 8: $count is 3; $count == 3 is true, and the if statement block is executed. Line 9: $done is set to 1. Execution continues with the first statement after the if, which is line 11. Line 11: $count is set to 4. Line 12: Jump back to line 6. Line 6: $done == 0 is now false, because the value of $done is 1. The Perl interpreter exits the loop and continues with the first statement after while, which is line 13. Line 13 prints the following message on the screen: End of loop. At this point, program execution terminates because there are no more statements to execute. The syntax for the while statement is while (expr) { statement_block } As you can see, the while statement is syntactically similar to the if statement. expr is a conditional expression to be evaluated, and statement_block is a block of statements to be executed while expr is true. Nesting Conditional Statements The if statement in Listing 2.6 (shown previously) is an example of a nested conditional statement. It is contained inside another conditional statement (the while statement). In Perl, you can nest any conditional statement inside another. For example, you can have a while statement inside another while statement, as follows:
Slide 85: while (expr_1) { some_statements while (expr_2) { inner_statement_block } some_more_statements } Similarly, you can have an if statement inside another if statement, or you can have a while statement inside an if statement. You can nest conditional statements inside elsif and else parts of if statements as well: if ($number == 0) { # some statements go here } elsif ($number == 1) { while ($number2 == 19) { # here is a place for a statement block } } else { while ($number2 == 33) { # here is a place for another statement block } } The braces ({ and }) around the statement block for each conditional statement ensure that the Perl interpreter never gets confused. TIP
Slide 86: If you plan to nest conditional statements, it's a good idea to indent each statement block to indicate how many levels of nesting you are using. If you write code such as the following, it's easy to get confused: while ($done == 0) { print ("The value of count is", $count, "\n"); if ($count == 3) { $done = 1; } $count = $count + 1; } Although this code is correct, it's not easy to see that the statement $done = 1; is actually inside an if statement that is inside a while statement. Larger and more complicated programs rapidly become unreadable if you do not indent properly. Looping Using the until Statement Another way to loop in Perl is with the until statement. It is similar in appearance to the while statement, but it works in a slightly different way. q q The while statement loops while its conditional expression is true. The until statement loops until its conditional expression is true (that is, it loops as long as its conditional expression is false). Listing 2.7 contains an example of the until statement. Listing 2.7. A program that uses the until statement. 1: 2: #!/usr/local/bin/perl
Slide 87: 3: 4: 5: 6: 7: 8: 9: 10: print ("What is 17 plus 26?\n"); $correct_answer = 43; $input_answer = <STDIN>; chop ($input_answer); until ($input_answer == $correct_answer) { print ("Wrong! Keep trying!\n"); $input_answer = <STDIN>; chop ($input_answer); # the correct answer 11: } 12: print ("You've got it!\n"); $ program2_7 What is 17 plus 26? 39 Wrong! Keep trying! 43 You've got it! $ Lines 3 and 4 set up the loop. Line 3 prints the following question on the screen What is 17 plus 26? Line 4 assigns the correct answer, 43, to $correct_answer. Lines 5 and 6 retrieve the first attempt at the answer. Line 5 reads a line of input and
Slide 88: stores it in $input_answer. Line 6 chops off the newline character. Line 7 tests whether the answer entered is correct by comparing $input_answer with $correct_answer. If the two are not equal, the Perl interpreter continues with lines 810; if they are equal, the interpreter skips to line 12. Line 8 prints the following on the screen: Wrong! Keep trying! Line 9 reads another attempt from the standard input file and stores it in $input_answer. Line 10 chops off the newline character. At this point, the Perl interpreter jumps back to line 7 and tests the new attempt. The interpreter reaches line 12 when the answer is correct. At this point, the following message appears on the screen, and the program terminates: You've got it! The syntax for the until statement is until (expr) { statement_block } As in the while statement, expr is a conditional expression, and statement_block is a statement block. Summary Today, you learned about scalar variables and how to assign values to them. Scalar variables and values can be used by the arithmetic operators to perform the basic arithmetic operations of addition, subtraction, multiplication, and division. The chop library function removes the trailing newline character from a line, which enables you to read scalar values from the standard input file.
Slide 89: A collection of operations and their values is known as an expression. The values operated on by a particular operator are called the operands of the operator. Each operator yields a result, which then can be used in other operations. An expression can be divided into subexpressions, each of which is evaluated in turn. Today you were introduced to the idea of a conditional statement. A conditional statement consists of two components: a conditional expression, which yields a result of either true or false; and a statement block, which is a group of statements that is executed only when the conditional expression is true. Some conditional expressions contain the == operator, which returns true if its operands are numerically equal, and returns false if its operands are not. The following conditional statements were described today: q q q q q The if statement, which is executed only if its conditional expression is true The if-else statement, which chooses between two alternatives The if-elsif-else statement, which chooses between multiple alternatives The while statement, which loops while a condition is true The until statement, which loops until a condition is true You also learned about nesting conditional statements, as well as about infinite loops and how to avoid them. Q&A Q: A: Which should I use, the while statement or the until statement? It doesn't matter, really; it just depends on which, in your judgment, is easier to read. Once you learn about the other comparison operators on Day 4, "More Operators," you'll be able to use the while statement wherever you can use an until statement, and vice versa. In Listing 2.7, you read input from the standard input file in two separate places. Is there any way I can reduce this to one? Yes, by using the do statement, which you'll encounter on Day 8, "More Control Structures." Do I really need both a $done variable and a $count variable in Listing 2.6? No. On Day 4 you'll learn about comparison operators, which enable you to test whether a variable is less than or greater than a particular value. At that point, you won't need the $done variable. How many elsif parts can I have in an if-elsif-else statement? Q: A: Q: A: Q:
Slide 90: A: Q: A: Effectively, as many as you like. (There is an upper limit, but it's so large that you are not likely ever to reach it.) How much nesting of conditional statements does Perl allow? Can I put an if inside a while that is inside an if that is inside an until? Yes. You can nest as many levels deep as you like. Generally, though, you don't want to go too many levels down because your program will become difficult to read. The logical operators, which you'll learn about on Day 4, make it possible to produce more complicated conditional expressions. They'll eliminate the need for too much nesting. Workshop The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to give you experience in using what you've learned. Try and understand the quiz and exercise answers before you go on to tomorrow's lesson. Quiz 1. Define the following terms: a. expression b. operand c. conditional statement d. statement block e. infinite loop 2. When does a while statement stop looping? 3. When does an until statement stop looping? 4. What does the == operator do? 5. What is the result when the following expression is evaluated? 14 + 6 * 3 - 10 / 2 6. Which of the following are legal scalar variable names? a. $hello b. $_test c. $now_is_the_time_to_come_to_the_aid_of_the_party d. $fries&gravy e. $96tears f. $tea_for_2 Exercises 1. Write a Perl program that reads in a number, multiplies it by 2, and prints the result. 2. Write a Perl program that reads in two numbers and does the following:
Slide 91: It prints Error: can't divide by zero if the second number is 0. r If the first number is 0 or the second number is 1, it just prints the first number (because no division is necessary). r In all other cases, it divides the first number by the second number and prints the result. 3. Write a Perl program that uses the while statement to print out the first 10 numbers (1-10) in ascending order. 4. Write a Perl program that uses the until statement to print out the first 10 numbers in descending order (10-1). 5. BUG BUSTER: What is wrong with the following program? (Hint: there might be r more than one bug!) #!/usr/local/bin/perl $value = <STDIN>; if ($value = 17) { print ("You typed the number 17.\n"); else { print ("You did not type the number 17.\n"); 6. BUG BUSTER: What is wrong with the following program? #!/usr/local/bin/perl # program which prints the next five numbers after the # number typed in $input = <STDIN>; chop ($input); $input = $input + 1; # start with the next number; $input = $terminate + 5; # we want to loop five times until ($input == $terminate) { print ("The next number is ", $terminate, "\n");
Slide 92: Chapter 3 Understanding Scalar Values CONTENTS q q q q q q q q q What Is a Scalar Value? Integer Scalar Values r Integer Scalar Value Limitations Floating-Point Scalar Values r Floating-Point Arithmetic and Round-Off Error Using Octal and Hexadecimal Notation r Decimal Notation r Octal Notation r Hexadecimal Notation r Why Bother? Character Strings r Using Double-Quoted Strings r Escape Sequences r Single-Quoted Strings Interchangeability of Strings and Numeric Values r Initial Values of Scalar Variables Summary Q&A Workshop r Quiz r Exercises Today's lesson describes everything you need to know about scalar values in Perl. Today, you learn about the following: q q q q q Scalar values How integers are represented Floating-point values The octal and hexadecimal notations Character strings, and using the double-quote and single-quote characters to enclose them
Slide 93: q q Escape sequences The interchangeability of character strings and numeric values What Is a Scalar Value? Basically, a scalar value is one unit of data. This unit of data can be either a number or a chunk of text. There are several types of scalar values that Perl understands. Today's lesson describes each of them in turn and shows you how you can use them. Integer Scalar Values The most common scalar values in Perl programs are integer scalar values, also known as integer constants or integer literals. An integer scalar value consists of one or more digits, optionally preceded by a plus or minus sign and optionally containing underscores. Here are a few examples: 14 10000000000 -27 1_000_000 You can use integer scalar values in expressions or assign them to scalar variables, as follows: $x = 12345; if (1217 + 116 == 1333) { # statement block goes here } Integer Scalar Value Limitations In Perl, there is a limit on the size of integers included in a program. To see what this limit is and how it works, take a look at Listing 3.1, which prints out integers of various
Slide 94: sizes. Listing 3.1. A program that displays integers and illustrates their size limitations. 1: 2: 3: 4: 5: 6: 7: 8: $value = 1234567890; print ("first value is ", $value, "\n"); $value = 1234567890123456; print ("second value is ", $value, "\n"); $value = 12345678901234567890; print ("third value is ", $value, "\n"); #!/usr/local/bin/perl $ program3_1 first value is 1234567890 second value is 1234567890123456 third value is 12345678901234567168 $ This program assigns integer scalar values to the variable $value, and then prints $value Lines 3 and 4 store and print the value 1234567890 without any difficulty. Similarly, lines 5 and 6 successfully store and print the value 1234567890123456.
Slide 95: Line 7 attempts to assign the value 12345678901234567890 to $value. Unfortunately, this number is too big for Perl to understand. When line 8 prints out the value assigned to $value, it prints out 12345678901234567168 As you can see, the last three digits have been replaced with different values. Here's what has happened: Perl actually stores integers in the floating-point registers on your machine. In other words, integers are treated as if they are floating-point numbers (numbers containing decimal points). On most machines, floating-point registers can store approximately 16 digits before running out of space. As the output from line 8 shows, the first 17 digits of the number 12345678901234567890 are remembered and stored by the Perl interpreter, and the rest are thrown away. This means that the value printed by line 8 is not the same as the value assigned in line 7. This somewhat annoying limitation on the number of digits in an integer can be found in almost all programming languages. In fact, many programming languages have an upper integer limit of 4294967295 (which is equal to 232 minus 1). The number of digits that can be stored varies from machine to machine. For a more detailed explanation, refer to the discussion of precision in the following section, "Floating-Point Scalar Values." An integer constant that starts with a 0 is a special case: $x = 012345; The 0 at the beginning of the constant (also known as a leading zero) tells the Perl interpreter to treat this as an octal integer constant. To find out about octal integer constants, refer to the section called "Using Octal and Hexadecimal Notation" later today Floating-Point Scalar Values
Slide 96: As you have just seen, integers in Perl actually are represented as floating-point numbers. This means that an integer scalar value is actually a special kind of floatingpoint scalar value. In Perl, a floating-point scalar value consists of all of the following: q q q An optional minus sign (-) A sequence of digits, optionally containing a decimal point An optional exponent Here are some simple examples of floating-point scalar values: 11.4 -275 -0.3 .3 3. The optional exponent tells the Perl interpreter to multiply or divide the scalar value by a power of ten. An exponent consists of all of the following: q q q The letter e (E is also acceptable) An optional + or A one-, two-, or three-digit number The number in the exponent represents the value by which to multiply or divide, represented as a power of 10. For example, the exponent e+01 tells the Perl interpreter to multiply the scalar value by 10 to the power of 1, or 10. This means that the scalar value 8e+01 is equivalent to 8 multiplied by 10, or 80. Similarly, the exponent e+02 is equivalent to multiplying by 100, e+03 is equivalent to multiplying by 1,000, and so on. The following scalar values are all equal: 541e+01 54.1e+02 5.41e+03 A negative exponent tells the Perl interpreter to divide by 10. For example, the value 54e-01 is equivalent to 54 divided by 10, or 5.4. Similarly, e-02 tells the Perl interpreter
Slide 97: to divide by 100, e-03 to divide by 1,000, and so on. The exponent e+00 is equivalent to multiplying by 1, which does nothing. Therefore, the following values are equal: 5.12e+00 5.12 If you want, you can omit the + when you multiply by a power of ten. 5.47e+03 5.47e03 Listing 3.2 shows how Perl works with and prints out floating-point scalar values. Listing 3.2. A program that displays various floating-point scalar values. 1: 2: 3: 4: 5: 6: 7: 8: 9: $value = 34.0; print ("first value is ", $value, "\n"); $value = 114.6e-01; print ("second value is ", $value, "\n"); $value = 178.263e+19; print ("third value is ", $value, "\n"); $value = 123456789000000000000000000000; #!/usr/local/bin/perl 10: print ("fourth value is ", $value, "\n"); 11: $value = 1.23e+999; 12: print ("fifth value is ", $value, "\n");
Slide 98: 13: $value = 1.23e-999; 14: print ("sixth value is ", $value, "\n"); $ program3_2 first value is 34 second value is 11.460000000000001 third value is 1.7826300000000001e+21 fourth value is 1.2345678899999999e+29 fifth value is Infinity sixth value is 0 $ As in Listing 3.1, this program stores and prints various scalar values. Line 3 assigns the floating-point value 34.0 to $value. Line 4 then prints this value. Note that because there are no significant digits after the decimal point, the Perl interpreter treats 34.0 as if it is an integer Line 5 assigns 114.6e-01 to $value, and line 6 prints this value. Whenever possible, the Perl interpreter removes any exponents, shifting the decimal point appropriately. As a result, line 6 prints out 11.460000000000001 which is 114.6e-01 with the exponent e-01 removed and the decimal point shifted one place to the left (which is equivalent to dividing by 10). Note that the number printed by line 6 is not exactly equal to the value assigned in line 5. This is a result of round-off error. The floating-point register cannot contain the exact value 11.46, so it comes as close as it can. It comes pretty close-in fact, the first 16 digits are correct. This number of correct digits is known as the precision, and it is a property of the machine on which you are working; the precision of a floating-point number varies
Slide 99: from machine to machine. (The machine on which I ran these test examples supports a floating-point precision of 16 or 17 digits. This is about normal.) NOTE The size of an integer is roughly equivalent to the supported floating-point precision. If a machine supports a floating-point precision of 16 digits, an integer can be approximately 16 digits long. Line 6 shows that a floating-point value has its exponent removed whenever possible. Lines 7 and 8 show what happens when a number is too large to be conveniently displayed without the exponent. In this case, the number is displayed in scientific notation. In scientific notation, one digit appears before the decimal point, and all the other significant digits (the rest of the machine's precision) follow the decimal point. The exponent is adjusted to reflect this. In this example, the number 178.263e+19 is converted into scientific notation and becomes 1.7826300000000001e+21 As you can see, the decimal point has been shifted two places to the left, and the exponent has, as a consequence, been adjusted from 19 to 21. As before, the 1 at the end is an example of round-off error. If an integer is too large to be displayed conveniently, the Perl interpreter converts it to scientific notation. Lines 9 and 10 show this. The number 123456789000000000000000000000 is converted to 1.2345678899999999e+29
Slide 100: Here, scientific notation becomes useful. At a glance, you can tell approximately how large the number is. (In conventional notation, you can't do this without counting the zeros.) Lines 11 and 12 show what happens when the Perl interpreter is given a number that is too large to fit into the machine's floating-point register. In this case, Perl just prints the word Infinity. The maximum size of a floating-point number varies from machine to machine. Generally, the largest possible exponent that can be stored is about e+308. Lines 13 and 14 illustrate the case of a number having a negative exponent that is too large (that is, it's too small to store). In such cases, Perl either gets as close as it can or just prints 0. The largest negative exponent that produces reliable values is about e-309. Below that, accuracy diminishes. Floating-Point Arithmetic and Round-Off Error The arithmetic operations you saw on Day 2, "Basic Operators and Control Flow," also work on floating-point values. On that day, you saw an example of a miles-to-kilometers conversion program that uses floating-point arithmetic. When you perform floating-point arithmetic, you must remember the problems with precision and round-off error. Listing 3.3 illustrates what can go wrong and shows you how to attack this problem. Listing 3.3. A program that illustrates round-off error problems in floating-point arithmetic. 1: 2: 3: 4: 5: 6: $value = 9.01e+21 + 0.01 - 9.01e+21; print ("first value is ", $value, "\n"); $value = 9.01e+21 - 9.01e+21 + 0.01; print ("second value is ", $value, "\n"); #!/usr/local/bin/perl
Slide 101: $ program3_3 first value is 0 second value is 0.01 $ Line 3 and line 5 both subtract 9.01e+21 from itself and add 0.01. However, as you can see when you examine the output produced by line 4 and line 6, the order in which you perform the addition and subtraction has a significant effect In line 3, a very small number, 0.01, is added to a very large number, 9.01e+21. If you work it out yourself, you see that the result is 9.01000000000000000000001e+21. The final 1 in the preceding number can be retained only on machines that support 24 digits of precision in their floating-point numbers. Most machines, as you've seen, handle only 16 or 17 digits. As a result, the final 1, along with some of the zeros, is lost, and the number instead is stored as 9.0100000000000000e+21. This is the same as 9.01e+21, which means that subtracting 9.01e+21 yields zero. The 0.01 is lost along the way. Line 5, however, doesn't have this problem. The two large numbers are operated on first, yielding 0, and then 0.01 is added. The result is what you expect: 0.01. The moral of the story: Floating-point arithmetic is accurate only when you bunch together operations on large numbers. If the arithmetic operations are on values stored in variables, it might not be as easy to spot this problem. $result = $number1 + $number2 - $number3; If $number1 and $number3 contain large numbers and $number2 is small, $result is likely to contain an incorrect value because of the problem demonstrated in Listing 3.3.
Slide 102: Using Octal and Hexadecimal Notation So far, all the integer scalar values you've seen have been in what normally is called base 10 or decimal notation. Perl also enables you to use two other notations to represent integer scalar values: q q Base 8 notation, or octal Base 16 notation, or hexadecimal (sometimes shortened to hex) To use octal notation, put a zero in front of your integer scalar value: $result = 047; This assigns 47 octal, or 39 decimal, to $result. To use hexadecimal notation, put 0x in front of your integer scalar value, as follows: $result = 0x1f; This assigns 1f hexadecimal, or 31 decimal, to $result. Perl accepts either uppercase letters or lowercase letters as representations of the digits a through f: $result = 0xe; $result = 0xE; Both of the preceding statements assign 14 (decimal) to $result. If you are not familiar with octal and hexadecimal notations and would like to learn more, read the following sections. These sections explain how to convert numbers to different bases. If you are familiar with this concept, you can skip to the section called "Character Strings." Decimal Notation To understand how the octal and hexadecimal notations work, take a closer look at what the standard decimal notation actually represents.
Slide 103: In decimal notation, each digit in a number has one of 10 values: the standard numbers 0 through 9. Each digit in a number in decimal notation corresponds to a power of 10. Mathematically, the value of a digit x in a number is x * 10 to the exponent n, where n is the number of digits you have to skip before reaching x. This might sound complicated, but it's really straightforward. For example, the number 243 can be expressed as follows: q q q 2 * 10 to the exponent 2 (which is 200), plus 4 * 10 to the exponent 1 (which is 40), plus 3 * 10 to the exponent 0 (which is 3 * 1, which is 3) Adding the three numbers together yields 243. Octal Notation Working through these steps might seem like a waste of time when you are dealing with decimal notation. However, once you understand this method, reading numbers in other notations becomes simple. For example, in octal notation, each digit x in a number is x * 8 to the exponent n where x is the value of the digit, and n is the number of digits to skip before reaching x. This is the same formula as in decimal notation, but with the 10 replaced by 8. Using this method, here's how to determine the decimal equivalent of 243 octal: q q q 2 * 8 to the exponent 2, which is 2 * 64, or 128, plus 4 * 8 to the exponent 1, which is 4 * 8, or 32, plus 3 * 8 to the exponent 0, which is 3 * 1, or 3 Adding 128, 32 and 3 yields 163, which is the decimal notation equivalent of 243 octal. Hexadecimal Notation Hexadecimal notation works the same way, but with 16 as the base instead of 10 or 8. For
Slide 104: example, here's how to convert 243 hexadecimal to decimal notation: q q q 2 * 16 to the exponent 2, which is 2 * 256, or 512, plus 4 * 16 to the exponent 1, which is 4 * 16, or 64, plus 3 * 16 to the exponent 0, which is 3 * 1, or 3 Adding these three numbers together yields 579. Note that the letters a through f represent the numbers 10 through 15, respectively. For example, here's the hexadecimal number fe in decimal notation: q q 15 * 16 to the exponent 1, which is 15 * 16, or 240, plus 14 * 16 to the exponent 0, which is 14 * 1, or 14 Adding 240 and 14 yields 254, which is the decimal equivalent of fe. Why Bother? You might be wondering why Perl bothers supporting octal and hexadecimal notation. Here's the answer: Computers store numbers in memory in binary (base 2) notation, not decimal (base 10) notation. Because 8 and 16 are multiples of 2, it is easier to represent stored computer memory in base 8 or base 16 than in base 10. (You could use base 2, of course; however, base 2 numbers are clumsy because they are very long.) NOTE Perl supports base-2 operations on integer scalar values. These operations, called bit-manipulation operations, are discussed on Day 4, "More Operators. Character Strings On previous days, you've seen that Perl enables you to assign text to scalar variables. In the following statement, for instance $var = "This is some text"; the text This is some text is an example of what is called a character string (frequently shortened to just string). A character string is a sequence of one or more letters, digits, spaces, or special characters. The following subsections show you
Slide 105: q q q How you can substitute for scalar variables in character strings How to add escape sequences to your character strings How to tell the Perl interpreter not to substitute for scalar variables NOTE C programmers should be advised that character strings in Perl do not contain a hidden null character at the end of the string. In Perl, null characters can appear anywhere in a string. (See the discussion of escape sequences later today for more details. Using Double-Quoted Strings Perl supports scalar variable substitution in character strings enclosed by double quotationmark characters. For example, consider the following assignments: $number = 11; $text = "This text contains the number $number."; When the Perl interpreter sees $number inside the string in the second statement, it replaces $number with its current value. This means that the string assigned to $text is actually This text contains the number 11. The most immediate practical application of this is in the print statement. So far, many of the print statements you have seen contain several arguments, as in the following: print ("The final result is ", $result, "\n"); Because Perl supports scalar variable substitution, you can combine the three arguments to print into a single argument, as in the following: print ("The final result is $result\n");
Slide 106: NOTE From now on, examples and listings that call print use scalar variable substitution because it is easier to read Escape Sequences Character strings that are enclosed in double quotes accept escape sequences for special characters. These escape sequences consist of a backslash (\) followed by one or more characters. The most common escape sequence is \n, which represents the newline character as shown in this example: $text = "This is a string terminated by a newline\n"; Table 3.1 lists the escape sequences recognized in double-quoted strings. Table 3.1. Escape sequences in strings. Escape Sequence \a \b \cn \e \E \f \l Description Bell (beep) Backspace The Ctrl+n character Escape Ends the effect of \L, \U or \Q Form feed Forces the next letter into lowercase All following letters are lowercase Newline Carriage return Do not look for special pattern characters Tab Force next letter into uppercase \L \n \r \Q \t \u
Slide 107: \U All following letters are uppercase Vertical tab \v The \Q escape sequence is useful only when the string is used as a pattern. Patterns are described on Day 7, "Pattern Matching." The escape sequences \L, \U, and \Q can be turned off by \E, as follows: $a = "T\LHIS IS A \ESTRING"; # same as "This is a STRING" To include a backslash or double quote in a double-quoted string, precede the backslash or quote with another backslash: $result = "A quote \" in a string"; $result = "A backslash \\ in a string"; A backslash also enables you to include a $ character in a string. For example, the statements $result = 14; print("The value of \$result is $result.\n"); print the following on your screen: The value of $result is 14. You can specify the ASCII value for a character in base 8 or octal notation using \nnn, where each n is an octal digit; for example: $result = "\377"; # this is the character 255, or EOF You can also use hexadecimal notation to specify the ASCII value for a character. To do this, use the sequence \xnn, where each n is a hexadecimal digit.
Slide 108: $result = "\xff"; # this is also 255 Listing 3.4 is an example of a program that uses escape sequences. This program takes a line of input and converts it to a variety of cases. Listing 3.4. A case-conversion program. 1: 2: 3: 4: 5: 6: 7: print ("Enter a line of input:\n"); $inputline = <STDIN>; print ("uppercase: \U$inputline\E\n"); print ("lowercase: \L$inputline\E\n"); print ("as a sentence: \L\u$inputline\E\n"); #!/usr/local/bin/perl $ program3_4 Enter a line of input: tHis Is My INpUT LiNE. uppercase: THIS IS MY INPUT LINE. lowercase: this is my input line. as a sentence: This is my input line. $ Line 3 of this program reads a line of input and stores it in the scalar variable
Slide 109: $inputline Line 5 replaces the string $inputline with the current value of the scalar variable $inputline. The escape character \U tells the Perl interpreter to convert everything in the string into uppercase until it sees a \E character; as a result, line 4 writes the contents of $inputline in uppercase. Similarly, line 6 writes the input line in all lowercase characters by specifying the escape character \L in the string. Line 7 combines the escape characters \L and \u. The \L specifies that everything in the string is to be in lowercase; however, the \u special character temporarily overrides this and tells the Perl interpreter that the next character is to be in uppercase. When this character-the first character in the line-is printed, the \L escape character remains in force, and the rest of the line is printed in lowercase. The result is as if the input line is a single sentence in English. The first character is capitalized, and the remainder is in lowercase. Single-Quoted Strings Perl also enables you to enclose strings using the ' (single quotation mark) character: $text = 'This is a string in single quotes'; There are two differences between double-quoted strings and single-quoted strings. The first difference is that scalar variables are replaced by their values in double-quoted strings but not in single-quoted strings. The following is an example: $string = "a string"; $text = "This is $string"; $text = 'This is $string'; # becomes "This is a string" # remains 'This is $string' The second difference is that the backslash character, \, does not have a special meaning in single-quoted strings. This means that the statement $text = 'This is a string.\n'; assigns the following string to $text:
Slide 110: This is a string.\n The \ character is special in only two instances for single-quoted strings. The first is when you want to include a single-quote character ' in a string. $text = 'This string contains \', a quote character'; The preceding line of code assigns the following string to $text: This string contains ', a quote character The second instance is to escape the backslash itself. $text = 'This string ends with a backslash \\'; The preceding code line assigns the following string to $text: This string ends with a backslash \ As you can see, the double backslash makes it possible for the backslash character (\) to be the last character in a string. Single-quoted strings can be spread over multiple lines. The statement $text = 'This is two lines of text '; is equivalent to the statement $text = "This is two\nlines of text\n"; This means that if you forget the closing ' for a string, the Perl interpreter is likely to get quite confused because it won't detect an error until after it starts
Slide 111: processing the next line Interchangeability of Strings and Numeric Values As you've seen, you can use a scalar variable to store a character string, an integer, or a floating-point value. In scalar variables, a value that was assigned as a string can be used as an integer whenever it makes sense to do so, and vice versa. In the following example: $string = "43"; $number = 28; $result = $string + $number; the value of $string is converted to an integer and added to the value of $number. The result of the addition, 71, is assigned to $result. Another instance in which strings are converted to integers is when you are reading a number from the standard input file. The following is some code similar to code you've seen before: $number = <STDIN>; chop ($number); $result = $number + 1; This is what is happening: When $number is assigned a line of standard input, it really is being assigned a string. For instance, if you enter 22, $number is assigned the string 22\n (the \n represents the newline character). The chop function removes the \n, leaving the string 22, and this string is converted to the number 22 in the arithmetic expression.
Slide 112: If a string contains characters that are not digits, the string is converted to 0 when used in an integer context. For example: $result = "hello" * 5; # this assigns 0 to $result, since "hello" becomes 0 This is true even if the string is a valid hexadecimal integer if the quotes are removed, as in the following: $result = "0xff" + 1; In cases like this, Perl does not tell you that anything has gone wrong, and your results might not be what you expect. Also, strings containing misprints might not contain what you expect. For example: $result = "12O34"; # the letter O, not the number 0 When converting from a string to an integer, Perl starts at the left and continues until it sees a letter that is not a digit. In the preceding instance, 12O34 is converted to the integer 12, not 12034 Initial Values of Scalar Variables In Perl, all scalar variables have an initial value of the null string, "". This means that you do not need to define a value for a scalar variable. #!/usr/local/bin/perl $result = $undefined + 2; # $undefined is not defined print ("The value of \$result is $result.\n"); This short program is perfectly legal Perl. The output is The value of $result is 2.
Slide 113: Because $undefined is not defined, the Perl interpreter assumes that its value is the null string. This null string is then converted to 0, because it is being used in an addition operation. The result of the addition, 2, is assigned to $result. TIP Although you can use uninitialized variables in your Perl programs, you shouldn't. If your Perl program gets to be large (as many complicated programs do), it might be difficult to determine whether a particular variable is supposed to be appearing for the first time or whether it is a spelling mistake that should be fixed. To avoid ambiguity and to make life easier for yourself, initialize every scalar variable before using it Summary Perl supports three kinds of scalar values: integers, floating-point numbers, and character strings. Integers can be in three notations: standard (decimal) notation, octal notation, and hexadecimal notation. Octal notation is indicated by a leading 0, and hexadecimal notation is indicated by a leading 0x. Integers are stored as floating-point values and can be as long as the machine's floating-point precision (usually 16 digits or so). Floating-point numbers can consist of a string of digits that contain a decimal point and an optional exponent. The exponent's range can be anywhere from about e-309 to e+308. (This value might be different on some machines.) When possible, floating-point numbers are displayed without the exponent; failing that, they are displayed in scientific notation (one digit before the decimal point). When you use floating-point arithmetic, be alert for round-off errors. Performing arithmetic operations in the proper order-operating on large numbers first-might yield better results. You can enclose character strings in either double quotes (") or single quotes ('). If a scalar variable name appears in a character string enclosed in double quotes, the value of the variable is substituted for its name. Escape characters are recognized in strings enclosed in double quotes; these characters are indicated by a backslash (\). Character strings in single quotes do not support escape characters, with the exception of \\ and \'. Scalar variable names are not replaced by their values.
Slide 114: Strings and integers are freely interchangeable in Perl whenever it is logically possible to do so. Q&A Q: A: Q: A: If Perl character strings are not terminated by null characters, how does the Perl interpreter know the length of a string? The Perl interpreter keeps track of the length of a string as well as its contents. In Perl, you do not need to use a null character to indicate "end of string." Why does Perl use floating-point registers for floating-point arithmetic even though they cause round-off errors? Basically, it's a performance issue. It's possible to write routines that store floating-point numbers as strings and convert parts of these strings to numbers as necessary; however, you often don't need more than 16 or so digits of precision anyway. Applications that need to do high-speed arithmetic calculations of great precision usually run on special computers designed for that purpose. What happens if I forget to call chop when reading a number from the standard input file? As it happens, nothing. Perl is smart enough to ignore white space at the end of a line that consists only of a number. However, it's a good idea to get into the habit of using chop to get rid of a trailing newline at all times, because the trailing newline becomes significant when you start doing string comparisons. (You'll learn about string comparisons on Day 4, "More Operators.") Q: A: Workshop The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to give you experience in using what you've learned. Try and understand the quiz and exercise answers before you go on to tomorrow's lesson. Quiz 1. Define the following terms: a b c d a b c round-off error octal notation precision scientific notation 0377 06 01131 2. Convert the following numbers from octal notation to decimal: 3. Convert the following numbers from hexadecimal notation to decimal notation:
Slide 115: a b c 0xff 0x11 0xbead 4. What does the following line print? print ("I am bored\b\b\b\b\bhappy!\n"); 5. Suppose the value of $num is 21. What string is assigned to $text in each of the following cases? a b c a b c d $text = "This string contains $num."; $text = "\\$num is my favorite number."; $text = 'Assign \$num to this string.'; 43.71 0.000006e-02 3 -1.04 6. Convert the following numbers to scientific notation: Exercises 1. Write a program that prints every number from 0 to 1 that has a single digit after the decimal place (that is, 0.1, 0.2, and so on). 2. Write a program that reads a line of input and prints out the following: r 1 if the line consists of a non-zero integer r 0 if the line consists of 0 or a string (Hint: Remember that character strings are converted to 0 when they are converted to integers.) 3. Write a program that asks for a number and keeps trying until you enter the number 47. At that point, it prints Correct! and rings a bell. 4. BUG BUSTER: What is wrong with the following program? #!/usr/local/bin/perl $inputline = <STDIN>; print ('here is the value of \$inputline\', ": $inputline"); 5. BUG BUSTER: What is wrong with the following code fragment? $num1 = $num2 = $num3 = $num4 = $result 6.02e+23; 11.4; 5.171e+22; -2.5; = $num1 + $num2 - $num3 + $num4; 6. BUG BUSTER: What is wrong with the following statement? $result = "26" + "0xce" + "1";
Slide 116: Chapter 4 More Operators CONTENTS q q q q q q q q q Using the Arithmetic Operators r Exponentiation r The Remainder Operator r Unary Negation Using Comparison Operators r Integer-Comparison Operators r String-Comparison Operators r String Comparison Versus Integer Comparison r Comparison and Floating-Point Numbers Using Logical Operators r Evaluation Within Logical Operators r Logical Operators as Subexpressions Using Bit-Manipulation Operators r What Bits Are and How They Are Used r The Bit-Manipulation Operators Using the Assignment Operators r Assignment Operators as Subexpressions Using Autoincrement and Autodecrement r The Autoincrement Operator Pre-Increment r The Autoincrement Operator Post-Increment r The Autodecrement Operator r Using Autoincrement With Strings The String Concatenation and Repetition Operators r The String-Concatenation Operator r The String-Repetition Operator r Concatenation and Assignment Other Perl Operators r The Comma Operator r The Conditional Operator The Order of Operations r Precedence r Associativity
Slide 117: q q q Forcing Precedence Using Parentheses Summary Q&A Workshop r Quiz r Exercises r On Day 2, "Basic Operators and Control Flow," you learned about the following operators: q q q The arithmetic operators +, -, *, and / The comparison operator == The assignment operator = Today, you learn about the rest of the operators that Perl provides, as well as about operator associativity and precedence. The operators are q q q q q q q q The arithmetic operators **, %, and - (unary negation) The other integer- and string-comparison operators The logical operators The bit-manipulation operators The assignment operators Autoincrement and autodecrement Concatenating and repeating strings The comma and conditional operators Using the Arithmetic Operators The arithmetic operators that you have seen so far-the +, -, *, and / operators-work the way you expect them to: They perform the operations of addition, subtraction, multiplication, and division. Perl also supports three other arithmetic operations: q q q Exponentiation The modulo or remainder operation Unary negation Although these operators aren't as intuitively obvious as the ones you've already seen, they are quite easy to use. Exponentiation
Slide 118: The exponentiation operator, **, provides a convenient way to multiply a number by itself repeatedly. For example, here is a simple Perl statement that uses the exponentiation operator: $x = 2 ** 4; The expression 2 ** 4 means "take four copies of two and multiply them." This statement assigns 16 to the scalar variable $x. Note that the following statements are equivalent, but the first statement is much more concise: $x = 2 ** 7; $x = 2 * 2 * 2 * 2 * 2 * 2 * 2; When an exponentiation operator is employed, the base value (the value to the left of the **) is the number to be repeatedly multiplied. The number to the right, called the exponent, is the number of times the multiplication is to be performed. Here are some other simple examples of the exponentiation operator: $x = 9 ** 2; $x = 2 ** 3; $x = 43 ** 1; # 9 squared, or 81 # 2 * 2 * 2, or 8 # this is just 43 The ** operator also works on the values stored in variables: $x = $y ** 2; Here, the value stored in $y is multiplied by itself, and the result is stored in $x. $y is not changed by this operation. $x = 2 ** $y; In this case, the value stored in $y becomes the exponent, and $x is assigned 2 multiplied by itself $y times.
Slide 119: You can use the exponent operator with non-integer or negative exponents: 2 ** -5 5 ** 2.5 # this is the fraction 1/32 # this is 25 * the square root of 5 Listing 4.1 shows an example of a simple program that uses the exponential operator. It prompts for a number, $exponent, and prints out 2 ** $exponent. Listing 4.1. A program that prints out the powers of two. 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: print ("Enter the exponent to use:\n"); $exponent = <STDIN>; chop ($exponent); print ("Two to the power $exponent is ", 2 ** $exponent, "\n"); # this program asks for a number, n, and prints 2 to the # exponent n #!/usr/local/bin/perl $ program4_1 Enter the exponent to use: 16 Two to the power 16 is 65536
Slide 120: $ The program shown in Listing 4.1 is useful if you have to use, or be aware of, numbers such as 4,294,967,295 (the largest number that can be stored in a 32-bit unsigned integer) and 2,147,483,647 (the largest number that can be stored in a 32-bit signed integer). The former is equivalent to 2 ** 32 - 1, and the latter is equivalent to 2 ** 31 - 1 DON'T use the exponent operator with a negative base and a non-integer exponent: (-5) ** 2.5 # error The result of this expression is a complex (non-real) number (just as, for instance, the square root of -2 is a complex number). Perl does not understand complex numbers. DON'T produce a result that is larger than the largest floating-point number your machine can understand: 10 ** 999999 # error In this example, the exponent is too large to be stored on most machines. The Remainder Operator The remainder operator retrieves the remainder resulting from the division of one integer by another. Consider the following simple example: $x = 25 % 4; In this case, 25 divided by 4 yields 6, with a remainder of 1. The remainder, 1, is assigned to $x. The % operator does not work on values that are not integers. Non-integers are converted to integers, as follows:
Slide 121: $x = 24.77 % 4.21; # same as 25 % 4 Because division by 0 is impossible, you can't put a 0 to the right of a % operator. $x = 25 % 0; $x = 25 % 0.1; # error: can't divide by 0 # error: 0.1 is converted to 0 Unary Negation The unary negation operator is a - character in front of a single value. (This distinguishes it from the subtraction operator, which appears between two values.) It is equivalent to multiplying the value by -1, as illustrated by this example: - 5; - $y; # identical to the integer -5 # equivalent to $y * -1 Using Comparison Operators On Day 2, "Basic Operators and Control Flow," you learned about the equality comparison operator (==), which compares two values and tests whether they are equal. $x = $a == $b; Recall that the value of $x depends on the values stored in $a and $b: q q If $a equals $b, $a == $b is true, and $x is assigned a nonzero value. If $a is not equal to $b, $a == $b is false, and $x is assigned 0. The == operator is an example of a comparison operator. Comparison operators are most commonly used in control statements such as the if statement, as follows: if ($a == $b) { print("$a is equal to $b\n"); }
Slide 122: In Perl, the comparison operators are divided into two classes: q q Comparison operators that work with numbers Comparison operators that work with strings Integer-Comparison Operators Table 4.1 defines the integer-comparison operators available in Perl. Table 4.1. Integer-comparison operators. Operator Description < > == <= >= != <=> Less than Greater than Equal to Less than or equal to Greater than or equal to Not equal to Comparison returning 1, 0, or 1 Here are simple examples of each of the first six operators in Table 4.1: $x < 10 $x > 10 $x == 10 $x <= 10 $x >= 10 $x != 10 # true if the value of $x is less than 10 # true if $x is greater than 10 # true if $x is equal to 10 # true if $x is less than or equal to 10 # true if $x is greater than or equal to 10 # true if $x is not equal to 10 Each of these operators yields one of two values: q q True, or nonzero False, or zero The <=> operator is a special case. Unlike the other integer comparison operators, <=> returns one of three values:
Slide 123: q q q 0, if the two values being compared are equal 1, if the first value is greater -1, if the second value is greater For example, consider the following statement: $y = $x <=> 10; These are the possible results: q q q If $x is greater than 10, the first value in the comparison is greater, and $y is assigned 1. If $x is less than 10, the second value in the comparison is greater, and $y is assigned -1. If $x is equal to 10, $y is assigned 0. Integer Comparisons and Readability In any given statement, it's best to use the comparison that can be most easily read. For example, consider the following: if (3.2 < $x) { # conditionally executed stuff goes here } Although the expression 3.2 < $x< is perfectly valid, it isn't easy to read because variables usually appear first in comparisons. Instead, it would be better to use if ($x >= 3.2) { ... because this is easier to understand. I'm not sure exactly why this is true; I think it's related to the way the English language is spoken. (Normally, we say, "If I had five dollars, I'd buy some milk," instead of, "If five dollars had I, I'd buy some milk," even though both are correct.) String-Comparison Operators
Slide 124: For every numeric-comparison operator, Perl defines an equivalent string-comparison operator. Table 4.2 displays each string-comparison operator, the comparison it performs, and the equivalent numeric-comparison operator. Table 4.2. String- and numeric-comparison operators. String operator lt gt eq le ge ne cmp Comparison operation Less than Greater than Equal to Less than or equal to Not equal to Compare, returning 1, 0, or -1 Equivalent numeric operator < > == <= Greater than or equal to >= != <=> Perl compares strings by determining their places in an alphabetical order. For example, the string aaa is less than the string bbb, because aaa appears before bbb when they are sorted alphabetically. Here are some examples of string-comparison operators in action: $result = "aaa" lt "bbb"; $result = "aaa" gt "bbb"; $result = "aaa" eq "bbb"; $result = "aaa" le "aaa"; $result = "aaa" ge "bbb"; $result = "aaa" ne "aaa"; $result = "aaa" cmp "bbb"; # result is true # result is false # result is false # result is true # result is false # result is false # result is -1 If you are familiar with the C programming language, you might have noticed that the behavior of the cmp operator is identical to that of the C function strcmp(). String Comparison Versus Integer Comparison You might be thinking: If strings and integers are equivalent in Perl, why do we need
Slide 125: two kinds of comparison operators? To answer this, consider the strings 123 and 45. The result when these two strings are compared depends on whether a string or integer comparison is being performed. $result = "123" < "45"; $result = "123" lt "45"; In the first statement, the strings 123 and 45 are converted to integers, and 123 is compared to 45. The result is false and $result is assigned 0, because 123 is not less than 45. In the second statement, 123 is alphabetically compared to 45. Because 123 is alphabetically less than 45, the result in this case is true, and $result is assigned a nonzero value. Because these results are different, you must ensure that you are using the proper comparison operator every time. If you don't, your program can contain errors that are not easy to spot. For instance, consider the following: $var1 = "string 1"; $var2 = "string 2"; $result = $var1 == $var2; # this statement is bad Because == is a numeric-comparison operator, the values string 1 and string 2 are converted to integers before the comparison is performed. Because both strings are nonnumeric, they are both converted to the integer 0, and the following comparison becomes true: $var1 == $var2 This is probably not what you want. Comparison and Floating-Point Numbers There is one thing to keep in mind when you use comparison operators: Floating-point numbers don't always behave properly in comparisons. Take a look at Listing 4.2.
Slide 126: Listing 4.2. A program that contains a floating-point comparison. 1: 2: 3: 4: 5: 6: 7: 8: 9: } } else { print("value 1 does not equal value 2\n"); $value1 = 14.3; $value2 = 100 + 14.3 - 100; if ($value1 == $value2) { print("value 1 equals value 2\n"); #!/usr/local/bin/perl $ program4_2 value 1 does not equal value 2 $ At first glance, you might think that $value1 and $value2 are identical. However, when you run this program, you get the following: value 1 does not equal value 2 What is wrong? To find out, print out the values of $value1 and $value2 before doing the comparison.
Slide 127: #!/usr/local/bin/perl $value1 = 14.3; $value2 = 100 + 14.3 - 100; print("value 1 is $value1, value2 is $value2\n"); if ($value1 == $value2) { print("value 1 equals value 2\n"); } else { print("value 1 does not equal value 2\n"); } When you run this program, you get the following output: value 1 is 14.300000000000001, value 2 is 14.299999999999997 value 1 does not equal value 2 Well, Perl isn't lying: $value1 and $value2 are different. What happened? To understand what's going on, consider what happens when you take an ordinary calculator and tell it to divide 8 by 3. The actual answer is 2.6666666... with the number of 6s being infinite. Because your calculator can't display an infinite number of 6s, what it displays is something like the following: 2.6666666667 This is as close to the actual number as your calculator can get. The difference between the actual number and the number displayed is an example of a round-off error. Round-off errors often occur when Perl (or almost any other programming language) stores a floating-point number or adds a number to a floating-point number. The statement $value1 = 14.3;
Slide 128: actually assigns 14.300000000000001 to $value1, because 14.3 cannot be exactly represented in the machine's floating-point storage. When 100 is added to this number and subtracted again, the result is 14.299999999999997 Note that both numbers are very close to 14.3 but aren't exactly 14.3 due to round-off errors. What's worse, each number is affected by a different set of round-off errors, so the two numbers are not identical. The moral of the story? Be very careful when you use floating-point numbers in comparisons, because round-off errors might affect your results. Using Logical Operators The comparison operators you've seen so far are sufficient if you need to test for only one condition before executing a particular code segment, as in this example: if ($value == 26) { # the code to execute if the condition is true } Suppose, however, that a particular section of code is to be executed only when a variety of conditions are true. You can use a sequence of if statements to test for the conditions, as follows: if ($value1 == 26) { if ($value2 > 0) { if ($string1 eq "ready") { print("all three conditions are true!\n"); } }
Slide 129: } This is tiresome to write and not particularly easy to read. Fortunately, Perl provides an easier way to deal with multiple conditions: the logical operators. The following logical operators are defined: $a || $b $a && $b ! $a # logical or: # logical and: # logical not: true if either is nonzero true only if both are nonzero true if $a is zero Perl 5 also defines these logical operators: $a or $b $a and $b not $a $a xor $b but not both # another form of logical or # another form of logical and # another form of logical not # logical xor: true if either $a or $b is nonzero, The or, and, and not operators listed are identical to ||, &&, and !, except that their precedence is lower. (Operator precedence determines the order in which operators are evaluated, and is discussed later today.) In each case, the result of the operation performed by a logical operator is nonzero if true and 0 if false. $a = 5; $b = 0; $a || $b; $b || $a; $a && $b; ! $a; ! $b; # true: $a is not zero # also true # false: $b is zero # false: $a is nonzero, so ! $a is zero # true: $b is zero, so ! $b is nonzero
Slide 130: These logical operators enable you to test for multiple conditions more conveniently. Instead of writing, for example, this code: if ($value1 == 26) { if ($value2 > 0) { if ($string1 eq "ready") { print("all three conditions are true!\n"); } } } you now can write this code instead: if ($value == 26 && $value2 > 0 && $string1 eq "ready") { print("all three conditions are true!\n"); } In each case, the result is the same: the print operation is performed only when $value is 26, $value2 is greater than 0, and $string1 is "ready." Evaluation Within Logical Operators When Perl sees a logical AND operator or a logical OR operator, the expression on the left side of the operator is always evaluated first. For example, consider the following: $a = 0; $b = 106; $result = $a && $b; When Perl is evaluating the expression $a && $b, it first checks whether $a is 0. If $a is 0, $a && $b must be false regardless of the value of $b, so Perl doesn't bother checking the value of $b. (This is called short-circuit evaluation.) Similarly, in the following example, Perl doesn't bother checking $b, because $a is nonzero and therefore $a || $b must be true:
Slide 131: $a = 43; $b = 11; $result = $a || $b; You can take advantage of the order of evaluation of expressions in || or && to safeguard your code. $x == 0 || $y / $x > 5 Here is how the preceding statement protects you from division-by-zero errors: q q If $x is not 0, $x == 0 is false, so Perl evaluates $y / $x > 5. This cannot produce a division-by-zero error, because $x is guaranteed to be some value other than 0. If $x is 0, $x == 0 is true. This means that $x == 0 || $y / $x > 5 is true, so Perl doesn't bother evaluating the expression to the right of the ||. As a result, the expression $y / $x > 5 is not evaluated when $x is 0, and the division-by-zero error is avoided. Logical Operators as Subexpressions Expressions that contain logical operators can be contained in larger expressions. The following is an example: $myval = $a || $b || $c; Here, Perl evaluates the expression $a || $b || $c and assigns its value to $myval. To understand the behavior of this statement, recall that the || operator evaluates its subexpressions in the order given, and evaluates a subexpression only if the previous subexpression is zero. This means that $b is evaluated only if $a is zero. When the logical OR operator is used in a larger expression, its value is the last subexpression actually evaluated, which is the first subexpression of the logical OR operator that is nonzero. This means that $myval = $a || $b || $c;
Slide 132: is equivalent to if ($a != 0) { $myvalue = $a; } elsif ($b != 0) { $myvalue = $b; } else { $myvalue = $c; } The logical AND operator works in the same way, but isn't as useful. The statement $myval = $a && $b && $c; is equivalent to if ($a == 0) { $myvalue = $a; } elsif ($b == 0) { $myvalue = $b; } else { $myvalue = $c; } This means that $myval is set to either 0 or the value of $c. Using Bit-Manipulation Operators Perl enables you to manipulate the binary digits (or bits) of an integer. To understand how Perl does this, first look at what a bit is and how computers store integers. Once you understand how bits work, you can easily figure out how the bit-manipulation operators work. (If you are familiar with binary notation and the computer representation of an integer, feel free to skip the following section.)
Slide 133: What Bits Are and How They Are Used On Day 3, "Understanding Scalar Values," you learned that Perl understands three different notations for integers: q q q Standard notation, or base 10 Octal notation, or base 8 Hexadecimal notation, or base 16 However, when a computer stores an integer, it uses none of these notations; instead, it uses base 2, or binary notation. In binary notation, every number is represented as a series of 0s and 1s. For instance, the number 124 is represented as 01111100 To understand how to get from base-10 notation to binary notation, recall what the number 124 represents. When we write "124," what we really mean is the following: q q q 4 multiplied by 1, plus 2 multiplied by 10, plus 1 multiplied by 100 In grade school, your teacher probably said these digits represented the "ones place," the "tens place," and the "hundreds place." Each "place" is ten times larger than the place to its right. This means that you also can think of 124 as follows: q q q 4 multiplied by 1 (or 10 to the exponent 0), plus 2 multiplied by 10 to the exponent 1, plus 1 multiplied by 10 to the exponent 2 In binary notation, you can use this same method, but replace the 10s with 2s. Here's how to use this method to figure out that the binary number 01111100 is equivalent to 124 in standard notation. Starting from the right, you have: q q q q q q q 0 multiplied by 2 to the exponent 0, which is 0 0 multiplied by 2 to the exponent 1, which is 0 1 multiplied by 2 to the exponent 2, which is 4 1 multiplied by 2 to the exponent 3, which is 8 1 multiplied by 2 to the exponent 4, which is 16 1 multiplied by 2 to the exponent 5, which is 32 1 multiplied by 2 to the exponent 6, which is 64
Slide 134: q 0 multiplied by 2 to the exponent 7, which is 0 Adding 2, 8, 16, 32, and 64 gives you 124. Each of the 0s and 1s in the binary number 01111100 is called a bit (which is short for binary digit). Each bit can have only two possible values: 0 or 1. In computers, integers are stored as a sequence of bits. This sequence of bits is normally 8, 16, or 32 bits long, depending on the size and configuration of your computer. In the examples in today's lesson, 8-bit integers are assumed; to convert an 8-bit binary number to a 16-bit binary number, just add eight zeros to the left. For example, the following numbers are equivalent: 01111100 0000000001111100 # 124 as an 8-bit integer # 124 as a 16-bit integer The examples in today's lesson use 8-bit integers. The Perl bitwise operators will work on integers of any size. The Bit-Manipulation Operators The following bit-manipulation operators are supported in Perl: q q q q q The & (bitwise AND) operator The | (bitwise OR) operator The ^ (bitwise XOR or "exclusive or") operator The ~ (bitwise NOT) operator The << (left shift) and >> (right shift) operators The Bitwise AND Operator In Perl, the & operator represents the bitwise AND operation. This operation works as follows: q q q q The value to the left side of the & (also called the left operand of the & operation) is converted to an integer, if necessary. The value to the right side of the & (the right operand) also is converted to an integer. Each bit of the left operand is compared to the corresponding bit of the right operand. If a pair of corresponding bits both have the value 1, the corresponding bit of the result is set to 1. Otherwise, the corresponding bit of the result is set to 0.
Slide 135: This might sound complicated, but when you take a look at an example, you'll see that it's pretty easy to figure out. For instance, consider the following: $result = 124.3 & 99; First, the left operand, 124.3, is converted to an integer, becoming 124. (The right operand, 99, does not need to be converted.) Next, take a look at the binary representations of 124 and 99: 01111100 01100011 # this is 124 in binary # this is 99 in binary When you examine each pair of bits in turn, you can see that only the second and third pairs (from the left) are both 1. Thus, the & operation yields the following binary result: 01100000 This is 96 in standard notation. As a consequence, the statement $result = 124.3 & 99; assigns 96 to $result. DO use the & operator with strings, provided the strings can be converted to numbers, as follows: $result = "124.3" & "99"; Remember: Strings and integers are interchangeable in Perl. DON'T confuse the & operator with the && operator. The && operator performs a logical AND operation, not a bitwise AND operation. For example, the statement $result = 124.3 && 99;
Slide 136: assigns a nonzero value to $result (because 124.3 and 99 are both nonzero). This nonzero value is not likely to be the result you want. DON'T use the & operator with negative integers, because Perl will convert them to unsigned integers, and you won't get the result you want. The Bitwise OR Operator The bitwise OR operator, |, also compares two integers one bit at a time. However, in the bitwise OR operation, a result bit is 1 if either of the corresponding bits in the operands is 1. To see how this works, look at another example: $result = 124.3 | 99; Here's how this operation is performed: q As before, the two operands are converted to integers if necessary. The operands become 124 and 99; in binary representation, these are, as before, 01111100 01100011 q Each bit of the left operand is compared with the corresponding bit in the right operand. If either of the corresponding bits is 1, the corresponding result bit is 1. In this example, every bit becomes 1 except the first one, because at least one of each of the other pairs is a 1. Therefore, the result is 01111111 which translates to 127. This means that the following statement assigns 127 to $result: $result = 124.3 | 99;
Slide 137: DO make sure you are using the proper bitwise operator. It's easy to slip and assume you want bitwise OR when you really want bitwise AND. (Trust me.) DON'T confuse the | operator (bitwise OR) with the || operator (logical OR). The Bitwise XOR Operator The bitwise XOR ("exclusive or") operator, ^, is similar to the bitwise OR operator, but it's a little more demanding. In the bitwise OR operation, a result bit is 1 if either of the corresponding bits in the operands is 1. In the bitwise XOR operation, a result bit is 1 if exactly one of the corresponding bits in the operands is 1. Here is an example of the bitwise XOR operation: $result = 124.3 ^ 99; This works as follows: q As before, 124.3 is converted to 124, and the binary representations of the two operands are as follows: 01111100 01100011 # this is 124 # this is 99 q Each bit of the left operand is compared with the corresponding bit of the right operand. The corresponding result bit is set to 1 if exactly one of the bits in the operands is 1. In this case, the result is 00011111 which is 31. To work through how you get this result, consider the following:
Slide 138: q q q q q q q The first bit of the left operand and the first bit of the right operand are both 0. This means the first bit of the result is 0. The second bit of the left operand and the second bit of the right operand both are 1. Therefore, the second bit of the result is 0, not 1. The same applies for the third bits: Both are 1, so the result bit is 0. The fourth bit of the left operand is 1, and the fourth bit of the right operand is 0. Here, exactly one of the bits is 1, so the result bit becomes 1. Same for the fifth and sixth pairs: The first bit is 1 and the second is 0, so the result is 1. The seventh bit of the left operand is 0, and the seventh bit of the right operand is 1. Again, exactly one of the bits is 1, and the result bit is also 1. Same for the eighth pair: The first bit is 0, the second is 1, so the result is 1. From this, you can determine that the following statement assigns 31 to $result: $result = 124.3 ^ 99; The Bitwise NOT Operator Unlike the other bitwise operators you've seen so far, the bitwise NOT operator, ~, is a unary operator, meaning it works on only one operand. The way it works is straightforward, as follows: q q The operand is converted to an integer, if necessary. Each bit of the operand is examined. If a bit is 0, the corresponding result bit is set to 1, and vice versa. For example, consider the following: $result = ~99; The binary representation of 99 is 01100011 Applying the bitwise NOT operation to this number produces 10011100
Slide 139: This number, in standard notation, is 156. Therefore, the following statement assigns 156 to $result: $result = ~99; Note that the number of bits used to store an integer affects the results produced by the ~ operator. For example, if integers are stored in 16 bits on your computer, the number 99 is represented as 0000000001100011 This means that applying ~ to this number yields 1111111110011100 which is 65436 in standard notation. As a consequence, the statement $result = ~99; assigns 65436, not 156, to $result. (On a computer with 32-bit integers, the value assigned is 4294967196.) The Shift Operators Perl enables you to shift the bits of an integer using the << (shift left) and >> (shift right) operators. For example, in the statement $result = $x >> 1; every bit of the value stored in $x is shifted one place to the right, and the result is assigned to $result ($x itself is not changed). To see how this works, consider the following example: $result = 99 >> 1; As you saw earlier, the binary representation of 99 is
Slide 140: 01100011 Shifting every bit right one place yields 00110001 Note that a 0 is added at the far left, and the bit at the far right disappears. Because 00110001 in binary notation is the same as 49 in standard notation, the following statement assigns 49 to $result: $result = 99 >> 1; The <<, or shift-left, operator works in the same way: $result = 99 << 1; The shift-left operator works as follows: 01100011 11000110 # the binary representation of 99 # after shifting left 1 bit The result of the shift is 198, which is assigned to $result.
Slide 141: DO remember that when you use the >> operator, the bits on the right are lost. For example: $result1 = 17 >> 1; $result2 = 16 >> 1; In this case, $result1 and $result2 are the same value, 8. This is because the rightmost bit is shifted out in both cases. DON'T shift left too far, or you might not get the result you want. For example, if you are using 16-bit integers, the statement $result = 35000 << 1; does not assign 70000 to $result as you might think it would because the largest value that can be stored in a 16-bit integer is 65536. Shifting and Powers of 2 In the following statement, the variable $result is assigned the value 49: $result = 99 / 2; Take a look at the binary representations of 99 and 49: 01100011 00110001 # 99 in binary form # 49 in binary form As you can see, dividing by 2 is identical to shifting right one bit-in each case, every bit is moved one place to the right. Similarly, shifting right two bits is equivalent to dividing by 4: $result = 99 / 4; 01100011 00011000 # $result is assigned 24 # 99 in binary # 24 in binary
Slide 142: Multiplying by 4 is similar to shifting left two bits: $result = 17 * 4; 00010001 01000100 # $result is assigned 68 # 17 in binary # 68 in binary The general rules are as follows: q q Shifting left n bits, where n is some number greater than 0, is equivalent to multiplying by 2**n. Shifting right n bits, where n is some number greater than 0, is equivalent to dividing by 2**n. In the early days of programming, many programmers used shift operators in place of multiplication and division wherever possible, because the shift operations were usually more efficient. (In fact, some compilers would optimize their code by converting multiplication and division to shifts.) Today, it's usually best to use the shift operators when you are manipulating bits, and to use the multiplication and division operators when you're actually doing arithmetic. This will make your programs easier to understand. Using the Assignment Operators As you saw on Day 2, the assignment operator = associates, or assigns, a value to a variable. For example, the statement $result = 42; assigns the value 42 to the variable $result. The = operator can appear more than once in a single statement. For example, in the statement $value1 = $value2 = "a string"; the character string a string is assigned to both $value1 and $value2. Perl also supports other assignment operators, each of which combines an assignment
Slide 143: with another operation. For example, suppose that you want to add a value to a scalar variable and assign the result to the following variable: $var = $var + 1; Another way to write this is with the += assignment operator: $var += 1; This statement adds the value 1 to the existing value of $var. An assignment operator exists for just about every bitwise operator and arithmetic operator that Perl supports. Table 4.3 lists the assignment operators supported in Perl. Table 4.3. The assignment operators. Operator = += -= *= /= %= **= &= |= ^= Operations performed Assignment only Addition and assignment Subtraction and assignment Multiplication and assignment Division and assignment Remainder and assignment Exponentiation and assignment Bitwise AND and assignment Bitwise OR and assignment Bitwise XOR and assignment Table 4.4 shows examples of the assignment operators, along with equivalent statements that use operators you've seen earlier. Table 4.4. Examples of assignment operators. Statement using Equivalent Perl assignment operator statement
Slide 144: $a = 1; $a -= 1; $a *= 2; $a /= 2; $a %= 2; $a **= 2; $a &= 2; $a |= 2; $a ^= 2; none (basic assignment) $a = $a - 1; $a = $a * 2; $a = $a / 2; $a = $a % 2; $a = $a ** 2; $a = $a & 2; $a = $a | 2; $a = $a ^ 2; Assignment Operators as Subexpressions Any expression that contains an assignment operator can appear on the left side of another assignment operator. The following is an example: ($a = $b) += 3; In cases such as this, the assignment enclosed in parentheses is performed first. This assignment is then treated as a separate subexpression whose value is the variable to which it is being assigned. For example, $a = $b has the value $a. This means that the statement shown previously is equivalent to the following two statements: $a = $b; $a += 3; TIP Don't use assignments in this way unless you absolutely have to. At first glance, the statement ($a = $b) += 3; appears to add 3 to $b as well as to $a. Using Autoincrement and Autodecrement
Slide 145: So far, you've seen two ways to add 1 to a scalar variable: $a = $a + 1; $a += 1; The first method uses the standard assignment operator = and the addition operator +, and the second method uses the addition assignment operator +=. Perl also supports a third method of adding 1 to a scalar variable: the autoincrement operator, or ++. Here are some examples of the ++ operator in action: $a++; ++$a; $result = $a++; $result2 = ++$a; In each case, the ++ operator tells Perl to add 1 to the value stored in $a. In some of the examples, the ++ is in front of the variable it is affecting, whereas in others the ++ follows the variable. If the ++ is first, the operation is a pre-increment operation; if the ++ follows, the operation is a post-increment operation. The Autoincrement Operator Pre-Increment To understand how the pre-increment operation works, first recall that you can use a single statement to assign a value to more than one variable, as follows: $var1 = 43; $var2 = $var1 += 1; Here, the original value stored in $var1, 43, has 1 added to it. The result, 44, becomes the new value of $var1. This new value of 44 is then assigned to $var2. The pre-increment operation works in the same way: $var1 = 43;
Slide 146: $var2 = ++$var1; The following code fragment tells Perl to add 1 to $var1 before doing anything else: ++$var1 As a result, $var1 becomes 44 before the value of $var1 is assigned to $var2. Therefore, $var2 is assigned 44. The ++ operator is most frequently used in while statements. Listing 4.3 provides an example of a simple program that uses the ++ operator in a while statement. Listing 4.3. A program that uses the pre-increment operation. 1: 2: 3: 4: 5: 6: } print("all done\n"); #!/usr/local/bin/perl $value = 0; while (++$value <= 5) { print("value is now $value\n"); $ program4_3 value is now 1 value is now 2 value is now 3 value is now 4
Slide 147: value is now 5 all done $ Note that the pre-increment operation enables you to add 1 to $value and test it all at the same time. This means that you no longer have to remember to add the following: $value = $value + 1; at the bottom of the while statement, which means that you are less likely to write a while statement that goes on forever. Now see what happens when you change while (++$value <= 5) { to this: while (++$value <= 0) { and then run the program again. This time, you get the following: all done Because the ++ operator is in front of $value, 1 is added to $value before testing. This means that $value is not less than or equal to 0 when the while statement is executed for the first time; as a result, the code inside the while statement is never executed. The Autoincrement Operator Post-Increment The post-increment operator also adds 1 to the variable with which it is associated. However, its behavior is slightly different: $var1 = 43; $var2 = $var1++;
Slide 148: When the ++ operator appears after the variable, the ++ operator is performed after everything else is finished. This means that the original value of $var1, 43, is assigned to $var2. After this assignment is completed, 1 is added to $var1 and the new value of $var1 becomes 44. To see how this works in while statements, examine Listing 4.4. Although it is similar to Listing 4.3, it performs a post-increment operation instead of a pre-increment operation. Listing 4.4. A program that uses the post-increment operation. 1: 2: 3: 4: 5: 6: } print("all done\n"); #!/usr/local/bin/perl $value = 0; while ($value++ <= 5) { print("value is now $value\n"); $ program4_4 value is now 1 value is now 2 value is now 3 value is now 4 value is now 5 value is now 6 all done
Slide 149: $ You are probably wondering why the output of Listing 4.4 contained the following line: value is now 6 To figure out what happened, examine the value stored in $value each time the condition in the while statement is tested. Table 4.5 lists the contents of $value when the condition is tested, the result of the test, and $value immediately after the condition is tested (after the ++ operator is applied). Table 4.5. Condition evaluation. $value at time of Result true (0 <= 5) true (1 <= 5) true (2 <= 5) true (3 <= 5) true (4 <= 5) true (5 <= 5) false (6 <= 5) $value after test 0 1 2 3 4 5 6 test 1 2 3 4 5 6 7 (exit while) As you know, when the condition at the top of a while statement is true, the code inside the statement is executed, which in this case is print("value is now $value\n"); This is why the line value is now 6 appears-$value is 5 at the time the condition is tested, so the result is true. To fix this problem, change the while condition to the following and run the program
Slide 150: again: while ($value < 5) { This is the output you get from the changed program: value is now 1 value is now 2 value is now 3 value is now 4 value is now 5 all done Now, when $value is 5, the statement while ($value++ < 5) is false, and the code inside the while is not executed. The Autodecrement Operator As you've seen, the ++ operator adds 1 to the value of the variable it is associated with and can appear either before or after the variable. The -- operator, or autodecrement operator, works in the same way, but it subtracts 1 from the value of the variable it is associated with, as follows: $a--; --$a; $result = $a--; $result2 = --$a; When the -- operator is in front of the variable, the operation is a pre-decrement operation, which means that 1 is subtracted from the variable before anything else happens.