Most Viewed


cubecart 5 navigation panel missing

If you login to your cubecartv5 panel and navigation if gone, then tack this onto your URL:¬†_g=maintenance and click “clear cache” and submit. Worked for me. So your URL would look something like this:¬†admin.php?_g=maintenance

web resilience and dns round robin

Nice piece of work on recent browsers resilience and dns round robin

Perl Signals

Perl Signals

Perl allows you to trap signals using the %SIG associative array. Using the signals you want to trap as the key, you can assign a subroutine to that signal. The %SIG array will only contain those values which the programmer defines. Therefore, you do not have to assign all signals. For example, to exit cleanly from a ^C:


$SIG{'INT'} = 'CLEANUP';

sub CLEANUP {

print "\n\nCaught Interrupt (^C), Aborting\n";

exit(1);

}

There are two special “routines” for signals called DEFAULT and IGNORE. DEFAULT erases the current assignment, restoring the default value of the signal. IGNORE causes the signal to be ignored. In general, you don’t need to remember these as you can emulate their functionality with standard programming features. DEFAULT can be emulated by deleting the signal from the array and IGNORE can be emulated by any undeclared subroutine.


In 5.001, the $SIG{__WARN__} and $SIG{__DIE__} handlers may be used to intercept die() and warn(). For example, here’s how you could promote unitialized variables to trigger a fatal rather merely complaining:


#!/usr/bin/perl -w 

require 5.001;

$SIG{__WARN__} = sub {

if ($_[0] =~ /uninit/) 

{

   die $@;

} 

else 

{

   warn $@;

} 



};



Perl DBI

Perl DBI Example

The DBI module enables your Perl applications to access

multiple database types transparently. You can connect to

MySQL, MSSQL, Oracle, Informix, Sybase, ODBC etc. without

having to know the different underlying interfaces of each.

The API defined by DBI will work on all these database types

and many more.

What is DBI and DBD::Oracle and where can one get it from?

DBI (previously called DBperl) is a database independent interface module for Perl. It defines a set of methods, variables and conventions that provide a consistent database interface independent of the actual database being used.

DBD::Oracle is the Oracle specific module for DBI. It can be downloaded from CPAN.

What DBI drivers have I got?

In DBI you can programmatically discover what DBI drivers are installed.


#!/usr/bin/perl -w

require DBI;



my @drivers = DBI->available_drivers;

print join(", ", @drivers), "n";


Example:


use strict;

use DBI;

my $dbh = DBI->connect( 'dbi:Oracle:orcl',

                        'username',

                        'password',

                        {

                          RaiseError => 1,

                          AutoCommit => 0

                        }

                      ) || die "Database connection not made: $DBI::errstr";



my $sql = qq{ CREATE TABLE employees ( id INTEGER NOT NULL,

                                       name VARCHAR2(128),

                                       position VARCHAR2(128),

                                     ) };

$dbh->do( $sql );

$dbh->disconnect();

SYBASE

Sybperl implements three Sybase extension modules to perl (version 5.002 or higher). Sybase::DBlib adds a subset of the Sybase DB-Library API. Sybase::CTlib adds a subset of the Sybase CT-Library (aka the Client Library) API. Sybase::Sybperl is a backwards compatibility module (implemented on top of Sybase::DBlib) to enable scripts written for sybperl 1.0xx to run with Perl 5. Using both the Sybase::Sybperl and Sybase::DBlib modules explicitly in a single script is not garanteed to work correctly.

The general usage format for both Sybase::DBlib and Sybase::CTlib is this:

use Sybase::DBlib;

# Allocate a new connection, usually refered to as a database handle

$dbh = new Sybase::DBlib username, password;

# Set an attribute for this dbh:

$dbh->{UseDateTime} = TRUE;

# Call a method with this dbh:

$dbh->dbcmd(sql code);

The DBPROCESS or CS_CONNECTION that is opened with the call to new() is automatically closed when the $dbh goes out of scope:


