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>
]]>
			http://coding-school.com/perl-file-operations/feed/
		0
		
		
		
		http://coding-school.com/perl-regular-expressions/
		http://coding-school.com/perl-regular-expressions/#comments
		Fri, 01 Jul 2011 16:47:42 +0000
		admin
				

		http://coding-school.com/?p=2175
		
			
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;

]]>
			http://coding-school.com/perl-regular-expressions/feed/
		0
		
		
		
		http://coding-school.com/perl-subroutine/
		http://coding-school.com/perl-subroutine/#comments
		Fri, 01 Jul 2011 16:44:53 +0000
		admin
				

		http://coding-school.com/?p=2173
		
			
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]);

]]>
			http://coding-school.com/perl-subroutine/feed/
		0
		
		
		
		http://coding-school.com/perl-references/
		http://coding-school.com/perl-references/#comments
		Fri, 01 Jul 2011 16:41:20 +0000
		admin
				

		http://coding-school.com/?p=2171
		
			
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

]]>
			http://coding-school.com/perl-references/feed/
		0
		
		
		
		http://coding-school.com/perl-if-else/
		http://coding-school.com/perl-if-else/#comments
		Fri, 01 Jul 2011 16:39:09 +0000
		admin
				

		http://coding-school.com/?p=2169
		
			
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";

}


]]>
			http://coding-school.com/perl-if-else/feed/
		0