Perl CGI Happy Path: Using Operators

Using Operators on Scalar Literals and Variables

• Things are no fun until you can do stuff with them.
• With Perl, the things we use to do stuff to scalars and literals are called operators.
• Different operators do different things and take different numbers of arguments.
• Most of these operators will look pretty familiar.

Valid Arithmetical Operators for Scalar Numbers

• The simplest operator is the "=" (equals) operator.
• It takes the scalar literal or variable on the right hand side of the "=" sign, and puts a copy of it in the scalar variable that is on the left hand side. Obviously, you cannot put a scalar literal on the left hand side of the "=" operator, as scalar literals cannot change. You can, however, put either a scalar literal or a scalar variable on the right hand side of the "=" operator, since we are just making a copy of it.
• Each of these operators take two numeric arguments, and return numerical result of the specified operation. We typically (but not necessarily) store the result somewhere by using the "=" operator.

Table of Arithmetical Operators for Scalar Numbers

Operator Symbol	Operation
+	Addition
-	Subtraction
*	Multiplication
/	Division
**	Exponentiation
%	Modulus (remainder)

• Examples:
  

  $result = 3 + 5 # Three plus five (will be equal 8)
  $total = $counter + 5 # Contents of scalar $counter plus five
  $x = 2 ** 3 # Two to the third power (will equal 8)
  $a = $a * $c # Contents of $a times the contents of $c
  $rem = 17 % 7 # Remainder when 17 is divided by 7 (will equal 3)
  

Valid Logical Operators for Scalar Numbers:

• Return true or false.

Table of Logical Operators for Scalar Numbers

Operator Symbol	Operation
==	Logical Equal To
<	Logical Less Than
>	Logical Greater Than
<=	Logical Less Than or Equal
>=	Logical Greater Than or Equal
!=	Logical Not Equal

• Examples:

  3 < 5 # Three is less then five (will be true)
  2 >= 3 # Two is greater then or equal three (will be false)
  17 != 7 # Seventeen is not equal to 7 (will be true)
  

• Remember that all numbers are internally represented as double precision floats, so you may get occasional weirdness with numbers not being exact (for example 1/3). The good news is that you almost always see what you would expect in normal usage.

Valid Logical Operators for Strings:

• You can also use operators to modify strings.
• Valid Operators for Scalar Strings: Return the modified string.

Table of Operators for Scalar Strings

Operator Symbol	Operation
.	Concatenation (append)
x n	Repeat string n times

• Examples:

  $newStr = "Hello" . " World" # Returns string "Hello World"
  $bike = "Z" . ( "o" x 8 ) . "m" # Returns "Zoooooooom"
  

• Note that full regular expression support is also built in to Perl, and it provides one of the richest set of string operators known to man. We will learn about them later.
• Valid Logical Operators for Scalar Strings: Return true or false.

  Table of Logical Operators for Scalar Strings

  Operator Symbol	Operation
  eq	Alphabetic Equal To
  lt	Alphabetic Less Than
  gt	Alphabetic Greater Than
  le	Alphabetic Less Than or Equal
  ge	Alphabetic Greater Than or Equal
  ne	Alphabetic Not Equal

• Examples:
  "Alpha" lt "Beta" # The word Alpha comes before the word Beta in alpha sort (will be true)
  "Eight" ge "Seven" # The word Eight comes after the word Seven in alpha sort (will be false)
  "Hello" eq "Hello" # Check if strings are equal (will be true)
  
• There are different operators for scalar strings and scalar numbers because Perl as a general rule does not know (or care) if a scalar is a string or an integer. This means that 2 < 10 is true, but "2" lt "10" is false.

Operator Precedence: Order of Operations

• There are built in rules for which operators get done first in a given equation. This is important, because the order of these operations can change the result of an equation.


• For example, the equation "2+3*4" would be equal to 20 if you add first, but would be equal to 14 if you multiply first.


• Computer science majors love to dither on subjects like this because it makes them feel superior, and because they are easy test questions to grade.


• My personal opinion is that any equation like "2+3*4" is broken even if it happens to do what you want. I believe any compound expression should use parenthesis to explicitly show the order desired for the operations. In this example, it should be either written as "(2+3)*4" or as "2+(3*4)".


• When interpreting parenthesis in an equation, always solve the innermost parts of the equation first, then work your way out. I think this is called "Foils Law", but you would have to ask one of the aformentioned computer science types to be sure.


• For example, here is how the following equation would decompose.
  (((1+2) * 3 ) / (2*5))
  (((3) * 3 ) / (2*5))
  ((3 * 3 ) / (2*5))
  ((9) / (2*5))
  ((9) / (10))
  (9 / 10)
  (.9)
  .9
  


• If you have to know the default order of operations, look it up just about anywhere... it is almost identical for all 10 or so languages I have used, and works the same as most calculators.

Other Very Common Operators and Functions

• chomp($someScalar) will remove the trailing newline at the end of the specified scalar argument. If no trailing newline exists, then the scalar is left unchanged.


• chop($someScalar) is similiar, but will remove the last character in the supplied argument, no matter what it may be.

Reading from the keyboard

• Perl can uses concepts known as "streams" and "pipes".
• The normal input pipe is called Standard Input. It automatically has a file handle associated with it named STDIN. This handle is automatically opened at the start of every Perl program.
• To read from any file handle, use the "Diamond Operator" (a less than symbol, followed by the file handle, followed by the greater than symbol).
• You can use the diamond operator to read from standard input anywhere and anyway you would use a normal scalar.
• The special symbol for standard input is <STDIN>.
• Basically, unless the user deliberately overrides it, <STDIN> gets what the user types.
• For most operating systems, <STDIN> will have a newline tacked on to the end of it.
• If a pipe has been closed, <STDIN> will return undef.
• Unless the user deliberately overrides it, <STDIN> will pick up a line of text at a time. That is, the user will type in characters, and when they hit return Perl will get the complete line (with newline) in it's entirety.
• Example:

  $MyName = <STDIN> ;
  $Greeting = "Hello $MyName\n";
  

• Perl was designed to allow you to use an assignment expression interchangebly with a variable, so you can get away with the following handy shorthand (and you will likely see it often).
• chomp ($MyName = <STDIN> );
  

Printing to the Screen

• The normal output pipe is called Standard Output.
• Just like STDIN is automatically opened at the start of every program as a file handle for the keyboard, STDOUT is automatically opened as a file handle for the screen (or whatever the current default output device is).
• To send a string to the standard output pipe, use the print command.
• You can manually specify the default filehandle (STDOUT), or you can simply omit any filehandle argument and it will use STDOUT by default.
• Example:

  $MyName = <STDIN>
  chomp $MyName;
  $Greeting = "Hello $MyName";
  print "$Greeting\n";
  print STDOUT "How are you?\n";