sub run_a_query {

my $dbh = new Sybase::CTlib $user, $passwd;

my @dat = $dbh->ct_sql("select * from sysusers");

return @dat;

}

# The $dbh is automatically closed when we exit the subroutine.

Sybase::DBlib

A generic perl script using Sybase::DBlib would look like this:


use Sybase::DBlib;

$dbh = new Sybase::DBlib 'sa', $pwd, $server, 'test_app';

$dbh->dbcmd("select * from sysprocessesn");

$dbh->dbsqlexec;

$dbh->dbresults;

while(@data = $dbh->dbnextrow)

{

 .... do something with @data ....

}

$dbh = Sybase::DBlib->dbopen([$server [, $appname, [{attributes}] ]])

Open an additional connection, using the current LOGINREC information.

$status = $dbh->dbuse($database)

Executes “use database $database” for the connection $dbh.

$status = $dbh->dbcmd($sql_cmd)

Appends the string $sql_cmd to the current command buffer of this connection.

$status = $dbh->dbsqlexec

Sends the content of the current command buffer to the dataserver for execution. See the DB-library documentation for a discussion of return values.

$status = $dbh->dbresults

Retrieves result information from the dataserver after having executed dbsqlexec().

$status = $dbh->dbcancel

Cancels the current command batch.

$status = $dbh->dbcanquery

Cancels the current query within the currently executing command batch.

$dbh->dbfreebuf

Free the command buffer (required only in special cases – if you don’t know what this is you probably don’t need it :-)

$dbh->dbclose

Force the closing of a connection. Note that connections are automatically closed when the $dbh goes out of scope.

$dbh->DBDEAD

Returns TRUE if the DBPROCESS has been marked DEAD by DBlibrary.

$status = $dbh->DBCURCMD

Returns the number of the currently executing command in the command batch. The first command is number 1.

$status = $dbh->DBMORECMDS

Returns TRUE if there are additional commands to be executed in the current command batch.

$status = $dbh->DBCMDROW

Returns SUCCEED if the current command can return rows.

$status = $dbh->DBROWS

Returns SUCCEED if the current command did return rows

$status = $dbh->DBCOUNT

Returns the number of rows that the current command affected.

$row_num = $dbh->DBCURROW

Returns the number (counting from 1) of the currently retrieved row in the current result set.

$status = $dbh->dbhasretstat

Did the last executed stored procedure return a status value? dbhasretstats must only be called after dbresults returns NO_MORE_RESULTS, ie after all the selet, insert, update operations of he sored procedure have been processed.

$status = $dbh->dbretstatus

Retrieve the return status of a stored procedure. As with dbhasretstat, call this function after all the result sets of the stored procedure have been processed.

$status = $dbh->dbnumcols

How many columns are in the current result set.

$status = $dbh->dbcoltype($colid)

What is the column type of column $colid in the current result set.

$status = $dbh->dbcollen($colid)

What is the length (in bytes) of column $colid in the current result set.

$string = $dbh->dbcolname($colid)

What is the name of column $colid in the current result set.

@dat = $dbh->dbretdata[$doAssoc])

Retrieve the value of the parameters marked as ‘OUTPUT’ in a stored procedure. If $doAssoc is non-0, then retrieve the data as an associative array with parameter name/value pairs.

Perl OOP

Perl OOP

Why Object Oriented approach?

A major factor in the invention of Object-Oriented approach is to remove some of the flaws encountered with the procedural approach. In OOP, data is treated as a critical element and does not allow it to flow freely. It bounds data closely to the functions that operate on it and protects it from accidental modification from outside functions. OOP allows decomposition of a problem into a number of entities called objects and then builds data and functions around these objects. A major advantage of OOP is code re-usability.

Some important features of Object Oriented programming are as follows:

  • Emphasis on data rather than procedure

  • Programs are divided into Objects
  • Data is hidden and cannot be accessed by external functions
  • Objects can communicate with each other through functions
  • New data and functions can be easily added whenever necessary
  • Follows bottom-up approach

