Perl - Tidings

The caller() function and $wantarray

2011-09-18T23:47:00.001-07:00

The argument of interest is the $wantarray argument. This indicates what return value is

expected of the subroutine from where it was called. The subroutine could have been

called in void context meaning the return value is thrown away. Or it could have been

called and the return value assigned to a scalar. Or it could have been called and the

return value assigned to a list of scalars.

sub CheckMyWantArray

{

my @info = caller(0);

my $wantarray = $info[5];

$wantarray='undef'

unless(defined($wantarray));

print "wantarray is '$wantarray'\n";

}

CheckMyWantArray; # undef

my $scal = CheckMyWantArray; # 0

my @arr = CheckMyWantArray; # 1

> wantarray is 'undef'

> wantarray is '0'

> wantarray is '1'

Using the caller() Function in Subroutines

2011-09-18T23:43:00.000-07:00

The caller() function can be used in a subroutine to find out information about where the

subroutine was called from and how it was called. Caller takes one argument that

indicates how far back in the call stack to get its information from. For information about

the current subroutine, use caller(0).

sub HowWasICalled {

my @info = caller(0);

print Dumper \@info;

}

HowWasICalled;

>$VAR1 = [

> 'main',

> './test.pl',

> 13,

> 'main::HowWasICalled',

> 1,

> undef,

> 2,

> 'UUUUUUUUUUUU'

> ];

The caller() function returns a list of information in the following order

0 $package package namespace at time of call

1 $filename filename where called occurred

2 $line line number in file where call occurred

3 $subroutine name of subroutine called

4 $hasargs true if explicit arguments passed in

5 $wantarray list=1, scalar=0, void=undef

6 $evaltext evaluated text if an eval block

7 $is_require true if created by "require" or "use"

8 $hints internal use only, disregard

9 $bitmask internal use only, disregard

Implied Arguments in perl

2011-09-18T23:40:00.000-07:00

When calling a subroutine with the "&" sigil prefix and no parenthesis, the current @_

array gets implicitely passed to the subroutine being called. This can cause subtly odd

behaviour if you are not expecting it.

sub second_level {

print Dumper \@_;

}

sub first_level {

# using '&' sigil and no parens.

# doesn't look like I'm passing any params

# but perl will pass @_ implicitely.

&second_level;

}

first_level(1,2,3);

> $VAR1 = [

> 1,

> 2,

> 3

> ];

what is it meants by '$_'?

2011-09-14T21:15:00.000-07:00

It is a default variable which holds automatically, a list of arguements passed to the subroutine within parentheses.

Difference between 'my' and 'local' variable scope declarations

2011-09-14T21:11:00.000-07:00

Both of them are used to declare local variables. The variables declared with 'my' can live only within the block and cannot gets its visibility inherited functions called within that block, but one defined as 'local' can live within the block and have its visibility in the functions called within that block.

what is meant by a 'pack' in perl?

2011-09-14T21:09:00.000-07:00

Pack Converts a list into a binary representation. Takes an array or list of values and packs it into a binary structure, returning the string containing the structure It takes a LIST of values and converts it into a string. The string contains a concatenation of the converted values. Typically, each converted values looks like its machine-level representation. for example, on 32-bit machines a converted integer may be represented by a sequence of 4 bytes.

How to substitute a particular string in a file containing million of record?

2011-09-14T21:05:00.000-07:00

perl -p -ibak -e 's/search_str/replace_str/g'

how do you check the return code of system call?

2011-09-14T21:03:00.000-07:00

System calls "traditionally" returns 9 when successful and 1 when it fails.

system (cmd) or die "Error in command";

What is '->' in Perl?

2011-09-14T20:58:00.000-07:00

It is a symbolic link to link one file name to a new name. so lets say we do it like

file1-> file2, if we read file1, we end up reading file2.

Difference between 'chomp' and 'chop'?

2011-09-14T20:53:00.000-07:00

'chop' functiononly removes the last character completely 'from the scaler, where as 'chomp' function only removes the last character if it is a newline. by default,

