PERL TIPS

Arrays of Arrays

noreply@blogger.com (SHEELA) — Tue, 25 Sep 2007 05:26:00 +0000

How do we preserve the data as three unique arrays? An array can only contain scalars. Luckily we know that a reference is a scalar. Let's create an array of array references!
# we have separate arrays we want to combine
my @austin_toys = qw(perl pizzastone pilobolus);
my @justin_toys = ('hack saw', 'boots', 'grout');
my @reinhard_toys = ('OED', 'oatmeal', 'orange juice');

# we could do this: (an array of array refs)
my @toys = ( \@austin_toys, \@justin_toys, \@reinhard_toys );
print "Reinhard's 1st toy is a $toys[2]->[0]\n";
print "Reinhard's 1st toy is a $toys[2][0]\n";

# or this: (an array ref of array refs)
my $toys = [ \@austin_toys, \@justin_toys, \@reinhard_toys ];
print "Reinhard's 1st toy is a $toys->[2][0]\n";

Occurence of each value in a list.

noreply@blogger.com (SHEELA) — Wed, 19 Sep 2007 09:55:00 +0000

Usual approach is
@list=(1,2,3,4,5,4,3,2,1,2,3,4,5,4,3,2,1);
for (@list) {
$count++ if $_ eq "3";
}
We can smarten this by using grep function.
$count = grep $_ eq "3", @list;
But when we need the number of 4 or 5, we must repeat the above again.
This can be made easy by hash in a single line as,
my %count;
$count{$_}++ for @list;
foreach $key (keys %count){
print $key."\t".$count{$key}."\n";
}

Regex - Replacement Count

noreply@blogger.com (SHEELA) — Tue, 18 Sep 2007 07:30:00 +0000

When you bind a variable to a substitution, the expression as a whole will return the number of substitutions made, e.g. ,
$replacements =$myvar =~s/foo/bar/g;
$replacements will give you the total count of replacements.

Fast Way..

noreply@blogger.com (SHEELA) — Tue, 18 Sep 2007 07:21:00 +0000

Need a fast way of getting rid of the second half of an array?
Simply divide $#array by two, where array is the name of the @array.
$#array /= 2;

Shortcuts with the Arrow Notation

noreply@blogger.com (SHEELA) — Tue, 11 Sep 2007 07:19:00 +0000

Perl provides an alternate and easier-to-read syntax for accessing array or hash elements: the ->[ ] notation. For example, given the array's reference, you can obtain the second element of the array like this:
$rarray = \@array;
print $rarray->[1] ; # The "visually clean" way
instead of the approaches we have seen earlier:
print $$rarray[1]; # Noisy
#or
print ${$rarray}[1];

Similarly, you can use the ->{ } notation to access an element of a hash table:
$rhash = \%hash;
print $rhash->{"k1"};
#instead of ........
print $$rhash{"k1"};
# or
print ${$rhash}{"k1"};

10 Perl modules for JAVA

noreply@blogger.com (SHEELA) — Thu, 06 Sep 2007 09:58:00 +0000

Java
This module provides a framework to start a local, or connect to a remote, Java Virtual Machine (JVM). It includes support for VM localization, object creation, method invocation, event listeners and loops, and exceptions.
Use this module when you need to connect to a local or remote JVM through Perl.

Inline::Java
This module is one of the most useful for Java developers switching over to Perl, because it allows them to embed Java code as-is into a Perl script. This code is then automatically compiled and invoked as needed by the Perl interpreter. The module includes support for environment variables, type casting, shared JVMs, arrays, objects and exceptions.
Use this module when you need to embed Java code directly in a Perl script.

Java::Import
This module makes it easy to import and access Java classes from Perl. It includes the ability to call static methods, pass arguments and process return values, work with Java-based data structures, and handle exceptions.
Use this module when you need to access a Java class from a Perl script.

Java::Build
This module provides an alternative to Ant, the traditional Java build tool. It combines Perl's scripting abilities with the standard Java build/package toolset.
Use this module when you require greater control over the build/package process for a Java class.

Java::Swing
The Swing toolkit provides sophisticated GUI controls (toolbars, buttons, and selectors) for Java applications. This module provides an object-based interface to core Swing API calls, and includes support for extended components, listeners and other wrappers.
Use this module when you need to access Java Swing functions through Perl.

JDBC
This module provides an interface to various database systems using JDBC. It includes support for database connections, query execution and result set retrieval, prepared statements and error handling.
Use this module when you need to connect to an RDBMS through a JDBC "pipe", perhaps to make use of a custom JDBC driver class.

