hello_world.pl

Note: the below line must be the first line of code, you can find the location of perl by using the which command, also the perl program must have executable privileges

#!/usr/local/bin/perl

#!/usr/local/bin/perl
print "Hello World!\n";

$var = "Hello World!";

$total_salary = 13000;

Note: do not forget the semi-colon at the nd to terminate the statement

if ($number) { print "The number is not zero"; }

if ($number == 21 ) { print "The number is 21 "; }

if ($number1 == $number2) {
       print "Number1 is equal to number2";
}
elsif ($number1 == $number3) {
       print "Number1 is equal to number3";
}
elsif ($number1 == $number4) {
       print "Number1 is equal to number4";
}
else {
       print "Number1 does not match any number ";
}

$number = 1;

while ($number != 5) {
    print ( "The number is still not 5\n");
    $number = $number + 1;
}

Note: There is a possibility that the while loop will not run if the condition has already been meet.

$number = 5;

until ($number == 5) {
   print "Number is not 5 yet!\n";
   $number = $number +1 ;
}

Note: in other languages until loop always runs at least once but perl is different, if the conditional statement has already been meet then the until loop will not run as shown above

$salary = 10000;
$pay_reduction = -100;

$mars_bar = 0.50;
$breakages = -1.50;
$bonus = .1;

$a_large_number = 1.2e+05;          # remember that e+05 means multiply by 100000
$a_tiny_number = 1.2e-05;           # remember that e-05 means divide by 100000

$string = "Hello World";

## Substitution (double and single quotes)
$string = "You have $balance in your bank";   # using double quotes $balance will be substituted with the value of $balance
$string = 'You have $balance in your bank';   # will not substitute $balance because single quotes means take literary        

## Using escape sequences
$string = "Hello World!\n";         # notice the new line feed escape sequence
$string = "Hello World!\a";         # beep when you print this
$string = "\uhello World!\n";       # \u forces the h to become upper case

## Using a string as a integer
$string = "43";
$number = 57;
$result = $string + $number;        # the value of string is converted into a number and then added

$x = 2 ** 4;          # take four copies of two and multiply them (2 * 2 * 2 * 2 = 16)
$y = 3 ** 5;          # 3 * 3 * 3 * 3 * 3 = 243;

$ x = 2 ** -5;        # this is the fraction 1/32

$x = 25 % 4;          # 25 divided by 4 yields 6 with a remainder of 1, so $x = 1
$x = 24 % 7;          # 24 divided by 7 yields 3 with a remainder 0f 3, so $x = 3

if ( $a == $b )  { .... }
if ( $a < $b )   { .... }
if ( $a > $b )   { .... }
if ( $a <= $b )  { .... }
if ( $a >= $b )  { .... }
if ( $a != $b )  { .... }
if ( $a <=> $b ) { .... }

if ( $age > 5 && $age < 17 ) { .... }
if ( $age > 5 && $age < 17 || $person eq "teacher") { .... }

if ( ! $x ) { .... }     # true if $x is not zero and false if $x is 0;

$x = 124 & 99;         # 01111100 (124) & 01100011 (99) = 01100000 (96)
$x = 124 | 99;
$x = 124 ^ 99;
$x = ~99;

$result = $x >> 1;     # shift bits to the right 01100011 (99) becomes 00110001 (49)
$result = $x << 1;     # shift bits to the left 01100011 (99) becomes 11000110 (198)

$you_are_a = $potatoe . $head;    # this concatenation variables $potatoe, $head into one string value

$a = "Magic"
$a .= "Roundabout"                # produces "Magic Roundabout"

$result = $var == 0 ? 14 : 7;     # if $var equals 0 then $result = 14, if $var is not equal to 0 then                                   # $result = 7

$result = $var =~ /abc/;                     # true if $var has abc in the string

if ( $question =~ /right/ ) { .... }         # true if $var has abc in the string, false if abc is not in $var

$result = $var !~ /abc/;                     # true if $var does not have abc in the string

if ( $question !~ /right/ ) { .... }         # true if $var does not have abc, false if abc does appear in string $var

/d[eE]f/       # match words def or dEf
/a[456]c/      # match a followed by any digit then c such as a4c, a5c or a6c
/d[eE]+f/      # match words like def, dEf, deef, dEeF, dEEeeEef, etc