chomp only removes what is currently defined as the $INPUT_RECORD_SEPARATOR.

whenever you call 'chomp ', it checks the value of a special variable '$/'. whatever the value of '$/' is eliminated from the scaler. by default the value of '$/' is '\n'

Diffrence between 'use' and 'require' function?

2011-09-14T20:51:00.000-07:00

Use:

1. the method is used only for modules (only to include .pm type file)

2. the included object are verified at the time of compilation.

3. No Need to give file extentsion.

Require:

1. The method is used for both libraries ( package ) and modules

2. The include objects are varified at the run time.

3. Need to give file Extension.

How do you know the reference of a variable whether it is a reference,scaller, hash or array?

2011-09-14T20:42:00.000-07:00

Answer : There is a 'ref' function .

Perl provides the ref() function so that you can check the reference type before dereferencing a reference

The ref() function can return are:

Function Call	Return Value
ref( 10 );	undefined
ref( `\`10);	SCALAR
ref( `\{1 => ; "Joe"}` );	HASH
ref(`\`&firstSub );	CODE
ref( `\\`10);	REF

Meaning of i and g in Oracle 9i & 10g

2011-09-14T20:27:00.000-07:00

The i in oracle 8i and 9i stands for INTERNET and the g in 10g and 11g stands for GRID

bcz from 10g onwards oracle supports grid architecture.

The "i" and "g" Versions Starting in 1999 with Version 8i, Oracle added the "i" to the version name to reflect support for the Internet with its built-in Java Virtual Machine (JVM). Oracle 9i added more support for XML in 2001. In 2003, Oracle 10g was introduced with emphasis on the "g" for grid computing, which enables clusters of low-cost, industry standard servers to be treated as a single unit.

Why should I use the -w argument with my Perl programs?

2010-09-19T21:17:00.000-07:00

Many Perl developers use the -w option of the interpreter, especially during the development stages of an application.

This warning option turns on many warning messages that can help you understand and debug your applications.

To use this option on Unix systems, just include it on the first line of the program, like this:
#!/usr/bin/perl -w

If you develop Perl apps on a DOS/Windows computer, and you're creating a program named myApp.pl, you can turn on the warning messages when you run your program like this:

perl -w myApp.pl

Env

2010-08-11T23:32:00.000-07:00

Perl provides access to environment variables via the global "%ENV" hash. However, if using the ENV module, it will create global scalars for all the environment variables.

use Env;
print "$USER uses $SHELL";

If required to get only a few selected variables then it can be done like:

use Env qw[@PATH $USER];
print "$USER's  path is @PATH";

FindBin

2010-08-11T23:30:00.000-07:00

Its usage is like:

 use FindBin;
 use lib "$FindBin::Bin/../lib";

or

use FindBin qw($Bin);
use lib "$Bin/../lib";

Using hash for counting

2010-08-11T23:17:00.000-07:00

When we have an array or a list of items and we want to find out the number of occurrences of a particular item then we generally use the following kind of logic:

 my $count = 0;
 for (@list) {
     $count++ if $_ eq "apple";
 }

This can be made better by using the grep function like:

    $count = grep $_ eq "apple", @list;

Here we use the list returned by grep in a scalar context here by getting the number of elements in the grep -ed list.However if we have to find the count for more than one element in the list, then by this approach we need to make repetitive sentences like:

    $count_apples = grep $_ eq "apple", @list;
    $count_pears  = grep $_ eq "pear",  @list;

A better method will be something like:

    my %histogram;
    $histogram{$_}++ for @list;

This hash has a count of each individual item in the list and it also traverses the list only once.Moreover, to find number of unique elements in the list,all we have to do is:

    $unique = keys %histogram;

In order to find the five most popular items in the list we can do something like:

    @popular = (sort { $histogram{$b} <=> $histogram{$a} } keys %histogram)[0..4];

This sorts the unique elements of the list ie the keys of hash, in a descending order and pulls out only the top five.

Copying and Substituting Simultaneously

2010-08-11T23:13:00.000-07:00

When the purpose is to search and replace a copy of the string and the intention is to accomplish this in one step then instead of doing this:

$dst = $src;
$dst =~ s/this/that/;

a single step like this will be more concise:

($dst = $src) =~ s/this/that/;

WebAPP

2010-08-11T22:09:00.000-07:00

WebAPP is a popular, open source Content Management System (cms) written in the Perl programming language. The name WebAPP is an abbreviation of Web Automated Perl Portal. Available under the GNU General Public License, WebAPP is free software. Features Enhanced crypt, Articles, Forums and nested message boards, Private Instant Messaging system (IM), Who is Online, Profile info, Memberlist, sortable with links to IM, Profile and Email Download and Link sections, Stats with advanced sorting options, Webabsed Site Administration control panel, About, Contact and Help pages, Custom Welcome messages for guests and registered members. Languages The WebAPP script is available in these languages Afrikaans, Albanian, Bosnian, Brazilian Portuguese, Bulgarian, Catalan, Chinese (Simplified), Chinese (Traditional), Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hebrew, Hungarian, Italian, Japanese, Ladino, Lithuanian, Polish, Portuguese, Russian, Slovenian, Somali, Spanish, Thai, Swedish, Vietnamese and Yiddish.

WebAPP is the most fully-featured, versatile, free and open-source, flat-file Perl portal script available today! Acronym for Web Automated Perl Portal ™, WebAPP is easily installed on virtually any UNIX-based server. WebAPP requires no SQL backend, no PHP, only a hosting environment offering support for Perl.
Featuring the most complete (and growing) set of interactive community-building resources available, even an inexperienced webmaster can easily install WebAPP, login and personalize their portal, populate it with their content, and easily maintain, develop and administer the site.

Refer More http://www.web-app.net/

difference between soft link and hard link

2010-03-04T23:49:00.001-08:00

Hard Links :

1. All Links have same inode number.

2.ls -l command shows all the links with the link column(Second) shows No. of links.

3. Links have actual file contents

4.Removing any link just reduces the link count but doesn't affect other links.

Soft Links(Symbolic Links) :

1.Links have different inode numbers.

2. ls -l command shows all links with second column value 1 and the link points to original file.

3. Link has the path for original file and not the contents.

4.Removing soft link doesn't affect anything but removing original file the link becomes dangling link which points to nonexistant file.

Changing your default UNIX file permissions

2010-02-09T01:40:00.000-08:00

To change the default permissions assigned to your UNIX files and directories, use the umask command. umask is a little confusing at first. Its format is

umask nnn

where nnn is a three-digit code that defines the new default permissions. The umask string does not have the same format as the the chmod permission string.

Each of the three numbers represents one of the categories user, group, and other. The value for a category is calculated as follows:

read permission has a value of 4
write permission has a value of 2
execute permission has a value of 1

Sum the permissions you want to set
for the category, then subtract that
value from 7.

As an example, examine the current default umask statement that is used to assign the file protections -rwx-r-x--- :

umask 027

The user category value is 0 because r+w+x = 4+2+1 = 7. When this is subtracted from 7, the value is 0.

The group category value is 2 because r+x = 4+1 = 5. When this is subtracted from 7, the value is 2.

The other category value is 7 because no permissions = 0. When this is subtracted from 7, the value is 7.

Printing Environment Variables Using Perl One Liner

2009-07-08T06:20:00.001-07:00

Solution 1

C:\Documents and Settings\sivkumar>perl

use Data::Dumper;
print Dumper \%ENV;

Solution 2 - Perl One Liner

perl -MData::Dumper -e "print Dumper \%ENV"

Tilde-Tilde Operator

2009-07-06T23:19:00.000-07:00

A bit obscure is the tilde-tilde "operator" which forces scalar context.

print ~~ localtime;

is the same as

print scalar localtime;

and different from

print localtime;

Spaceship Operator.

2009-07-06T23:09:00.000-07:00

Easy with the Spaceship Operator.

$a = 2 <=> 5;  # $a is set to -1
$a = 5 <=> 2;  # $a is set to 1
$a = 2 <=> 2;  # $a is set to 0

Non-Obvious features in perl.

2009-07-06T22:56:00.000-07:00

For example, did you know that there can be a space after a sigil?

 $ perl -wle 'my $x = 3; print $ x'
3

Or that there you can give subs numeric names if you use symbolic references?

$ perl -lwe '*4 = sub { print "yes" }; 4->()' 
yes

There's also the "bool" quasi operator, that return 1 for true expressions and the empty string for false:

$ perl -wle 'print !!4'
1
$ perl -wle 'print !!"0 but true"'
1
$ perl -wle 'print !!0'
(empty line)

Other interesting stuff: with use overload you can overload string literals and numbers (and for example make them BigInts or whatever).

Many of these thins are actually documented somewhere, or follow logically from the documented features, but nonetheless some are not very well known.

Update: Another nice one. Below the q{...} quoting constructs were mentioned, but did you know that you can use letters as delimiters?

$ perl -Mstrict  -wle 'print q bJet another perl hacker.b'
Jet another perl hacker.

Likewise you can write regexes

m xabcx
# same as m/abc/

Error : Can't do inplace edit without backup

2009-03-24T21:52:00.000-07:00

I am writing a command line perl program to replace text content in a file .I know that the following instruction executes successfully on one of the unix machine. I am trying to execute it through cygwin.

perl -pi -e 's/siva/prabu/g;' TestScript.xml

But I get following error.
Can't do inplace edit without backup.

I tried to run:
perl -pi 'Temp.bak' -e 's/siva/prabu/g;' TestScript.xml

It gives me
Can't open -e: No such file or directory.
Can't open s/siva/prabu/g;: No such file or directory.
Can't do inplace edit without backup.

Solution :

perl -pi.bak -e 's/siva/prabu/g;' TestScript.xml

or

perl -pi.bak -e "/siva/prabu/g;" TestScript.xml

Special Variables - @ARGV

2009-03-23T23:59:00.000-07:00

@ARGV


Short Name   :          @ARGV

Scope        :          always global

This variable is an array of the arguments passed to the script. he first element of this array is the first argument (not the program name). As the arguments are processed, the value of this variable can alter.

Example:

$TestString = "There were $#ARGV arguments first arguments @ARGV[0]\n";

print $TestString;

Perl Handles Numbers

2009-03-16T03:18:00.000-07:00

Perl can handle both whole numbers (integers, like 37) and floating-point numbers (real numbers with decimal points, like 17.5 or -235.2). Internally, Perl handles both as 'double precision floating-point values', but in Perl code they are treated the same way and can be used interchangeably. Here are some examples of number literals :

128 (positive integer)
-127 (negative integer)
0
17.5 (positive floating number)
-4.6E13 (negative 4.6 times 10 to the 13th power. E denotes exponential notation)

The last numeric literal above is an example of exponential or scientific notation, used when you need to work with very large or very small numbers.

In addition to decimal literals, Perl supports octal (base 8) and hexadecimal (base 16) literals.

Octal literals are denoted by a leading 0, and hex literals by a leading 0x or 0X.

For example:
0177 # 177 octal, same as 127 decimal
0xf0 # f0 hexadecimal, same as 240 decimal
- 0Xff # negative ff hexadecimal, same as -255 in decimal

Many people writing Perl programs will never need to work with octal or hex numbers - but be careful not to specify decimal numbers with a leading zero, because Perl will interpret them as octal.

Basic Naming Rules in Perl

2009-03-16T02:56:00.000-07:00

Variable names can start with a letter, a number, or an underscore, although they normally begin with a letter and can then be composed of any combination of letters, numbers, and the underscore character.
Variables can start with a number, but they must be entirely composed of that number; for example, $123 is valid, but $1var is not.
Variable names that start with anything other than a letter, digit, or underscore are generally reserved for special use by Perl
Variable names are case sensitive; $foo, $FOO, and $fOo are all separate variables as far as Perl is concerned.
As an unwritten (and therefore unenforced) rule, names all in uppercase are constants.
All scalar values start with $, including those accessed from an array of hash,for example $array[0] or $hash{key}.
All array values start with @, including arrays or hashes accessed in slices,for example @array[3..5,7,9] or @hash{‘bob’, ‘alice’}.
Namespaces are separate for each variable type—the variables $var, @var, and %var are all different variables in their own right.FUNDAMENTALS In situations where a variable name might get confused with other data (such as when embedded within a string), you can use braces to quote the name. For example, ${name}, or %{hash}.
Limited to 255 characters, however. We hope that suffices

Printing a Hash

2009-03-10T00:11:00.000-07:00

Solution 1 :

while ( ($key,$value) = each %hash ) {
 print "$k => $v\n";
}

Solution 2 :

print map { "$_ => $hash{$_}\n" } keys %hash;

Solution 3 :

print "@{[ %hash ]}\n";


Solution 4 : 
{
 my @temp = %hash;
 print "@temp";
}

Solution 5 :

foreach $key (sort keys %hash) {
 print "$key => $hash{$key}\n";
}

How to Take a Hash Slice

2009-03-09T03:44:00.000-07:00

Assign some variables of a hash to an array. i.e you want to take some of the elements from hash based on there keys into a array here is a trick

%hash = ( 1 => 'one', 2 => 'two',3 => 'three');
@array = @hash{'1','2'};

If you have a hashref and want to take the values of some keys into an array you can do the following.

$hashref = {1 => 'one', 2 => 'two', 3 => 'three'};
@array = @{%$hashref}{'1','2'};

Establishing a Default Value

2009-03-09T02:33:00.000-07:00

# use $b if $b is true, else $c
$a = $b || $c;              

# set $x to $y unless $x is already true
$x ||= $y

# use $b if $b is defined, else $c
$a = defined($b) ? $b : $c;

$foo = $bar || "DEFAULT VALUE";

$dir = shift(@ARGV) || "/tmp";

$dir = $ARGV[0] || "/tmp";

$dir = defined($ARGV[0]) ? shift(@ARGV) : "/tmp";

$dir = @ARGV ? $ARGV[0] : "/tmp";


# find the user name on Unix systems
$user = $ENV{USER}
  || $ENV{LOGNAME}
  || getlogin()
  || (getpwuid($<))[0]
  || "Unknown uid number $<";


@a = @b unless @a;    # copy only if empty
@a = @b ? @b : @c;    # assign @b if nonempty, else @c

Get Pathname Of Current Working Directory

2009-03-06T04:00:00.000-08:00

Windows :

use File::Spec;
my $current_directory = File::Spec->rel2abs(".");
print $current_directory;

Unix

use Cwd;
my $current_directory = getcwd;
print "$current_directory";

use Cwd;
$dir = cwd;

use Cwd;
$dir = fastgetcwd;

use Cwd 'abs_path';
print abs_path($ENV{'PWD'});

use Cwd 'fast_abs_path';
print fast_abs_path($ENV{'PWD'});

Ordered Hashes

2009-03-06T02:42:00.000-08:00

Perl hashes have no internal order. A hash consists of a number of "buckets''. When a record is inserted into the hash, the key is transformed, using a "hash function'', into a bucket number. The details of the hash function itself are not important, but a good hash function ensures that even very similar keys are mapped to different buckets. If too many keys map to the same bucket, then Perl has to spend a lot of time searching through that bucket for the corresponding value.

The important thing is not how Perl puts the key into the hash table but what the table gives us. To find if a value is in a hash, Perl takes the key name supplied, applies the same transformation and checks to see whether the key is in that position. This is much faster than searching through an ordered list.

However, while we often appreciate the speed in which hashes work, sometimes we want to maintain key order as well. A common solution is to create both our hash and an array. The array stores the keys in sorted order and we can then iterate through our has as required:

        my @idNumbers = qw(101 102 ... );
        
        my %nameMapping = ( 101 => 'Siva', 102 => 'Sakthi', ... );

        foreach my $Key ( @idNumbers ) {
                print "$Key : $nameMapping{$Key} \n";
        }

If @idNumbers and %nameMapping are created in one place in our program and then never changed (such as could be expected for a list of months of the year) then this is a very good solution. However if our hash is likely to grow over time then we can encounter problems. What happens if a key is added to one structure but not the other?

Fortunately there are better solutions.

Tie::InsertOrderHash

        use Tie::InsertOrderHash;

        tie my %nameMapping => 'Tie::InsertOrderHash',
             101   => 'Siva',
             102   => 'Sakthi',
             103   => 'Swetha',
             104   => 'Saran',
             105   => 'Darwin';

        print join(" ", keys %nameMapping), "\n";

        # prints: 101,102,103,104,105

In the above example, we're setting the hash at creation time. This is not required. We can add our values to our hash whenever we desire, just like a normal hash, further, our values can be any kind of value we can normally use in a hash.

Tie::IxHash

Tie::InsertOrderHash does not allow you to change values in your hash and keep the original ordering. Thus, as mentioned above, updating the keys in 102 will cause 102 to now appear after 105 when listing the keys.

If you want to be able to change values without changing the ordering then Tie::IxHash may be a better option.

        use Tie::IxHash;

        tie my %nameMapping => 'Tie::IxHash',
             101   => 'Siva',
             102   => 'Sakthi',
             103   => 'Swetha',
             104   => 'Saran',
             105   => 'Darwin';
   
     # Update Hash Value
     $nameMapping{102} = 'Kumar';

        print join(" ", keys %nameMapping), "\n";

        # prints: 101,102,103,104,105

There is also Tie::Hash::Indexed which provides less features than Tie::IxHash, but is considerably faster.

To get a similar behaviour to Tie::InsertOrderHash you can delete a key-value pair from your hash before providing the new value. Thus if we were to write:

delete($nameMapping{102} );

$nameMapping{102} = 'KumarS';

then June would be considered to have been inserted last.

How many ways can we express string in Perl

2009-03-05T00:04:00.000-08:00

Many.

For example

'this is a string' can be expressed in:
"this is a string"
qq/this is a string like double-quoted string/
qq^this is a string like double-quoted string^
q/this is a string/
q&this is a string&
q(this is a string)

TypeGlobes

2009-03-03T02:24:00.000-08:00

The typeglob is a composite data type that contains one instance of each other data types. It is an amalgam of all Perl’s data types, from which it gets its name. It is a sort of ‘super reference’ whose value is not a single reference to something but six slots that can contain six different references, all at once:

a.scalar – A reference to scalar
b.array – A reference to array
c.hash – A reference to hash
d.code – A reference to a subroutine
e.handle – A file or directory handle
f.format – A format definition

Defining Typeglobs:
$message = “Some text”;
*missive = *message;
print $missive; # prints “some text”;
or
*glob = \$scalar;
*glob = \@arr;
*glob = \%hash;
*glob = sub { return “\n Try this !” };

Manipulating Typeglobs:
print “\n $glob “;
print “\n @glob ”;
foreach $key (keys %glob)
{
print “\n $key => $glob{$key} “;
}
print glob();

Accessing Typeglobs:
$scalarref = *glob{SCALAR};
$arrayref = *glob{ARRAY};
$hashref = *glob{HASH};
$subref = *glob{CODE};

Use of pragma strict.

2009-02-18T22:41:00.000-08:00

Use the pragma strict tells the compiler to generate three types of errors

An error for any variables used before it was declared
An error if your code uses symbolic references
An error if your code uses bare words

How to turn on Perl warnings? Why is that important?

2009-02-18T22:39:00.000-08:00

Perl is very forgiving of strange and sometimes wrong code, which can mean hours spent searching for bugs and weird results.
Turning on warnings helps uncover common mistakes and strange places and save a lot of debugging time in the long run.
There are various ways of turning on Perl warnings:

For Perl one-liner, use -w option on the command line.
On Unix or Windows, use the -w option in the shebang line (The first # line in the script). Note: Windows Perl interpreter may not require it.
For other systems, choose compiler warnings, or check compiler documentation.

How to Run the Shell Script or External Unix or System Commands In Perl ?

2009-02-18T22:37:00.001-08:00

Exec
system
backquotes (``)
Using Pipe Symbol In open

What is stack concepts In Perl ?

2009-02-18T22:34:00.000-08:00

One of the most basic uses for an array is as stack

push | pop ==> LIFO

shift | unshift ==> FIFO

How do you find the length of an array?

2009-02-18T01:07:00.000-08:00

$#array

Scalar(@array)

$length = @array ;

What is difference between "Use" and "require"

2009-02-18T00:54:00.000-08:00

Use :

1. The method is used only for the modules(only to include .pm type file)

2. The included objects are varified at the time of compilation.

3. No Need to give file extension.

Use: only for modules, included objects are verified at the time of compilation

Require:

1. The method is used for both libraries and modules.

2. The included objects are verified at the run time.

3. Need to give file Extension.

Require : both library and modules, at the time run time

Essential Information In Perl

2009-02-18T00:42:00.000-08:00

Perl comes with documentation as standard, including a complete set of manual pages that can
be accessed with the perldoc program,

use the command line for view Perl Man Pages

[sivkumar@VersionTech sivkumar] perldoc perl
return a list of the (many) standard Perl manual pages available as part of every Perl installation

The perldoc command can also return information on specific Perl modules

[sivkumar@VersionTech sivkumar]perldoc CGI
[sivkumar@VersionTech sivkumar]perldoc DBI

Type perldoc perldoc for information on using perldoc itself, and perldoc -h for a brief summary of options.

Function in the perlfunc page

[sivkumar@VersionTech sivkumar] perldoc -f funcname
# look up a function in the perlfunc page

perldoc -f split
perldoc -f sort

Display source code file

[sivkumar@VersionTech sivkumar] perldoc -m module # display source code file

perldoc -m CGI
perldoc -m DBI

perlfaq documentation

[sivkumar@VersionTech sivkumar] perldoc -q pattern # search the perlfaq documentation

Insensitive lookup

[sivkumar@VersionTech sivkumar] perldoc -i [options] # do a case insensitive lookup or search

perldoc -i cgi

Unix To Dos

2009-02-18T00:37:00.000-08:00

#!/usr/bin/perl -pi
s/\n/\r\n/;

Dos To Unix

2009-02-18T00:30:00.000-08:00

perl -pi -e 's/\r\n/\n/;' Filename.pl

```
#!/usr/bin/perl -pi
s/\r\n/\n/;
```

UTF-8 Solution

2008-11-18T03:26:00.000-08:00

#!/usr/local/git/bin/perl 
# Test Char Set Issue 
# Tested By : Sivasakthi.kumar
# IM : Sivasakthikumar@gmail.com 
 

use DBI;
use DBD::Oracle qw(:ora_types);
use utf8;
use Encode;
 

$string = "FuÔbalÀl";
 

$ENV{NLS_LANG} = ".UTF8";
$ENV{NLS_NCHAR} = "AL32UTF8";
 

print "Before Insert DataBase :";
print "$string";
 

my $dbh;
 

$dbh = DBI->connect("DBI:Oracle:SID=tosipo;HOST="localhost";PORT=1521", 
                       teststage, 
                       SSaih, 
                       {RaiseError => 1,
                       PrintError => 0,
                       AutoCommit => 0 }) or die $DBI::errstr;
 

$sqlquery = "update TEST_ASSESSMENT set RESPONSE = \'$string\' where doc_id = 34 and version_id = \'1.0.0\'";
print "\nSqlQuery : $sqlquery";
$dbh->do("$sqlquery") or die $dbh->errstr;
 

 

$sth = $dbh->prepare( "select response from TEST_ASSESSMENT where doc_id = 34 and version_id = '1.0.0'" ) or die $dbh->errstr;
$sth->execute();
 

while ( my($res) = $sth->fetchrow_array )
{
 # $res = decode("ISO-8859-1", $res);
 #$res = encode("utf8", $res);
  print "\n$res";
}
 

$dbh->commit();
$dbh->disconnect();

Perl One Line Programs

2008-05-10T00:33:00.000-07:00

# run program, but with warnings
perl -w my_file

# run program under debugger
perl -d my_file

# just check syntax, with warnings
perl -wc my_file

# useful at end of "find foo -print"
perl -nle unlink

# simplest one-liner program
perl -e 'print "hello world!\n"'

# add first and penultimate columns
perl -lane 'print $F[0] + $F[-2]'

# just lines 15 to 17
perl -ne 'print if 15 .. 17' *.pod

# in-place edit of *.c files changing all foo to bar
perl -p -i.bak -e 's/\bfoo\b/bar/g' *.c

# command-line that prints the first 50 lines (cheaply)
perl -pe 'exit if $. > 50' f1 f2 f3 ...

# delete first 10 lines
perl -i.old -ne 'print unless 1 .. 10' foo.txt

# change all the isolated oldvar occurrences to newvar
perl -i.old -pe 's{\boldvar\b}{newvar}g' *.[chy]

# command-line that reverses the whole file by lines
perl -e 'print reverse <>' file1 file2 file3 ....

# find palindromes
perl -lne 'print if $_ eq reverse' /usr/dict/words

# command-line that reverse all the bytes in a file
perl -0777e 'print scalar reverse <>' f1 f2 f3 ...

# command-line that reverses the whole file by paragraphs
perl -00 -e 'print reverse <>' file1 file2 file3 ....

# increment all numbers found in these files
perl i.tiny -pe 's/(\d+)/ 1 + $1 /ge' file1 file2 ....

# command-line that shows each line with its characters backwards
perl -nle 'print scalar reverse $_' file1 file2 file3 ....

# delete all but lines beween START and END
perl -i.old -ne 'print unless /^START$/ .. /^END$/' foo.txt

# binary edit (careful!)
perl -i.bak -pe 's/Mozilla/Slopoke/g' /usr/local/bin/netscape

# look for dup words
perl -0777 -ne 'print "$.: doubled $_\n" while /\b(\w+)\b\s+\b\1\b/gi'

# command-line that prints the last 50 lines (expensively)
perl -e 'lines = <>; print @@lines[ $#lines .. $#lines-50' f1 f2 f3 ...

Comparison of C, C++, Java, Perl, Python, Rexx, and Tcl.

2007-06-22T02:14:00.000-07:00

Run Time :

Number of programs and name/version of compiler or interpreter used for the various languages. The Java evaluation uses either the JDK 1.2.2 Hotspot Reference version or the JDK 1.2.1 Solaris Production version (with JIT),whichever was faster for each program. All programs were executed on a 300MHz Sun Ultra-II workstation with 256MB memory, running under SunOS 5.7 (Solaris 7). Note that the results for C and Rexx will be based on only 5 or 4 programs, respectively, and are thus rather coarse estimates of reality,but for all of the other languages there are 10 or more programs,which is a broad-enough base for reasonably precise results.

####################################################################
language no. compiler or execution platform
-------- --- ----------------------------
Tcl 10 tcl 8.2.2
Rexx 4 Regina 0.08g
Python 13 python 1.5.2
Perl 13 perl 5.005_02
Java 24 Sun JDK 1.2.1/1.2.2
C++ 11 GNU g++ 2.7.2
C 5 GNU gcc 2.7.2
###################################################################

The typical (i.e., median) run time for Tcl is not significantly longer than that for Java or even for C++.

The median run times of both Python and Perl are smaller than those of Rexx and those of Tcl.

The median run time of Java is not significantly different from any of the others (not even Rexx, where p = 0:13).

Don’t be confused by the median for C++. Since the distance to the next larger and smaller points is rather large, it is unstable. The Wilcoxon test, which takes the whole sample into account, confirms that the C++ median in fact tends to be smaller than the Java median (p = 0:18).

The median run time of C is smaller than those of Java Rexx, and Tcl and tends to be smaller than those of Perl and Python.

Except for two very slow programs, Tcl and Perl run times tend to have a smaller variability than the run times for the other languages.