Java::SJ
This module provides a framework to customize Java VM configuration, making it possible to run multiple VMs, each with a different startup configuration and service profile. Configurations are expressed in XML.
Use this module when you need to run multiple Java VMs simultaneously on the same system.

Java::JVM::Classfile
This module reads and parses JVM classfiles and expresses the information within them as a series of objects. Various methods are available to retrieve specific information about class methods, properties and visibility.
Use this module to retrieve detailed information about the objects and classes defined in a JVM classfile.

Template::Plugin::Java
This module provides a framework for describing Java classes in XML and then transforming these XML descriptions into Java source code. The XML description may include descriptions of variables and methods, and includes support for type casting and arrays. Two operation modes are supported: command-line, and embedded within a template.
Use this module when you need to create class templates in a standard, easily-parseable format, perhaps for use on different platforms.

Java::JCR::Jackrabbit
This module makes it possible to connect to, and manipulate, a Jackrabbit (JCR) content repository through Perl. It includes support for custom nodes.
Use this module when you need to access a Jackrabbit content repository.

Optimize for speed

noreply@blogger.com (SHEELA) — Wed, 29 Aug 2007 12:54:00 +0000

Perl comes with a very handy module to help you evaluate the relative speed of different code snippets.

The Benchmark module comes with a function that will take a hash of code snippets and a number. The module will run each code snippet that many times and report the speed of each for you to compare.

use Benchmark;
$string = "The bitter end.\n";
$code{chomp} = 'chomp $string';
$code{regex} = '$string =~ s/\n$//';
timethese(10_000_000, \%code);

Devel::DProf

noreply@blogger.com (SHEELA) — Wed, 29 Aug 2007 06:53:00 +0000

The Devel::DProf package is a Perl code profiler. This will collect information on the execution time of a Perl script and of the subs in that script. This information can be used to determine which subroutines are using the most time and which subroutines are being called most often. This information can also be used to create an execution graph of the script, showing subroutine relationships.

So to profile script test.pl the following command should be used:

perl -d:DProf test.pl

When the script terminates (or when the output buffer is filled) the profiler will dump the profile information to a file called tmon.out.

A tool like dprofpp can be used to interpret the information which is in that profile.
dprofpp

To print an execution graph of the subroutines in the script use the following command:
dprofpp -T

Smart::Comments

noreply@blogger.com (SHEELA) — Tue, 28 Aug 2007 11:05:00 +0000

Smart comments provide an easy way to insert debugging and tracking code into a program. They can report the value of a variable, track the progress of a loop, and verify that particular assertions are true.

All smart comments start with three (or more) # characters. That is, they are regular #-introduced comments whose first two (or more) characters are also #'s.

use Smart::Comments;
### [] Acquiring data...
for $i (0 .. 100) { ### Processing ==[%]
think_about($i);
}
sub think_about {
sleep 1; # deep ponder
}

the above program would print a cool animated progress bar.

B::Fathom

noreply@blogger.com (SHEELA) — Tue, 28 Aug 2007 10:58:00 +0000

A module to evaluate the readability of Perl code.

perl -MO=Fathom ScriptName

B::Fathom is a backend to the Perl compiler; it analyzes the syntax of your Perl code, and estimates the readability of your program.

Perl-Tidy

noreply@blogger.com (SHEELA) — Tue, 28 Aug 2007 07:06:00 +0000

Perltidy is a tool to indent and reformat perl scripts. It can also write scripts in html format.

Try it in your command prompt as:

perltidy perlprgname.pl

For safety, perltidy never overwrites your original file. In this case, its output will go to a file named perlprgname.pl.tdy

Not only does it nicely format code, it does an excellent job of telling you where your syntax errors are.

Error report will be in

perlprgname.pl.ERR

If you want the Perl as html just type in:

perltidy -html perlprgname.pl

Use Perl to create PDF

noreply@blogger.com (SHEELA) — Tue, 28 Aug 2007 07:00:00 +0000

The PDF::API2 package is used widely to create and manipulate PDF.

CODE:
use PDF::API2;
my $pdf = PDF::API2->new(-file => "HelloWorld.pdf");
$pdf->mediabox(595,842);
my $page = $pdf->page;
my $fnt = $pdf->corefont('Arial',-encoding => 'latin1');
my $txt = $page->text;
$txt->textstart;$txt->font($fnt, 20);
$txt->translate(100,800);
$txt->text("Hello Sheela! left-aligned");
$txt->translate(500,750);
$txt->text_right("Hello Sheela! right-aligned");
$txt->translate(300,700);$txt->text_center("Hello Sheela! center-aligned");
$txt->textend;$pdf->save;$pdf->end();