/d[a-z]f/      # match words like def, def, dzf, dsf, etc
/1[0-9]0/      / match numbers like 100, 110, 120, 150, 170, 190, etc

/^hello/       # match only if line starts with hello
/hello$/       # match only if hello is at end of line

/\bdef/        # only matches when def is at the beginning of a word define, defghi
/def\b/        # only matches when def is at the end of a word abcdef

/\Bdef/        # matches abcdef (opposite of \b)
/def\B/        # matches defghi (opposite of \b)

s/abc/def/                       # substitute the first occurrence of abc with def
s/abc//                          # delete first occurrence abc
s/abc//g                         # delete all occurrences of abc (global substitution)

Note: you can use any other pattern-matching option with substitution

tr/abc/def/                      # translate all a into d, all b into e, all c into f
y/a-z/A-Z/                       # translate all characters into upper case, a=A, b=B, etc

Note: you can use y/ instead of tr/, you have several options
/c  -  Translate all characters not specified
/d  -  Delete all specified characters
/s  -  Replace multiple identical output characters with a single character

for ($count = 1; $count <= 10; $count++)
{
   print ("Count: $count");
}

## More complex for loop
for ($line = <STDN>, $count = 1; $count <= 3; $line = <STDIN>, $count++)
{
   print ($line);
}

for ( control variable initialization ; loop continuation ; increment/decrement of the control variable )

@word = qw( hello world goodbye and goodnight );

foreach $word (@word)
{
   print ("The word is $word\n");
}

## More complex foreach loop
$line = "This is a lovely day to be fishing";

foreach $word (reverse sort split(/[ ]+/, $line))
{
   print ("$word ");
}    

$count = 1;
do {
  $count++;
  print ("$count\n");
} while ($count < 10);

Note: the do statement will execute at least once

$count = 1;
while ( $count <= 10 )
{
   print ("Count: $count \n");
   last if ($count >= 5);          // break out of the while loop if $count is 5
   $count++;
}

$count = 1;
while ( $count <= 10 )
{
  redo if ($count++ % 2 == 0);   // because of this statement goes beyond 10
  print ("Count: $count \n");
}

Note: notice that the loop continues beyond the while loops condition because of the redo statement

STOP: for ( $row = 1; $row <= 10; $row++ )
      {
         for ( $column = 1; $column <= 5; $column++ )
         {
            print ("Column : $column Row: $row\n");
            last STOP if ( $row == 5 );
         }
      }

Note: you can also use redo and next with labeled blocks

JUMPHERE: print ("Do not use the goto statement\n");
print ("This statement is below the goto statement\n");
goto JUMPHERE;

Note: this code will result in a infinite loop, told you so never ever use goto statements

#####################
## salaryCheck SUB ##
#####################
sub salaryCheck {
   if ( $salary > 50000)
   {
      print("You are promoted to manager and required to work 20 hours more\n");
   }
}

#####################
##      MAIN       ##
#####################
$salary = 60000;

print("Checking your salary\n");
&salaryCheck;

Note: the comments making it clear where the subroutines are, this helps any programmer when he/she has to change your code.

salaryCheck;                      ## This would fail as the subroutine has not been defined yet
                                  ## Now you know why i like putting subroutines at the top

#####################
## salaryCheck SUB ##
#####################
sub salaryCheck {
   if ( $salary > 50000)
   {
      print("You are promoted to manager and required to work 20 hours more\n");
   }
}

#####################
##      MAIN       ##
#####################
$salary = 60000;

print("Checking your salary\n");
salaryCheck;                       ## LOOK no & (ampersand)

Note: you can only obmit the & (ampersand) if the subroutines are defined before calling them

####################
####    Main    ####
####################
$total = 0;
foreach $number (&getNumbers)      ## can even call subroutines from the for loop
{
   $total += $number;
}
print ("\nThe total is: $total\n");

####################
####    Main    ####
####################
print ("\nThe dummy_value is " . &getDummy );

Note: we can use the keyword return to return a different value than the last expression

####################
### localVar SUB ###
####################
sub localVar
{
   my $total = 100;        ## defining a local variable with my keyword
   return $total;
}

##################
###    Main    ###
##################
$total = 10;
print ("Local total is $total\n");
print ("Subroutine local total is " . &localVar)