Concepts of OOP:

  • Objects
  • Classes
  • Data Abstraction and Encapsulation
  • Inheritance
  • Polymorphism

    Briefly on Concepts:

    Objects

    Objects are the basic run-time entities in an object-oriented system. Programming problem is analyzed in terms of objects and nature of communication between them. When a program is executed, objects interact with each other by sending messages. Different objects can also interact with each other without knowing the details of their data or code.

    Classes

    A class is a collection of objects of similar type. Once a class is defined, any number of objects can be created which belong to that class.

    Data Abstraction and Encapsulation

    Abstraction refers to the act of representing essential features without including the background details or explanations. Classes use the concept of abstraction and are defined as a list of abstract attributes.

    Storing data and functions in a single unit (class) is encapsulation. Data cannot be accessible to the outside world and only those functions which are stored in the class can access it.

    Inheritance

    Inheritance is the process by which objects can acquire the properties of objects of other class. In OOP, inheritance provides reusability, like, adding additional features to an existing class without modifying it. This is achieved by deriving a new class from the existing one. The new class will have combined features of both the classes.

    Polymorphism

    Polymorphism means the ability to take more than one form. An operation may exhibit different behaviors in different instances. The behavior depends on the data types used in the operation. Polymorphism is extensively used in implementing Inheritance.

    Advantages of OOP

    Object-Oriented Programming has the following advantages over conventional approaches:

    • OOP provides a clear modular structure for programs which makes it good for defining abstract datatypes where implementation details are hidden and the unit has a clearly defined interface.
    • OOP makes it easy to maintain and modify existing code as new objects can be created with small differences to existing ones.
    • OOP provides a good framework for code libraries where supplied software components can be easily adapted and modified by the programmer. This is particularly useful for developing graphical user interfaces.

    Perl Package

  • To create a class in Perl, we first create a

    package.

  • A package (module) is a module of variables and

    subroutines, which can be re-used over and over again.

  • They provide a separate namespace within a Perl

    program that keeps subroutines and variables from

    conflicting with those in other packages.

    To declare a class named Person in Perl we do:

    package Person;

  • The scope of the package definition extends to the

    end of the file

  • or until another package keyword is encountered.
    Perl Methods

    A method (subroutine) is a way of accessing objects. In

    Perl, a method is just a subroutine defined within a

    particular package. So to define a method to print our

    Person object, we do:

    
    sub print {
    
        my ($self) = @_; ## creating reference
    
        #print Person info
    
        printf( "Name:%s %snn", $self->firstName, $self->lastName );
    
    }
    
    
    
    

    The subroutine print is now associated with the package

    Person. To call the method print on a Person object, we

    use the Perl “arrow” notation. If the variable $mike

    contains a Person object, we would call print on that

    object by writing:

    $mike->print();

    When the object method is invoked, a reference to the

    object is passed in along with any other arguments

    (including class name). This is important since the

    method now has access to the object on which it is to

    operate.

    How do we create object?
  • To create an instance of a class (an object) we need

    an object constructor.

  • This constructor is a method defined within the

    package.

  • Most programmers choose to name this object

    constructor method new, but in Perl one can use any

    name.

  • One can use any kind of Perl variable as an object

    in Perl.

  • Most Perl programmers choose either

    references to arrays or hashes.

    Let’s create our constructor for our Person class using

    a Perl hash reference;

    
    package Person;
    
    sub new {
    
        my $self = {
    
            _firstName => undef,
    
            _lastName  => undef,
    
            _ssn       => undef,
    
            _address   => undef,
    
            _salary    => undef,
    
            _dept      => undef
    
        };
    
        bless $self, 'Person';
    
        return $self;
    
    }
    
    
    
    sub print {
    
        my ($self) = @_; ## creating reference
    
        #print Person info
    
        printf( "Name:%s %snn", $self->firstName, $self->lastName );
    
    }
    
    
  • We created a subroutine (method) called new

    associatedwith the package Person.

  • Other method is print (as discussed earlier).
  • The entries of the hash reference $self become the

    attributes of our object. We then use the bless function

    on the hash reference.

  • The bless function takes two arguments: a reference

    to the variable to be marked and a string containing the

    name of the class. This indicates that the variable now

    belongs to the class Person.

    To create an instance of our Person object:

    my $mike = new Person();

    We have not defined accessor methods or done any error

    checking on the input values or keys or the anonymous

    hash reference, but we have the start of a Perl Person

    OO framework. To make our constructor more flexible and

    to make our class inheritable (more on that later), we

    can define it to use the $class variable to bless the

    hash reference.

    
    #constructor
    
    sub new {
    
        my ($class) = @_;
    
        my $self = {
    
            _firstName => undef,
    
            _lastName  => undef,
    
            _ssn       => undef,
    
            _address   => undef,
    
            _salary    => undef,
    
            _dept      => undef
    
        };
    
        bless $self, $class;
    
        return $self;
    
    }
    
    

    Other object-oriented languages have the concept of

    security of data to prevent a programmer from changing

    an object data directly and so provide accessor methods

    to modify object data. Perl does not have private

    variables but we can still use the concept of accessor

    methods and ask programmers to not mess with our object

    innards.

    For our Person class, we should provides accessor

    methods for our object attributes; name, address, title,

    ssn,salary,dept.

    
    package Person;
    
    use strict;
    
    use Address;  #Person class will contain an Address
    
    
    
    #constructor
    
    sub new {
    
        my ($class) = @_;
    
        my $self = {
    
            _firstName => undef,
    
            _lastName  => undef,
    
            _ssn       => undef,
    
            _address   => undef
    
            _salary    => undef,
    
            _dept      => undef
    
        };
    
        bless $self, $class;
    
        return $self;
    
    }
    
    
    
    #accessor method for Person first name
    
    sub firstName {
    
        my ( $self, $firstName ) = @_;
    
        $self->{_firstName} = $firstName if defined ($firstName);
    
        return $self->{_firstName};
    
    }
    
    
    
    #accessor method for Person last name
    
    sub lastName {
    
        my ( $self, $lastName ) = @_;
    
        $self->{_lastName} = $lastName if defined($lastName);
    
        return $self->{_lastName};
    
    }
    
    
    
    #accessor method for Person address
    
    sub address {
    
        my ( $self, $address ) = @_;
    
        $self->{_address} = $address if defined($address);
    
        return $self->{_address};
    
    }
    
    
    
    #accessor method for Person social security number
    
    sub ssn {
    
        my ( $self, $ssn ) = @_;
    
        $self->{_ssn} = $ssn if defined($ssn);
    
        return $self->{_ssn};
    
    }
    
    
    
    sub salary {
    
        my ( $self, $salary ) = @_;
    
        $self->{_salary} = $salary if defined($salary);
    
        return $self->{_salary};
    
    }
    
    
    
    sub dept {
    
        my ( $self, $dept ) = @_;
    
        $self->{_dept} = $dept if defined($dept);
    
        return $self->{_dept};
    
    }
    
    
    
    
    
    
    
    sub print {
    
        my ($self) = @_;
    
        #print Person info
    
        printf( "Name:%s %snn", $self->firstName, $self->lastName );
    
    }
    
    
    
    1;
    
    
    
    
    Making Objects

    Object-oriented programming sometimes involves

    inheritance. Inheritance simply means allowing one class

    called the Child to inherit methods and attributes from

    another, called the Parent, so you don’t have to write

    the same code again and again. For example, we can have

    a class Employee which inherits from Person. This is

    referred to as an “isa” relationship because an employee

    is a person. Perl has a special variable, @ISA, to help

    with this.

    @ISA governs (method) inheritance. So to create a new

    Employee class that will inherit methods and attributes

    from our Person class, we simply code:

    
    # class Employee
    
    package Employee;
    
    use Person;
    
    use strict;
    
    our @ISA = qw(Person);    # inherits from Person
    
    

    What we have done is load the Person class and declare

    that Employee class inherits methods from it. We have

    declared no methods for Employee but an Employee object

    will behave just like a Person object. We should be able

    to write code:

    
    #create Employee class instance
    
    my $mike =  new Employee();
    
     
    
    #set object attributes
    
    $mike->firstName('mike');
    
    $mike->lastName('Weis');
    
    

    without any other changes.

    Now let’s add some methods.

    
    # class Employee
    
    package Employee;
    
    use Person;
    
    use strict;
    
    our @ISA = qw(Person);    # inherits from Person
    
    
    
    #constructor
    
    sub new {
    
        my ($class) = @_;
    
        #call the constructor of the parent class, Person.
    
        my $self = $class->SUPER::new();
    
        $self->{_id}   = undef;
    
        $self->{_title} = undef;
    
        bless $self, $class;
    
        return $self;
    
    }
    
    
    
    #accessor method for  id
    
    sub id {
    
        my ( $self, $id ) = @_;
    
        $self->{_id} = $id if defined($id);
    
        return ( $self->{_id} );
    
    }
    
    
    
    #accessor method for  title
    
    sub title {
    
        my ( $self, $title ) = @_;
    
        $self->{_title} = $title if defined($title);
    
        return ( $self->{_title} );
    
    }
    
    
    
    sub print {
    
        my ($self) = @_;
    
    
    
        # we will call the print method of the parent class
    
        $self->SUPER::print;
    
        $self->address->print;
    
    }
    
    
    
    1;
    
    

    Looking at the code, you will notice that we have a new

    method and a print method. Both the child class and its

    parent class have the same method defined. We have

    overridden the parent class’ methods with the ones from

    the child. When those methods are called on an Employee

    object, we will get the Employee class’ version of the

    method. This concept of using the methods of an existing

    object and modifying them is known as polymorphism.

    Putting it together

    So now that we have a complete set of classes, we can

    write a small program to test them.

    
    use strict;
    
    use warnings;
    
    use diagnostics;
    
    use Employee;
    
    
    
    #create Employee class instance
    
    my $mike =  eval { new Employee(); }  or die ($@);
    
     
    
    #set object attributes
    
    $mike->firstName('mike');
    
    $mike->lastName('Weis');
    
    $mike->id(0731034);
    
    $mike->title('Perl Programmer');
    
    $mike->address( new Address() );
    
    $mike->address->street('30 Hudson court');
    
    $mike->address->city('Jersey City');
    
    $mike->address->state('NJ');
    
    $mike->address->zip('665030');
    
    
    
    #diplay Employee info
    
    $mike->print();
    
    

    Let’s execute our code and see the output:

    $ ./test.pl

    Name:mike Weis

    Address:30 Hudson court

    Jersey City, NJ 665030

  • Perl File Operations

    Perl File operations

    Variables which represent files are called “file handles”, and they are handled differently from other variables. They do not begin with any special character — they are just plain words. By convention, file handle variables are written in all upper case, like FILE_OUT or SOCK. The file handles are all in a global namespace, so you cannot allocate them locally like other variables. File handles can be passed from one routine to another like strings (detailed below).

    The standard file handles STDIN, STDOUT, and STDERR are automatically opened before the program runs. Surrounding a file handle with <> is an expression that returns one line from the file including the “n” character, so returns one line from standard input. The <> operator returns undef when there is no more input. The “chop” operator removes the last character from a string, so it can be used just after an input operation to remove the trailing “n”. The “chomp” operator is similar, but only removes the character if it is the end-of-line character.

    
    $line = ; ## read one line from the STDIN file handle 
    
    chomp($line); ## remove the trailing "n" if present 
    
    

    File Open and Close

    The “open” and “close” operators operate as in C to connect a file handle to a filename in the file system.

    
    open(F1, "filename"); ## open "filename" for reading as file handle F1 
    
    open(F2, ">filename"); ## open "filename" for writing as file handle F2 
    
    open(F3, ">>appendtome") ## open "appendtome" for appending 
    
    close(F1); ## close a file handle 
    
    

    Open can also be used to establish a reading or writing connection to a separate process launched by the OS. This works best on Unix.

    
    open(F4, "ls -l |"); ## open a pipe to read from an ls process 
    
    open(F5, "| mail $addr"); ## open a pipe to write to a mail process 
    
    

    Passing commands to the shell to launch an OS process in this way can be very convenient, but it’s also a famous source of security problems in CGI programs. When writing a CGI, do not pass a string from the client side as a filename in a call to open().

    Open returns undef on failure, so the following phrase is often to exit if a file can’t be opened. The die operator prints an error message and terminates the program.

    
    open(FILE, $fname) || die "Could not open $fnamen"; 
    
    

    In this example, the logical-or operator || essentially builds an if statement, since it only evaluates the second expression if the first if false. This construct is a little strange, but it is a common code pattern for Perl error handling.

    Input Variants

    In a scalar context the input operator reads one line at a time. In an array context, the input operator reads the entire file into memory as an array of its lines… @a = ; ## read the whole file in as an array of lines

    This syntax can be dangerous. The following statement looks like it reads just a single line, but actually the left hand side is an array context, so it reads the whole file and then discards all but the first line….

    my($line) = ;

    The behavior of also depends on the special global variable $/ which is the current the end-of-line marker (usually “n”). Setting $/ to undef causes to read the whole file into a single string.

    
    $/ = undef; 
    
    $all = ; ## read the whole file into one string 
    
    

    You can remember that $/ is the end-of-line marker because “/” is used to designate separate lines of poetry. I thought this mnemonic was silly when I first saw it, but sure enough, I now remember that $/ is the end-of-line marker.

    Print Output

    Print takes a series of things to print separated by commas. By default, print writes to the STDOUT file handle.

    
    print "Woo Hoon"; ## print a string to STDOUT 
    
    
    
    $num = 42; 
    
    $str = " Hoo"; 
    
    print "Woo", $a, " bbb $num", "n"; ## print several things 
    
    

    An optional first argument to print can specify the destination file handle. There is no comma after the file handle, but I always forget to omit it.

    
    print FILE "Here", " there", " everywhere!", "n";  
    
    

    File Processing Example

    As an example, here’s some code that opens each of the files listed in the @ARGV array, and reads in and prints out their contents to standard output…

    
    #!/usr/bin/perl -w 
    
    require 5.004; 
    
    ## Open each command line file and print its contents to standard out 
    
    
    
    foreach $fname (@ARGV) { 
    
    open(FILE, $fname) || die("Could not open $fnamen"); 
    
    while($line = ) { 
    
    print $line; 
    
    } 
    
    close(FILE); 
    
    } 
    
    

    The above uses “die” to abort the program if one of the files cannot be opened. We could use a more flexible strategy where we print an error message for that file but continue to try to process the other files. Alternately we could use the function call exit(-1) to exit the program with an error code. Also, the following shift pattern is a common alternative way to iterate through an array…

    while($fname = shift(@ARGV)) {...

    /pre>

    Perl Regular Expressions

    Perl Regular Expressions

    
    
    
    Metacharacters
    char meaning
    ^ beginning of string $ end of string . any character except newline * match 0 or more times + match 1 or more times ? match 0 or 1 times; or: shortest match | alternative ( ) grouping; "storing" [ ] set of characters { } repetition modifier \ quote or special
    
    Repetition
    
    a*     zero or more a's 
    
    a+     one or more a's 
    
    a?     zero or one a's (i.e., optional a) 
    
    a{m}   exactly m a's 
    
    a{m,}  at least m a's 
    
    a{m,n} at least m but at most n a's repetition?
    
    
    
     
    
    \t     tab 
    
    \n     newline 
    
    \r     return (CR) 
    
    \xhh   character with hex. code hh 
    
    \b     "word" boundary 
    
    \B     not a "word" boundary 
    
    
    
    
    
    \w     matches any single character classified as a 
    
           "word" character (alphanumeric or _) 
    
    \W     matches any non-"word" character 
    
    \s     matches any whitespace character (space, tab, newline) 
    
    \S     matches any non-whitespace character  
    
    \d     matches any digit character, equiv. to [0-9] 
    
    \D     matches any non-digit character 
    
    
    
    
    
    [characters] matches any of the characters in the sequence  
    
    [x-y]        matches any of the characters from x to y 
    
                 (inclusively) in the ASCII code  
    
    [\-]         matches the hyphen character - 
    
    [\n]         matches the newline; other single character 
    
                 denotations with  apply normally, too  
    
     
    
    
    
    

    Examples

    How do I extract everything between a the words “start” and “end”?

    $mystring = “The start text always precedes the end of the end text.”;

    if($mystring =~ m/start(.*)end/) {

    print $1;

    }

    How do I extract a complete number, like the year?

    $mystring = “[2004/04/13] The date of this article.”;

    if($mystring =~ m/(d+)/) {

    print “The first number is $1.”;

    }

    # find word that is bolded

    # returns: $1 = ‘text’

    $line = “This is some text with HTML and “;

    $line =~ m/(.*)/i;

    Perl Subroutine

    Perl Subroutine

    
    sub mysubroutine
    
    {
    
    	print "Not a very interesting routine\n";
    
    	print "This does the same thing every time\n";
    
    }
    
    

    regardless of any parameters that we may want to pass to it. All of the following will work to call this subroutine. Notice that a subroutine is called with an & character in front of the name:

    
    &mysubroutine;		# Call the subroutine
    
    &mysubroutine($_);	# Call it with a parameter
    
    &mysubroutine(1+2, $_);	# Call it with two parameters
    
    

    Parameters

    In the above case the parameters are acceptable but ignored. When the subroutine is called any parameters are passed as a list in the special @_ list array variable. This variable has absolutely nothing to do with the $_ scalar variable. The following subroutine merely prints out the list that it was called with. It is followed by a couple of examples of its use.

    
    sub printargs
    
    {
    
    	print "@_n";
    
    }
    
    
    
    &printargs("perly", "king");	# Example prints "perly king"
    
    &printargs("frog", "and", "toad"); # Prints "frog and toad"
    
    

    Just like any other list array the individual elements of @_ can be accessed with the square bracket notation:

    
    sub printfirsttwo
    
    {
    
    	print "Your first argument was $_[0]n";
    
    	print "and $_[1] was your secondn";
    
    }
    
    

    Again it should be stressed that the indexed scalars $_[0] and $_[1] and so on have nothing to with the scalar $_ which can also be used without fear of a clash.

    Returning values

    Result of a subroutine is always the last thing evaluated. This subroutine returns the maximum of two input parameters. An example of its use follows.

    
    sub maximum
    
    {
    
    	if ($_[0] > $_[1])
    
    	{
    
    		$_[0];
    
    	}
    
    	else
    
    	{
    
    		$_[1];
    
    	}
    
    }
    
    
    
    $biggest = &maximum(37, 24);	# Now $biggest is 37
    
    

    The &printfirsttwo subroutine above also returns a value, in this case 1. This is because the last thing that subroutine did was a print statement and the result of a successful print statement is always 1.

    Local variables

    The @_ variable is local to the current subroutine, and so of course are $_[0], $_[1], $_[2], and so on. Other variables can be made local too, and this is useful if we want to start altering the input parameters. The following subroutine tests to see if one string is inside another, spaces not withstanding. An example follows.

    
    sub inside
    
    {
    
    	local($a, $b);                  # Make local variables
    
    	($a, $b) = ($_[0], $_[1]);      # Assign values
    
    	$a =~ s/ //g;                   # Strip spaces from
    
    	$b =~ s/ //g;                   # local variables
    
    	($a =~ /$b/ || $b =~ /$a/);     # Is $b inside $a
    
    					# or $a inside $b?
    
    }
    
    
    
    &inside("lemon", "dole money");		# true
    
    

    In fact, it can even be tidied up by replacing the first two lines with

    local($a, $b) = ($_[0], $_[1]);

    Perl References

    Perl References

    I’m happiest writing Perl code that does not use references because they always give me a mild headache. Here’s the short version of how they work. The backslash operator () computes a reference to something. The reference is a scalar that points to the original thing. The ‘$’ dereferences to access the original thing. Suppose there is a string…

    $str = “hello”; ## original string

    And there is a reference that points to that string…

    $ref = $str; ## compute $ref that points to $str

    The expression to access $str is $$ref. Essentially, the alphabetic part of the variable, ‘str’, is replaced with the dereference expression ‘$ref’…

    print “$$refn”; ## prints “hello” — identical to “$strn”;

    Here’s an example of the same principle with a reference to an array…

    @a = (1, 2, 3); ## original array

    $aRef = @a; ## reference to the array

    print “a: @an”; ## prints “a: 1 2 3″

    print “a: @$aRefn”; ## exactly the same

    Curly braces { } can be added in code and in strings to help clarify the stack of @, $, …

    print “a: @{$aRef}n”; ## use { } for clarity

    Here’s how you put references to arrays in another array to make it look two dimensional…

    @a = (1, 2, 3); @b = (4, 5, 6);

    @root = (@a, @b);

    print “a: @an”; ## a: (1 2 3)

    print “a: @{$root[0]}n”; ## a: (1 2 3)

    print “b: @{$root[1]}n”; ## b: (4 5 6)

    scalar(@root) ## root len == 2

    scalar(@{$root[0]}) ## a len: == 3

    For arrays of arrays, the [ ] operations can stack together so the syntax is more C like…

    $root[1][0] ## this is 4

    Perl if else

    The if…else Statement

    This statement uses a relational expression to check the validity of a condition and execute a set of statements enclosed in braces. It returns a Boolean value, true or false, according to the validity of the condition. The syntax of the if…else statement is:

    
    if(condition)
    
    {
    
    	block of statement(s);
    
    }
    
    else
    
    {
    
    	block of statement(s);
    
    }
    
    

    In this syntax, condition is a relational expression. If the result of this expression is true, then the block of statements following the if statement is executed. Otherwise, the block of statements following the else statement is executed.

    In Perl, unlike other languages, all loops and conditional constructs require statements to be enclosed in braces, even for single statements.

    
    #! /usr/bin/perl
    
    print "Enter a value for a: ";
    
    $a = <>;
    
    print "Enter a value for b: ";
    
    $b  = <>;
    
    if ($a>$b)
    
    {
    
       print "a is greater than b\n";
    
    }
    
    else
    
    {
    
       print "b is greater than a\n";
    
    }
    
    

    In this example, the if clause checks whether $a is greater than $b. If the value of $a is greater than $b, then the result is: a is greater than b. Otherwise, the control transfers to the code following the else clause and the statement associated with the else clause is printed as a result.

    The if…elsif…else Statement

    This statement is used when there is more than one condition to be checked. The syntax of the if…elsif…else statement is:

    
    if (condition)
    
    {
    
    	block of statement(s);
    
    }
    
    elsif (condition)
    
    {
    
    	block of statement(s);
    
    }
    
    else
    
    {
    
    	block of statement(s);
    
    }
    
    

    In this syntax, if the condition associated with the if clause is false, the control transfers to elsif clause that checks for the next condition. The code associated with elsif clause is executed only if the condition is true or the code associated with the else clause is executed.

    
    #! /usr/bin/perl
    
    print "Enter the score of a student: ";
    
    $score = <>;
    
    if($score>=90)
    
    {
    
      print "Excellent Performance\n";
    
    }
    
    elsif($score>=70 && $score<90)
    
    {
    
      print "Good Performance\n";
    
    }
    
    else
    
    {
    
      print "Try hard\n";
    
    }