Mail to a Friend Receive updates via our RSS feed

Perl Syntax

This tutorial is an introductory look at the Perl language and its syntax.

Semicolons
All Perl lines must end in semicolons. Perl does not use the carriage return to indicate the end of a line, it uses the semicolon.

$myName = "Jerry";
print "Hello, $myName\n";

Standard Shell Script Stuff

Where is the Perl program?
You need to tell the Unix shell where to find the “interpreter” for your shell script. Put the following line at the top of all of your Perl scripts.

#!/usr/local/bin/perl

chmod u+x hello

#tell Perl my name

Put the following line in front of the line that contains “print”:

#say hello to me!

You can also use comments to tell Perl to ignore parts of your program. You might want to do this to track down a bug, or to bypass a part of the program that isn't working correctly.

$myName = "Jerry";

A “scalar” variable is a variable that only holds one value. Later, we’ll get into “array” variables, which can hold more than one value, for example, all the first names in Academic Computing. Scalar variables always begin with a dollar sign.

#Test text and numeric variables
$First = "1.0";
$Second = "1";
if ($First eq $Second) {
	print "$First and $Second are the same with EQ!\n";
} else {
	print "$First and $Second are different with EQ!\n";
}
if ($First == $Second) {
	print "$First and $Second are the same with ==!\n";
} else {
	print "$First and $Second are different with ==!\n";
}

What happens if you get rid of the quotes, and why?

Working with Numbers
You can do any normal math with numbers: addition, subtraction, multiplication, and division. And you can use parentheses to partition off parts of the equations. Perl uses “algebraic” precedence, which means that certain operations take precedence over other operations. Multiplication and division, for example, take precedence over addition and subtraction. Two plus five times three is seventeen, not twenty-one.

$x = 2; $y = 5;

$z = $x + $y;

$a = $z - $y;

$b = $y * $x;

$c = $z/$a;

$d = ($a + $b)*$c;

Functions
Perl uses ‘functions’ in much the same way as any other programming language. The function has a name, and it takes ‘arguments’ in ‘parentheses’. The function is on the left, and the repository for the answer is on the right:

$a = sqrt($b);
print “The square root of $b is $a.\n”;

Look in the Perl man pages or reference guide for a complete listing of functions. Here are some common ones:

cos($number)

int($number)

sin($number)

sqrt($number)

ord($string)

index($string1,$string2,$number)

length($string)

substr($string,$number1,$number2)

Structure
A program’s “structure” controls which program lines get used. The three basic structural items in Perl are the “if” statement, the “while” statement, and the “foreach” statement.

These statements all use a “comparison” to determine whether or not to execute other Perl statements. Structural statements can be nested, so that a “while” can be inside an “if” which is inside another “if” inside another “while”.

The comparison is always inside parentheses. Curly brackets determine which part of the Perl program are controlled by the structural statement.

if (comparison) {
	do this!
}

An “if” can also contain an “else”. If the comparison is “true”, the first part is done. Otherwise, the second part is done:

if (comparison) {
	do this!
} else {
	do something else!
}

An “if” can also contain multiple “elsifs” which contain their own comparisons:

if (comparison) {
	do this!
} elsif (another comparison) {
	do that!
} elsif (yet another comparison) {
	do something!
}

Go ahead and try here:

$myName = $ARGV[0];
if ($myName eq "Jerry") {
	print "Welcome!\n";
} elsif ($myName eq "Steve") {
	print "Go away!\n";
} elsif ($myName) {
	print "Who are you really, $myName?\n";
} else {
	print "Who are you?\n";
}

You’ll notice at least two new items in this program. First, that “ARGV[0]” is an array. Don’t worry about it for now. All you need to know is that it is the first item on the command line. “ARGV[1]” would be the second, and so on.

In the third “elsif”, the comparison doesn’t compare with anything. If a comparison is nothing except a variable name, we are checking to see whether or not that variable exists at all. If you type nothing on the command line, “ARGV[0]” doesn't have anything in it, so “$myName” doesn’t have anything in it, either, and “($myName)” ends up being false. Otherwise, we know that “$myName” has something in it, we just don’t have a plan for it yet.

while (0) {
	print "The king is a fink.\n";
}

will never print, because 0 is never true. On the other hand,

while ($myName) {
	print "Hello, $myName.\n";
}

will print only if the variable “$myName” exists. And then, it will continue to print forever, because “$myName” will always exist. The following is slightly more useful:

#countdown from a user specified number
$Counter = $ARGV[0];
while ($Counter) {
	print "T-$Counter seconds...\n";
	$Counter--;
}
print "Boom!\n";

Two dashes after a variable name reduces that variable’s numeric value by one. You can also use two plusses to increase the variable’s value by one. What happens if the variable isn't a numeric variable? How would you fix it in the above program?

In general, you want your comparisons to be as robust as possible. Look for any conditions that could result in your loop going forever (called an “infinite loop”), and guard against it. In this case, replace the line “while ($Counter)” with “while ($Counter >= 0)”

#countdown from a user specified number
$Counter = $ARGV[0];
while ($Counter >= 0) {
	print "T-$Counter seconds...\n";
	$Counter--;
}
print "Boom!\n";

foreach $variable (@array) {
	do something with $variable
}

Foreach loops once through itself for each value in the array. If there are four values in the array, the loop will happen four times. Each time through the loop, it resets the value of the scalar variable to next value in the array.

foreach $argument (@ARGV) {
	print "Merry Christmas, $argument!\n";
}

You can also use “foreach” to loop through a range of numbers.

foreach $Counter (1..10) {
	print "$Counter potato...\n";
}
print "Jump!\n";

About this Tutorial
This tutorial is written by Jerry Stratton and is published under the GNU Free Documentation License.

NASA Tech Briefs features exclusive reports of innovations developed by NASA and its industry partners/contractors that can be applied to develop new/improved products and solve engineering or manufacturing problems. Authored by the engineers or scientists who did the work, the briefs span a wide array of fields, including electronics, physical sciences, materials, computer software, mechanics, machinery/automation, manufacturing/fabrication, mathematics/information sciences, and life sciences. NASA Tech Briefs also contains feature articles on successful NASA spinoffs, profiles of NASA tech transfer resources, news briefs, and application stories. Regular columns describe new patents, industry products, software, and literature.   Subscribe Free!