########################
## whoDoYouupport SUB ##
########################
sub whoDoYouSupport
{
my ($team, $home, $crowd) = @_;        # place the passed arguments into local variables getting them
                                       # from the system array variable @_

print("Team: $team\n");
print("Home Ground: $home\n");
print("Capacity: $crowd\n");

print ("system array variable first element is " . $_[0]);    # acts just like any normal array
}

##################
###    Main    ###
##################
$footballTeam = "Milton Keynes Dons";
$ground = "MK Stadium";
$capacity = 30000;

&whoDoYouSupport($footballTeam, $ground, $capacity);   # pass the arguments to the subroutine

##################
###    Main    ###
##################
$num_one = 1;
@num_list = qw( 2 3 4 5);
$num_six = 6;

&getLists($num_one, @num_list, $num_six);      # pass all the lists as arguments

####################
### routine2 SUB ###
####################
sub routine2 {
   print("You called subroutine two from subroutine one\n");
}

##################
###    Main    ###
##################
&routine1;

#####################
### rightcalc SUB ###
#####################
sub rightcalc {
   my ($index) = @_;
   my ($result, $operand1, $operand2);

   if ( $index+3 == @list )
   {
      $operand2 = $list[$index2+2];
   }
   else
   {
      $operand2 = &rightcalc($index+2);
   }
   $operand1 = $list[$index+1];
   if ($list[$index] eq "+" )
   {
      $result = $operand1 + $operand2;
   }
   elsif ($list[$index] eq "*" )
   {
      $result = $operand1 * $operand2;
   }
   elsif ($list[$index] eq "-" )
   {
      $result = $operand1 - $operand2;
   }
   else
   {
      $result = $operand1 / $operand2;
   }
}

##################
###    Main    ###
##################
$inputline = <STDIN>;$inputline =~ s/^\s+|\s+$//g;
@list = split(/\s+/, $inputline);
$result = &rightcalc(0);
print ("The result is $result\n");

##################
###  my_sub    ###
##################
sub my_sub {
   local (*subarray) = @_;      # tells the perl interpreter to operate on the actual list

   foreach $number (@subarray) {
      print($number . "\n");
   }
}

##################
###    Main    ###
##################
@list = qw( 1 2 3 4 5);
&my_sub(*list);                 # the argument *foo indicates that the array @foo is to be passed to
                                # my_sub and aliased

exit;
print("should not see this as it is after exit statement\n");
BEGIN { print("This will always execute\n") };
END { print("This will also always execute even you you stop the program with die or exit\n")};

@list = qw( 1 2 3 4);
&crazysun(@list);

AUTOLOAD { print("subroutine $AUTOLOAD does not exist check your code\n"); }

Note: useful if you have very large scripts or have many perl modules

$~ = "MYFORMAT";                            # set the system variable $~ to the format you want to use
write;                                      # call the built-in write function

format MYFORMAT =                                 
===================================
Here is the text i want to display.
===================================
.                                           # don't forget the single dot

$line = "hello this is a test program";

