Perl

Perl Programming
See Perl Programming

READ

 * How do I return multiple variables from a subroutine? - http://perlmeme.org/faqs/perl_thinking/returning.html
 * Dereferencing in perl - http://www.perlmeme.org/howtos/using_perl/dereferencing.html
 * Subroutines and References in Perl - http://www.troubleshooters.com/codecorn/littperl/perlsub.htm
 * Hashes of Hashes (Programming Perl) - http://docstore.mik.ua/orelly/perl3/prog/ch09_04.htm
 * Perl Primer 014, A Perl hash of hashes, or Multidimensional array. HTML FIX IT . COM - http://htmlfixit.com/cgi-tutes/tutorial_Perl_Primer_014_Advanced_data_constructs_A_hash_of_hashes.php
 * Multi-Dimensional Hashes in Perl - http://www.suite101.com/article.cfm/perl/98770

service:
 * http://www.cygwin.com/ml/cygwin/1999-05/msg00714.html
 * http://www.foo.be/docs/tpj/issues/vol4_3/tpj0403-0011.html
 * http://code.activestate.com/lists/perl-win32-users/16439/
 * http://www.perlmonks.org/index.pl?node_id=855752

Signals:
 * http://affy.blogspot.com/p5be/ch13.htm
 * http://www.cs.cf.ac.uk/Dave/PERL/node116.html

Hello World
print "Hello World\n";
 * 1) !/usr/bin/perl

Documentation
Perl functions A-Z - perldoc.perl.org - http://perldoc.perl.org/index-functions.html

One Liners
upper.sh: echo $1 | perl -lane 'print " cp $_ ". uc ($_)' | sh

Scalars
$myvar = 1; $myvar = "abc"; print $myvar;

Lists
Lists or arrays

my @mylist = ; @mylist = ( 1, 2, 3 ); @mylist = ( "a", "b", "c" ); print @mylist; # returns count print "@mylist"; # prints list separated by spaces

Hash Variables
my %myhash = ; %myhash = ("key1", "value1", "key2", "value2"); %myhash = ("key1" => "value1", "key2" => "value2"); $myhash{"key1"} = "value1"; # notice sigil delete %myhash{"key1");

See

Lexical Variables
my $x;

Note: Lexical variables (we'll see why later) or private variables because they're private. They're also sometimes called my variables because they're always declared with my. It's tempting to call them `local variables', because their effect is confined to a small part of the program, but don't do that, because people might think you're talking about Perl's local operator, which we'll see later. When you want a `local variable', think my, not local. 

Local
local $x;

This does not do what you think it does. See http://perl.plover.com/FAQs/Namespaces.html

Why have local at all? The answer is 90% history. Early versions of Perl only had global variables.

Function parameters
sub myfunc { my ( $var1, $var2, @leftover ) = @_; }

if
Number Compare: if (5 == 5) { print "== for numeric values\n"; } if (5 >= 4) { print ">= for numeric values\n"; }
 * 1) NUMERIC COMPARATORS: == != < > <= >=

String Compare: if ('moe' eq 'moe') { print "eq (EQual) for string values\n"; } if ('B' ge 'A') { print "ge (Greater-than Equal-to) for string values\n"; }
 * 1) STRING COMPARATORS: eq ne gt ge lt le

Logical: if (($number <= 10) && ($number > 0)) { ...}
 * 1) LOGICAL COMPARATORS: && || !
 * 2) LOGICAL COMPARATORS: and or not

Else: if(...) { ... } else { ... } if(...) { ... } elsif(...) { ... } else { ... }  # notice "elsif"

Unless: (opposite of if) unless ($gas_money == 10) { ... }

Switch/Case:
 * There is no switch/case statement in perl

Quote and Quote-like Operators
from 'man perlop':

While we usually think of quotes as literal values, in Perl they func- tion as operators, providing various kinds of interpolating and pattern matching capabilities. Perl provides customary quote characters for these behaviors, but also provides a way for you to choose your quote character for any of them. In the following table, a "{}" represents any pair of delimiters you choose.

Customary Generic        Meaning        Interpolates ’’      q{}          Literal             no               ""      qq{}          Literal             yes ‘‘     qx{}          Command             yes* qw{}        Word list            no               //       m{}       Pattern match          yes* qr{}         Pattern             yes* s{}{}     Substitution          yes* tr{}{}   Transliteration         no (but see below) < 4096; use constant PI            => 4 * atan2 1, 1; use constant { MAX_SIZE => 5, MIN_SIZE => 1 };

for
for($i=0;$i<100;$i++) {...} for {...} # infinite loop for $i (0..10) { ... }

foreach
foreach my $item (@items) { print $item; } for my $item (@items) { print $item; } foreach (@items) { print $_; } for $i ($low..$high) { ... } # count from $low to $high
 * 1) 'foreach' is an alias of 'for'

while
while ($i<100) {...}

next
[SOME_LOOP] { if(...){ next; } } [SOME_LOOP] { next if /^#/; } [SOME_LOOP] { next if $filename =~ /^FTP_RULES.txt$/; }
 * 1) the 'next' keyword will continue to the next loop (similar to continue in C)

last
[SOME_LOOP] { last if /^#/; } [LOOP] { last if($line eq "end\n");
 * 1) the 'last' keyword will exit the loop (similar to break in C)

redo
[SOME_LOOP] { redo if /^#/; }
 * 1) repeats the last loop

labels
[SOME_LOOP] { OUTER: while(
 * 1) tell next/last/redo to jump to specific loop level:

Lists and Arrays
Note: Single dimension arrays are called "lists". Lists can have multiple repeated items.

Create list/array: @foo = ; @foo = ("one", "two", "three"); @foo = (1, 2, 1);

List to Scalars: ( $first, $second, $third ) = @mylist; ( $first, $second, @all_others ) = @mylist; $last_update_time = (stat($filename))[9]; ($atime, $mtime) = (stat ($file) )[8,9];

Test for empty array: if (@a) { # @a is not empty... if (@ary != 0) { # @a is not empty...
 * Note: never be tempted to use defined on an array (or a hash for that matter). Simply testing the value of the @array in a scalar context is sufficient. The defined function makes little sense on any data type other than a $scalar.

Count of items in list: $count = $#foo + 1; # Index of last element ($#foo = -1 on empty) $count = @food; # implicitly force @foo into scalar context print @food + 0; # implicitly force @foo into scalar context $count = scalar(@food); # explicitly force @foo into scalar context

Append to array: @foo = ( @foo, "four", "five");

Quoted Word array: @myarray = qw/ 1 2 3 4 5 6 7 /; @myarray = qw( 1 2 3 4 5 6 7 );

Dereference value (zero based): print $foo[0]; # first item print $foo[1]; print $foo[$#foo]; # last item, using index of last item

Remove item from list: delete $a[$index]; # removes an element by index number

my $index = 0; while ($index <= $#items ) { my $value = $items[$index]; print "testing $value\n"; if ( $value == 1 or $value == 3 ) { print "removed value $value\n"; splice @items, $index, 1; } else { $index++; } }

@mylist = ('hello', 'world'); $remove_item = 'hello'; for( $i = $#mylist ; $i >= 0 ; $i-- ) { if( $remove_item eq $mylist[$i] ) { delete $mylist[$i]; }
 * 1) cycle backwards to avoid missing an item

Multidimensional Array: $foo[0][0] = "e00"; $foo[0][1] = "e01"; $foo[1][0] = "e10"; $foo[1][1] = "e11"; $foo[1][2] = "e12";

@foo = (  ['e00', 'e01' ],   ['e10', 'e11', 'e12' ], );

Loop through Multidimensional Array: foreach $items (@foo) { foreach $item (@$items) { print $item. "\n"; } } for my $i (0..$#foo) { for my $j (0..$#{$foo[$i]}) { print "\$i = $i, \$j = $j, $foo[$i][$j]\n"; } }

Passed to a funciton: my @my_list = @_; my ( $item1, $item2, $item3, $all_others ) = @_;

Check if item in list: $findme = 'test'; foreach $item in (@foo) { if( $item eq $findme ) ...; }

my $element = 'Whatever you are searching for' ; if (grep {$_ eq $element} @TheArray) { print "Element '$element' found!\n" ; }

push/pop/shift/unshift: @a = (1, 2, 3); $newcount = push(@a, $item); # append $item to end of list $right_item = pop(@a); # remove item from end of list $newcount = unshift(@a, $item); # add item to left $left_item = shift(@a); # remove one item from left delete $a[$index]; # removes an element by index number

sleep
To sleep for [n] seconds sleep [n];

Sleep less than a second: select(undef, undef, undef, 0.25);
 * 1) Sleep for 250 milliseconds

Using usleep: use strict; use warnings;

use Time::HiRes qw(usleep nanosleep);

usleep(1000); nanosleep(1000000);
 * 1) 1 millisecond == 1000 microseconds
 * 1) 1 microsecond == 1000 nanoseconds

Hashes
NOTE: Pay close attention to the sigils

Create hash: %foo = {}; # empty hash

Create hash from list: %foo = ;      # empty list %foo = @mylist; # list of key, value pairs %foo = ("key1", "value1", "key2", "value2"); %foo = ("key1" => "value1", "key2" => "value2");

Edit hash: (notice sigil) $foo{"key1"} = "value1"; # by string $foo{key1} = "value1";   # by bare word $foo{$key} = "value1";   # by variable

Delete entry: delete $foo{$key);

Dereference hash: print $foo{"key1"}; # by string print $foo{key1};  # by bare word print $foo{$key};  # by variable print %foo->{"key1"}; # using reference form

Get list of keys: @keys = keys( %hash );

Hash count: $count = scalar( keys( %hash ) );

Iterating through hash: foreach $key (sort keys %foo) { print $foo{$key}; } for $key ( keys %foo ) { ... } foreach $key ( sort { $foo{$a} cmp $foo{$b} } keys %foo) { print "$key $coins{$key}"; }
 * 1) sorted by keys
 * 1) potentially unsorted by keys
 * 1) sorted by values

Sorting using custom sort methods: sub hashValueAscendingNum { $grades{$a} <=> $grades{$b}; } sub hashValueDescendingNum { $grades{$b} <=> $grades{$a}; } print "\nGRADES IN ASCENDING NUMERIC ORDER:\n"; foreach $key (sort hashValueAscendingNum (keys(%grades))) { print "\t$grades{$key} \t\t $key\n"; } print "\nGRADES IN DESCENDING NUMERIC ORDER:\n"; foreach $key (sort hashValueDescendingNum (keys(%grades))) { print "\t$grades{$key} \t\t $key\n"; } @sorted = sort { $a <=> $b } @not_sorted # numerical sort @sorted = sort { $a cmp $b } @not_sorted # ASCII-betical sort @sorted = sort { lc($a) cmp lc($b) } @not_sorted # alphabetical sort

Get a list of hash keys sorted by value: @sorted = sort { $hash{$a} cmp $hash{$b} } keys %hash;

Get a reverse sort of a list: @sorted = sort { $b cmp $a } @list; # or @sorted = reverse sort { $a cmp $b } @list;

Passing to function: %first = ( one => "a", two => "b", -three => "c" ); passhash( %first ); passhash( one => "a", two => "b", -three => "c" ); sub passhash { (%items) = @_; for $key ( sort keys %items ) { print $key. " => " . $items{$key}. "\n"; } }

File Modes
Note: Each of the above modes can also be prefixed with the + character to allow for simultaneous reading and writing.

Open and Read Files
Open format:
 * 1) open FILEHANDLE, MODE, EXPR

Open file: open(MYFILE, $filename) or die "Can't open $filename: $!\n"; open MYFILE, ">", $filename or die "Can't open $filename: $!\n"; open MYFILE, ">filename" or die "Can't open $filename: $!\n"; open MYFILE, ">>", $filename or die "Can't open $filename: $!\n";
 * 1) for input
 * 1) for output
 * 1) for append

Note: $! contains the error message, if there is an error.

Read file lines: while ($line = ) { ... }

foreach $line () { chomp $line; print $line. "\n"; }

@lines = ;

Read STDIN: (Diamond operator) foreach my $line (<>) { ...} foreach my $line () { ...}

Write STDOUT: print STDOUT "Hello World\n";

Write STDERR: print STDERR "Hello World\n";

Write to file handle: print MYFILE "Hello World\n";

Close file: close(MYFILE);

Read a line and chomp: chomp($line = );

Read one character at a time in "binary mode":
 * 1) read FILEHANDLE, SCALAR, LENGTH
 * 2) read FILEHANDLE, SCALAR, LENGTH, OFFSET

open FILE, "picture.jpg" or die $!; binmode FILE; my ($buf, $data, $n); while (($n = read FILE, $data, 4) != 0) { print "$n bytes read\n"; $buf .= $data; } close(FILE);

Redirect STDOUT and STDERR
Saves, redirects, and restores STDOUT and STDERR: open SAVEOUT, ">&STDOUT"; open SAVEERR, ">&STDERR";
 * 1) !/usr/bin/perl

open STDOUT, ">foo.out" or die "Can't redirect stdout"; open STDERR, ">&STDOUT" or die "Can't dup stdout";

select STDERR; $| = 1; # enable autoflush, make unbuffered select STDOUT; $| = 1; # enable autoflush, make unbuffered

print STDOUT "stdout 1\n"; # these I/O streams propogate to print STDERR "stderr 1\n";  # subprocesses too

system("echo 'hi'"); # uses new stdout/stderr

close STDOUT; close STDERR;

open STDOUT, ">&SAVEOUT"; open STDERR, ">&SAVEERR";

print STDOUT "stdout 2\n"; print STDERR "stderr 2\n";

Similar Source: http://perldoc.perl.org/functions/open.html

See: perldoc -f open

Using IO:Handle:

use IO::Handle;

open INPUT, '<', "input.txt"  or die $!; open OUTPUT, '>', "output.txt" or die $!; open ERROR, '>', "error.txt"  or die $!;

STDIN->fdopen( \*INPUT, 'r' ) or die $!; STDOUT->fdopen( \*OUTPUT, 'w' ) or die $!; STDERR->fdopen( \*ERROR, 'w' ) or die $!;

print "Hello Output File\n";
 * 1) prints to output.txt:

print <>;
 * 1) reads everything from input.txt and prints it to output.txt:

warn "Hello Error File\n";
 * 1) prints to error.txt:

Source: http://www.perlmonks.org/?node_id=11007

Tee STDOUT
Using external 'tee' program: open (STDOUT, "| tee -ai log.txt"); print "blah blah" close (STDOUT);

Source: http://www.unix.com/shell-programming-scripting/41812-perl-print-log-file-screen.html

Using File::Tee: (not included with base)

use File::Tee qw(tee);

tee(STDOUT, '>', 'stdout.txt');
 * 1) simple usage:

print "hello world\n"; system "ls";

my $pid = tee STDERR, { prefix => "err[$$]: ", reopen => 'my.log'};
 * 1) advanced usage:

print STDERR "foo\n"; system("cat /bad/path");

tee STDOUT, '>> /tmp/out', '>> /tmp/out2'; tee STDOUT, '>>', '/tmp/out', '/tmp/out2';

Source: http://search.cpan.org/~salva/File-Tee-0.06/lib/File/Tee.pm

Using IO:Tee: (not icnluded with base) use IO::Tee; $tee = IO::Tee->new(">> debuglog.txt", \*STDOUT); print $tee "an error occurred on ".scalar(localtime)."\n";

Source: http://www.perlcircus.org/files.shtml

Using Tee for commands:

use Tee; tee( $command, @files ); $ cat README.txt | ptee COPY.txt
 * 1) from Perl
 * 1) from the command line

Source: http://search.cpan.org/~dagolden/Tee-0.13/lib/Tee.pod

Ugly Windows Solution: (Based on http://www.xav.com/perl/lib/Pod/perlfork.html) my $parent = 'CHILDPIPE';

open SAVEOUT, ">&STDOUT"; open SAVEERR, ">&STDERR";

pipe $parent, my $child or die;

$pid = fork;

print "PID: $pid \n";

if( $pid == 0 ) { print "CHILD: $pid\n";

close($parent); open(STDOUT, ">&=" . fileno($child)) or die; open(STDERR, ">&=" . fileno($child)) or die;

system( "adir" );

open STDOUT, ">&SAVEOUT"; open STDERR, ">&SAVEERR"; exit 0; } else { print "PARENT: $pid\n"; open LOG, ">", "c:\\log.txt"; close($child); while( $line =  ) { print SAVEOUT "P: $line\n"; print LOG "P: $line\n"; #sleep 1; } print LOG "hi\n"; close LOG; open STDOUT, ">&SAVEOUT"; print "test\n"; print SAVEOUT "P: $line\n"; print SAVEOUT "PARENT END\n"; print STDERR "PARENT END\n"; print SAVEOUT "out\n"; close $parent; exit 2; }

File System
Perl Functions for filehandles, files, or directories

Delete Files: unlink('delete-me.txt') or die "Could not delete the file!\n";

Move/Rename Files: rename oldname, newname

File Functions: chmod - changes the permissions on a list of files chown - change the owership on a list of files link - create a hard link in the filesytem rename - change a filename rmdir - remove a directory symlink - create a symbolic link to a file truncate - shorten a file unlink - remove one link to a file

Check if file exists: if( -e $filename ) ...

File Checks: -e File exists -z File exists, has a size of zero -s File exists, has non-zero size -r Readable -w Writable -x Executable -T text File -B binary File

Functions and Parameters
Calling a function MyFunc $arg1, $arg2; MyFunc($arg1, $arg2);

Function parameters: sub MyFunc { ($arg1, $arg2, @argremaining) = @_; } sub MyFunc { $arg1 = shift; $arg2 = shift; }

Application parameters are stored in @ARGV: $pcount = @ARGV; foreach $arg (@ARGV) { ... }

To get the process ID of the current perl program: print $$;

Command Line Parameters
Contains a list of parameters: @ARVG

Parameter count: $pcount = @ARGV;

Print first parameter: print $ARGV[0];

Cycle through parameters: foreach $ARG (@ARGV) { ... }

Cycle through text lines of parameters: $pcount = @ARGV; print "$pcount params: @ARGV\n"; while(<>) { print $ARGV. " - " . $_; }

Integer
Convert decimal number to integer: $myint = int( $decimal );

Increment
Incremental and Decremental $a++; $a--;

Logical Operators
And && Or  || Not ! Xor xor

Comparison
Num  String ==   eq !=    ne <     lt >     gt <=    le >=    ge <=>   cmp

Short Circuit Operation
$a && $b $a and $b

$a || $b $a or $b

open(FILE, "somefile") || die "Can't open somefile: $!\n";

logic operators return last value to assignment (careful with 'and' and 'or' due to precedence below '=') $value = $a || $b; $value = ($a or $b); # parenthesis required due to 'or' having lower precedence to '=');

Random
my $random_number = rand;
 * 1) number between 0 and 1

my $range = 100; my $random_number = rand($range);
 * 1) number between 0 and 100 (not including 100)

my $range = 100; my $random_number = int(rand($range));
 * 1) random integer between 0 and 100 (not including 100)

my $range = 50; my $minimum = 100; my $random_number = int(rand($range)) + $minimum;
 * 1) with offset

Documentation See: perldoc -f rand

Source: http://perlmeme.org/howtos/perlfunc/rand_function.html

time
time - Returns the number of non-leap seconds since whatever time the system considers to be the epoch

$now = time;

$first = time; sleep(10); $second = time; print $first - $second;

Formatting: $STRING = localtime( time ); $STRING = localtime($EPOCH_SECONDS);
 * 1) "Wed Apr 20 13:07:21 2011"

use POSIX qw(strftime); $STRING = strftime($FORMAT, $SECONDS, $MINUTES, $HOUR, $DAY_OF_MONTH, $MONTH, $YEAR, $WEEKDAY, $YEARDAY, $DST);

use Date::Manip qw(UnixDate); $STRING = UnixDate($DATE, $FORMAT);

struct

 * 1) !/usr/bin/perl

use Class::Struct;
 * 1) see Perl 5.8 Documentation - Class::Struct - declare struct-like datatypes as Perl classes
 * 2) http://perl.active-venture.com/lib/Class/Struct.html

struct structtemplate => { x => '$', y => '$' };

@mylist = ;

for( $i = 0 ; $i < 10 ; $i++ ) { $obj = structtemplate->new; $obj->x($i); $obj->y('y'.$i); @mylist[$i]=$obj; }

@mylist[3]->x(8); print @mylist[3]->x;
 * 1) compact modify

$item = @mylist[3]; print $item->x; $item->x(5);
 * 1) verbose grab and modify item

$item = @mylist[3]; print $item->x;
 * 1) check modification

System Calls
Call program and get exit code: $exit = system("vi $file");
 * 1) perldoc -f system
 * 1) return code is also stored in '$?'
 * 2) error message stored in '$!'

To capture the output from a command use merely backticks or "qx//", as described in "‘STRING‘" in perlop.

Call program and get string output: $output = `$COMMAND`; $output = qx/$COMMAND/; # Lines stored in string @output = `cat /etc/passwd`; # Multiple lines stored in list
 * 1) exit code in $?

Switch to new program: (unless command fails) exec( $COMMAND ) or print STDERR "couldn’t exec $COMMAND: $!";
 * 1) perldoc -f exec

Output one line at a time: sub backtick(@) {   my $pid = open(KID, '-|'); die "fork: $!" unless defined($pid); if ($pid) { my $output; while () { print STDOUT $_; $output .= $_; # could be improved... }       close(KID); return $output; } else { exec @_; } }

my @cmd = ('/bin/ls', '-l'); my $output = backtick(@cmd); Source: http://stackoverflow.com/questions/634508/how-can-i-send-perl-output-to-a-both-stdout-and-a-variable

Command Line
Test code syntax: perl -c [file.pl]

Execute one liner code: perl -e '...'

Wrap code: cat [file] | perl -n -e '...' cat [file] | perl -p -e '...'
 * 1)  while (<>){ ... }
 * 1) while (<>){ ... } print

Perl IDE
Perl Editor, Perl IDE - http://perlide.org/
 * Perl IDE and editor polls


 * Padre - The Perl Application Development and Refactoring Environment (written in Perl 5)
 * Eclipse - with the EPIC plugin or with Perlipse using dltk
 * ActiveState - proprietary Komodo IDE or free Komodo Edit
 * Kephra - Programmers Editor along perl-like Paradigms, written in Perl
 * Gvim - with Perl support
 * Emacs - with CPerl Mode

Perl IDE - http://www.softpanorama.org/Scripting/Perlorama/perl_programming_environment.shtml
 * Great tools will not make a bad programmer into a good programmer, but they will certainly make a good programmer better and they can make bad language acceptable (Java is one such example).

A good, modern IDE should at least have the following features:
 * A syntax-coloring text editor with language-specific help, pretty printing and macro language support (SlickEdit is one example of a very good programming editor, but it costs quit a lot).
 * Integrated syntax-checking (Komodo and SlickEdit has one)
 * Version control integration (Subversion, etc).
 * Access to library of templates, fragments, etc ("code-assist" infrastructure)
 * Access to symbol table or at least good XREF support. Perl has basic XREF generation capabilities via special module Xref, for example: perl -MO=Xref[,OPTIONS] scriptname.pl
 * A tree view of source files and resources.
 * Built-in debugger or integration with a good debugger (Komodo has a usable built-in debugger)

One possible "poor man IDE" is VIM. Vim has:
 * Bracket matching (user-definable, even)
 * Folding
 * Suggest and Complete
 * Multi-document
 * Split view
 * Doc and Help viewer
 * All the other languages
 * Is on every platform known to the Gods and Man (and then some)
 * See also http://mamchenkov.net/wordpress/2004/05/10/vim-for-perl-developers/

Epic Eclipse Perl Integration
EPIC - Eclipse Perl Integration - http://www.epic-ide.org/
 * EPIC is an open source Perl IDE (including editor and debugger) based on the Eclipse platform, compatible with Windows, Linux and Mac OS X. Whether you are into CGI scripting or full-fledged Perl projects with hundreds of modules, EPIC is the most feature-rich and extensible free Perl IDE available today, thanks to a seamless integration with all the major features and GUI conventions of Eclipse.

EPIC - How To Install - http://www.epic-ide.org/download.php
 * Eclipse Software Add Location: http://e-p-i-c.sf.net/updates

EPIC - User's Guide - http://www.epic-ide.org/guide/index.php
 * EPIC - User's Guide (PDF Version) - http://www.epic-ide.org/downloads/EPIC_User%27s_Guide.pdf

Other components Needed:


 * Eclipse - http://www.eclipse.org/
 * Platform Runtime Binary (non SDK included version) - http://download.eclipse.org/eclipse/downloads/
 * 'eclipse-platform-3.6.2-win32.zip' or 'eclipse-platform-3.6.2-win32-x86_64.zip'
 * Will have to customize perspective and enable Command Group Availability of "Debug" and "Launch"


 * Install PadWalker for debugger:
 * perl -MCPAN -e "install PadWalker"

Padre
Padre, the Perl IDE - http://padre.perlide.org/
 * Padre is a Perl IDE, an integrated development environment, or in other words a text editor that is simple to use for new Perl programmers but also supports large multi-lingual and multi-technology projects.
 * Our primary focus is to create a peerless environment for learning Perl and creating Perl scripts, modules and distributions, with an extensible plug-in system to support the addition of related functionality and languages and to support advanced developers taking the editor anywhere they want it to go.

Open Perl IDE
Open Perl IDE - http://open-perl-ide.sourceforge.net/ Open Perl IDE | Download Open Perl IDE software for free at SourceForge.net - http://sourceforge.net/projects/open-perl-ide/
 * Open Perl IDE is an integrated development environment for writing and debugging Perl scripts with any standard perl distribution under Windows 95/98/NT/2000.

Install CPAN module
See CPAN

Test for module: perl -e 'use IO::Uncompress::Gunzip; print "OK\n";' perldoc -l IO::Uncompress::Gunzip

Installation: apt-get install libnet-snmp-perl yum install while (<>){ ... } perl -MCPAN -e 'install Net::SNMP' note: package manager is usually preferred
 * 1) debian
 * 1) redhat
 * 1) perl method

Perl Slogan

 * "There's More Than One Way To Do It"
 * TMTOWTDI

Shebang Notation

 * 1) !/usr/bin/perl

Help
man perl man perl[topic] man perldata man perfaq1 perldoc -f [function]

Packages
Declare a name space: package MyWorld::MySpace; sub hello { ... }
 * 1) MySpace.pm in folder MyWorld/

To use: use MyWorld::MySpace; MyWorld::MySpace::hello;

Note: A name space will continue until another package is declared or the end of file is reached.

To export default functions: package MyWorld::MySpace; our $VERSION = '1.00'; use base 'Exporter';     # allow for default functions to be exported our @EXPORT = qw(hello); # default functions to export sub hello { ... }

include
Perl's equivalents of "include" are use, require and do. 

Perl Monks - Including files http://www.perlmonks.org/?node_id=393426

Classes
package Person;

sub new { my $self = {}; $self->{NAME} = undef; bless($self); return $self; }

sub name { my $self = shift; if (@_) { $self->{NAME} = shift } return $self->{NAME}; }

1; # modules have to return any true value

Another form of new (with arguments): my($class, %args) = @_; my $self = bless({}, $class); return $self;

Usage: use Person;

$person = Person->new; print $person->name("test");

Data Dumper
The standard Data::Dumper module is very useful for examining exactly what is contained in your data structure (be it hash, array, or object (when we come to them) ). When you use this module, it exports one function, named Dumper. This function takes a reference to a data structure and returns a nicely formatted description of what that structure contains.

use strict; use warnings; use Data::Dumper;
 * 1) !/usr/bin/env perl

my @foo = (5..10); $foo[@foo+1] = 'last';
 * 1) add one element to the end of the array
 * 2) do you see the error?

print Dumper(\@foo);

When run, this program shows you exactly what is inside @foo:

$VAR1 = [ 5,         6,          7,          8,          9,          10,          undef, 'last' ];

Source: Programming in Perl - Debugging

__DATA__
__DATA__ & 

Perl uses the __DATA__ marker as a pseudo-datafile. You can use this marker to write quick tests which would involve finding a file name, opening that file, and reading from that file. If you just want to test a piece of code that requires a file to be read (but don't want to test the actual file opening and reading), place the data that would be in the input file under the __DATA__ marker. You can then read from this pseudo-file using , without bothering to open an actual file:

use strict; use warnings;
 * 1) !/usr/bin/env perl

while (my $line = ) { chomp $line; print "Size of line $.: ", length $line, "\n"; }

__DATA__ hello world

The $. variable keeps track of the line numbers of the file currently being processed via a while (<$fh>) { ... } loop. More explicitly, it is the number of the last line read of the last file read.

Source: Programming in Perl - Debugging

__FILE__ and __LINE__
These are two special markers that return, respectively, the name of the file Perl is currently executing, and the Line number where it resides. These can be used in your own debugging statements, to remind yourself where your outputs were in the source code:

print "On line ". __LINE__. " of file ". __FILE__. ", \$foo = $foo\n";

Note that neither of these markers are variables, so they cannot be interpolated in a double-quoted string

Source: Programming in Perl - Debugging

TODO
User input $age = <>;

sleep sleep [seconds]

Getopts
Getopt::Long - perldoc.perl.org - http://perldoc.perl.org/Getopt/Long.html

use Getopt::Long;

use Getopt::Long; my $data = "file.dat"; my $length = 24; my $verbose; $result = GetOptions ("length=i" => \$length, # numeric                     "file=s" => \$data, # string                      "verbose" => \$verbose); # flag

To get the remaining arguments, check @ARGV

Ping
use Net::Ping; my $host = [IP OR ADDRESS]; $p = Net::Ping->new("icmp"); print "$host is down " unless $p->ping($host, 2); $p->close;

$p->hires; ($ret, $duration, $ip) = $p->ping($host, 5.5); printf("$host [ip: $ip] is alive (packet return time: %.2f ms)\n", 1000 * $duration) if $ret; $p->close;

http://perldoc.perl.org/Net/Ping.html

unsort lines
unsort.pl:
 * 1) !/usr/bin/perl -w


 * 1) @(#) randomize Effectively _unsort_ a text file into random order.
 * 2) 96.02.26 / drl.
 * 3) Based on Programming Perl, p 245, "Selecting random element ..."

srand(time|$$);
 * 1) Set the random seed, PP, p 188

@a = <>;
 * 1) Suck in everything in the file.

while ( @a ) { $choice = splice(@a, rand @a, 1); print $choice; }
 * 1) Get random lines, write 'em out, mark 'em done.

source: http://www.linuxforums.org/forum/programming-scripting/59111-how-do-you-randomly-shuffle-lines-text-file.html

mkdir
mkdir [FILENAME],[MASK] mkdir [FILENAME]

mkdir $dir or die "Error: $!";

Source: http://perldoc.perl.org/functions/mkdir.html

Get MAC Address
$output = `ipconfig /ALL`; if( $output =~ m/((?:[0-9A-F-]{2}-?){6})/i ) { print "Found Mac address: $1\n"; }
 * 1) source: http://www.experts-exchange.com/Programming/Languages/Scripting/Perl/Q_20850500.html

IO Buffering
Suffering from Buffering? - http://perl.plover.com/FAQs/Buffering.html

how to make the filehandle hot:

my $ofh = select LOG; $| = 1; select $ofh;

The key item here is the $| variable. If you set it to a true value, it makes the current filehandle hot. What's the current filehandle? It's the one last selected with the select operator. So to make LOG hot, we `select' it, set $| to a true value, and then we re-`select' whatever filehandle was selected before we selected LOG.

Compact version: select((select(LOG), $|=1)[0]);

If you happen to be using the FileHandle or IO modules, there's a nicer way to write this: use FileHandle;         # Or `IO::Handle' or `IO::'-anything-else LOG->autoflush(1);      # Make LOG hot.

Recipe 7.12. Flushing Output - http://docstore.mik.ua/orelly/perl/cookbook/ch07_13.htm

Disable buffering by setting the per-filehandle variable $| to a true value, customarily 1 :

$old_fh = select(OUTPUT_HANDLE); $| = 1; select($old_fh);

Or, if you don't mind the expense, disable it by calling the autoflush method from the IO modules:

use IO::Handle; OUTPUT_HANDLE->autoflush(1);

INET Socket
IO::Socket::INET - perldoc.perl.org - http://perldoc.perl.org/IO/Socket/INET.html

Server
$sock = IO::Socket::INET->new('127.0.0.1:25');

Multiplexing
Multiplexing filehandles with select in perl - http://www.perlfect.com/articles/select.shtml

Multiplexing without threads


 * 1) Multiplexed Socket

use IO::Socket; use IO::Select;

STDOUT->autoflush(1);

my $sock = new IO::Socket::INET (      LocalHost => 'localhost',       LocalPort => '7070',       Proto => 'tcp',       Listen => 1,       Reuse => 1,       ); die "Could not create socket: $!\n" unless $sock;

$sel = new IO::Select; $sel->add($sock);

while(1) {

# check for ready handle my ($rhlist) = IO::Select->select($sel, undef, undef, 0);

# cycle through ready handles, if any foreach $rh ( @$rhlist ) { if ( $rh == $sock ) { # handle new connection $ns = $rh->accept; $sel->add($ns); print "-new-"; } else { # handle existing connections $buf = <$rh>; if($buf) { # print buffer print "[$buf]"; } else { # handle closed connections $sel->remove($rh); close($rh); print "-close-"; }   }  }

print "."; # yeld for 1 second IO::Select->select(undef, undef, undef, 1); }

close($sock);

Select

 * "The idea behind select is to avoid blocking calls by making sure that a call will not block before attempting it. How do we do that? Suppose we have two filehandles, and we want to read data from them as it comes in. Let's call them A and B. Now, let's assume that A has no input pending yet, but B is ready to respond to a read call. If we know this bit of information, we can try readin from B first, instead of A, knowing that our call will not block. select gives us this bit of information. All we need to do is to define sets of filehandles (one for reading, one for writing and one for errors) and ask call select on them which will return a filehandle which is ready to perform the operation for which it has been delegated (depending on which set it is in) as soon as such a filhandle is ready."

Perl, Sockets and TCP/IP Networking
Perl, Sockets and TCP/IP Networking. - http://www.perlfect.com/articles/sockets.shtml

Multiplexing filehandles with select in perl. - http://www.perlfect.com/articles/select.shtml

Client
use IO::Socket; my $sock = new IO::Socket::INET (   PeerAddr => 'localhost',    PeerPort => '7070',    Proto => 'tcp',    ); die "Could not create socket: $!\n" unless $sock; print $sock "Hello there!\n"; close($sock);

Server
The first thing we need to do is to create a socket. We will use it to receive connections. The code below shows how to create a receiving socket. Note that we need to specify the local hostname and the port to which the socket will be bound. Of course, if the port is already in use this call will fail. Also note the 'Listen' parameter: this is the maximum number of connections that can be queued by the socket waiting for you to accept and process them. For the time being we will only accept a maximum of one connection at any time. (This means that a connection attempt while we're dealing with another connection, will return with an error like 'connection refused') Finally the 'Reuse' option tells the system to allow reuse of the port after the program exits. This is to ensure that if our program exits abnormally and does not properly close the socket, running it again will allow opening a new socket on the same port.

use IO::Socket; my $sock = new IO::Socket::INET (       LocalHost => 'localhost',       LocalPort => '7070',       Proto => 'tcp',       Listen => 1,       Reuse => 1,       ); die "Could not create socket: $!\n" unless $sock;

my $new_sock = $sock->accept; while(<$new_sock>) { print $_; } close($sock);

Kenneth's Echo Server

 * 1) !/usr/bin/perl

use IO::Socket; my $sock = new IO::Socket::INET (       #LocalHost => 'localhost',       LocalPort => '7070',       Proto => 'tcp',       Listen => 1,       Reuse => 1,       ); die "Could not create socket: $!\n" unless $sock;

while (1) { my $new_sock = $sock->accept; print "New Connection: ". $new_sock->peerhost. "\n"; $new_sock->send("Hi " . $new_sock->peerhost . "\r\n"); while(<$new_sock>) { print "CLIENT: ". $_;   $_ =~ s/(.*)\r\n/$1/; $new_sock->send("SERVER: [ $_ ]\r\n"); if($_ =~ /quit/) { close($new_sock); } } } close($sock);

threads
threads - perldoc.perl.org - http://perldoc.perl.org/threads.html

perlthrtut - tutorial on threads in Perl - http://www.xav.com/perl/lib/Pod/perlthrtut.html

CPAN
See CPAN

Regular Expression
See: Regular Expression

rxrx - Regexp::Debugger
Install: cpan Regexp::Debugger

Usage: rxrx perl -MRegexp::Debugger -E 'Regexp::Debugger::rxrx(@ARGV)'

To set the regex: /[SOMETHING]/

To set the string: '[SOMETHING]'

To match: m

To quit: q

Commands: / : Enter a pattern ' : Enter a new literal string " : Enter a new double-quoted string     m : Match current string against current pattern q or x : quit debugger and exit      h : help

Match Commands: - : back step [enter] : forward step c : proceed visually quickly to the end

Warning: Arrow keys do not appear to work!

---

/usr/local/bin/rxrx use Regexp::Debugger; Regexp::Debugger::rxrx(@ARGV);
 * 1) ! /usr/bin/env perl

__END__

=head1 NAME

rxrx - command-line REPL and wrapper for Regexp::Debugger

=head1 DESCRIPTION

See the documentation of L.

=cut

keywords
linux perl