$line =~ s/[^aeiou]//g;
@vowels = split(//, $line);
foreach $vowel (@vowels)
{
   $vowelcount{$vowel} += 1;
}

$~ = "MYFORMAT";
write;

format MYFORMAT =
=====================================================
Number of vowels found in text file:
      a: @<<<<< e: @<<<<<
      $vowelcount{"a"}, $vowelcount{"e"}
      i: @<<<<< o: @<<<<<
      $vowelcount{"i"}, $vowelcount{"o"}
      u: @<<<<<
      $vowelcount{"u"}
=====================================================
.

Note: the @<<<<< means six left justified characters

$~ = "PAGE_FOOTER";
write;

format PAGE_FOOTER =
page @<<<
$%
.

Note: the system variable $% holds the current page number and starts from 0

format MYFORMAT =
myformat
.
format TOP_OF_PAGE =
top of the page
.

$~ = "MYFORMAT";
write;

format MYFORMAT =
~ ^>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
$string
.

Note: the ^<< trys to fit as many lines as possible, @* will print as is including newlines
~ will remove any blank lines

open (OUTFILE, ">file1");
select (OUTFILE);
$~ = "WRITELINE";
$^ = "TOP_OF_PAGE";
$= = 60;

while ($line = <STDIN>)
{
   write;
}

close (OUTFILE);

format TOP_OF_PAGE =
                    -Page @<
                          $%
.
format WRITELINE =
@>>>>>>>>>>>>>>>>>>>>
$line
.

printf("The number is %d", $number);
printf("The house number is %d and the town is %s", $number, $town);

printf("amount: %20d", $salary);     # 20 fields of characters (right justified)
printf("amount: %-20d", $salary);    # 20 fields of characters (left justified)

printf("sale cost: %5.2f", $cost);   # 5 = total number of fields including the decimal point
                                     # 2 = total numbers after decimal point example:   99.99

## Example one
$print = "print (\"hello world\\n\");";
eval ($print);

## Example two (this has a error)
$print = "print (\hello world\\n\");";     # I have removed a double quote
eval ($print);
print "Errors: " . $@                      # $@ will contains the error message

Note: the $@ system variable is used to indicate if the statement was executed properly, if no error $@ contains null, if any errors $@ will have the error message

@proglist = ("echo", "hello", "world");     # echo is the program, hello world are the arguments to echo
system(@proglist);

Note: sometimes it is use to use the below command to make sure that buffers are flushed immediately, as sometimes calling two systems duplicate outp[ut can be mixed

$| = 1;       # make sure output buffers are flushed immediately.

print "Parent PID: " . $$ . "\n";

$retval = fork();

if ($retval == 0) {
   # this is the child process
   print $retval . "\n";
   print "Child PID: " . $$ . "\n";
   exit;
} else {
# this is the parent process
}

Note: to terminate a child process you use the exit function which is discussed lter

$retval = fork();

if ($retval != 0) {
   # this is the parent process
   close (INPUT);         # the parent process does not need INPUT
   print "Enter a line of input: ";
   $line = <STDIN>;
   print OUTPUT ($line);
} else {
   # this is the child process
   close (OUTPUT);        # the child process does not need OUPUT
   $line = <INPUT>;       # because data from OUTPUT is piped into INPUT, the program waits until the
                          # data is actually sent before continuing
   print ($line);
   exit(0)
}

exec ("vi", "test.pl");

Note: exec has the same buffering problems as system

require ("syscall.ph");   # must have the syscall header

my $buf = "\0"x64;
my $path = "/etc/motd";

syscall(&SYS_statfs, $path, $buf) == 0 or die;

my ($bsize, $blocks, $bfree, $bavail, $files, $ffree, $namelen) = unpack "x4 L6 x8 L", $buf;

print <<EOT;
   Optimal transfer block size: $bsize
   Blocks in file system: $blocks
   Blocks free: $bfree (${\(int $bfree/$blocks*100)}%)
   User blocks available: $bavail (${\(int $bavail/$blocks*100)}%)
   Inodes: $files
   Free inodes: $ffree (${\(int $ffree/$files*100)}%)
   Maximum filename length: $namelen
EOT

# waitpid (<procid>,<waitflag>)

$procid = fork();                                    # obtain the child process ID

if ($procid == 0) {
   # this is the child process
   print ("CHILD: this line is printed first\n");
   exit(0);
} else {
   # this is the parent process
   waitpid ($procid, 0);                              # wait until child process finishes
   print ("PARENT: this line is printed first\n");
}

Note: the waitflags are
0  - normal wait
1  - process has been found and has terminated
-1 - child process does not exist

sub test {
   ($package, $file, $line_num) = caller;

   print "Package: " . $package . "\n";
   print "File: " . $file . "\n";
   print "Line Number: " . $line_num . "\n";
}

if ( $var == 44) {
   local ($localvar);                # this is a local variable and does not affect any other $localvar's
}

Note: becarefuil when using loops as you can create alot of local variables

($user,$system,$cuser,$csystem) = times;   # The four element list is returned

if ($procid == 0) {
   # this is the child process
   print ("CHILD: this line is printed first\n");
   exit(0);
} else {
   # this is the parent process
   waitpid ($procid, 0); # wait until child process finishes
   print ("PARENT: this line is printed first\n");
}

print "User: " . $user . "\n";
print "System: " . $system . "\n";
print "Child User: " . $cuser . "\n";
print "Child System: " . $csystem . "\n";

# position = index (string, substring)
# position = index (string, substring, skip characters)

$string = "elephant";
$position = index($string, "ant");

print "ant is located at position " . $position . " in elephant";

# position = rindex (string, substring)
# position = rindex (string, substring, skip characters)

$string = "elephant";
$position = rindex($string, "ant");

print "ant is located at position " . $position . " in elephant";

Note: the only different with index and rindex is thet rindex starts at the right hand side of the string

$new_string = tr/a-z/A-Z/;       # new string goes in $_, number of characters change is returned

print "We have changed " . $string . " to " . $_ . "\n";
print $string . " has " . $new_string . " characters"

$string = "Mississippi";

while ($string =~ /i/g) {
   $position = pos($string);
   print ("matched at position $position\n");
}

# substr (expr, skipchars, length)

$string = "This is a simple character string";

$sub1 = substr($string, 10 , 6);       # skip 10 characters, get next 6 characters
$sub2 = substr($string, 17);           # skip 17 characters, get the rest of the string

print '$sub1 is ' . $sub1 . ' and $sub2 is ' . $sub2;

$newstring = quotemeta($string);

print $string . "\n";
print $newstring;                      # prints 'Hello\ World'

$string1 = join( "::", @list);
$string2 = join( " ", @list);

print $string1 . "\n";
print $string2;

$num = 26;
$outstr = sprintf("%d = %x hexadecimal or %o octal\n", $num, $num, $num);

print $outstr;

$string = "hello World!";
chop ($string);                       # string is now "Hello World", removed the bang (!)
                                      # chop returns the last character chopped in this case the !

@list = qw ( one two three );
chop (@list)                          # list is now "on","tw","thre"
                                      # chop returns the last character chopped in this case e

Note: chop is normally used to remove the newline character when requesting user input from <STDIN>

$/ = "o";                             # remove the last character only if it's a 'o'
chomp $string;

$/ = "e";                             # remove the last character only if it's a 'e'
chomp @list;

print $string . "\n";
print "@list";                        # notice only one and three get chomped because they have a 'e'
                                      # as the last character

Note: you can chomp multiple characters as well

print "Enter something to encrypt: ";

$encrypt = <STDIN>;

print "\n Your text encrypted: " . crypt($encrypt, $salt_key);   

Note: DES uses a salt key to change the DES algorithm to make it more differcult to decode.

print hex($hex);                     # prints out 65535

print int($float);                   # prints out 34

print oct($octal);                   # prints out 127

print ord($char) . "\n";

print chr(ord($char));               # using ord to obtain the numeric ASCII of V (86)

@lengtharray = scalar(@array);

print "@lengtharray" . "\n";         # number of array elements of @array (3), is converted into a one
                                     # element list and assigned to @lengtharray

$| = 1;

print "Enter a string: \n";
@line = scalar (<STDIN>);            # specifying scalar with <STDIN> ensures that only one lin is read
                                     # from STDIN

print "@line";

$val1 = vec ($vector, 0, 4);         # start at right get 0011 (4 bits) = 3 in decimal
$val2 = vec ($vector, 1, 4);         # start at left get 1101 (4 bits) = 13 in decimal

print ("high-to-low order values: $val1 and $val2");

Note: specifying 0 means start at the right end, 1 means start at the left end

if (defined ($array[0])) {
   print "element 0 in array is defined\n";
} else {
   print "element 0 in array is NOT defined\n";
}

if (defined ($array[1])) {
   print "element 1 in array is defined\n";
} else {
   print "element 1 in array is NOT defined\n";
}

$integer = pack("i", 171)

$integer = pack("i*", 14, 26, 11, 241);

Note: takes number 171 converts it into the format used to store integers on your machine and returns the converted integer in $integer. This converted integer can now be written out to a file or passed to a program using system or exec functions

$mystring = pack("a6", "test");

Note: This creates a string of 6 characters (4 for the word test and 2 null characters for padding)

$mystring = pack("a @6 a", "test", "test2");

Note: This integer indicates the number of bytes the string must contain at this point. here the test string is convert to ASCII format, because this string is only 4 characters long, and the pack format @6 specifies that it should be 6 characters two null characters are added to the string before test2 is packed.

print $mystring2;

$skipnum = unpack("@4i", $mystring);

Note: the @4 means skip 4 bytes then unpack