Amazing Perl

Importing from the ‘Exporter’

2009-10-29T03:08:00.001-07:00

One advantage of the Exporter module is that the import method it provides is well developed and handles many different situations for us. Even if we decide to provide our own import subroutine we may want to use Exporter too, just for the richness of the features it provides. For example, it accepts regular expressions as well as literal symbol names, which means that we can define a collection

Exporting

2009-10-29T03:06:00.000-07:00

Having examined the import mechanism from the side of the importer, we can take a look at how modules handle import requests. From the module’s perspective of course, this is exporting. The Exporter module provides a generic import subroutine for modules to configure to their own particular tastes. It handles almost all the possible issues that a module needs to consider, and for many modules it

The ‘import’ Mechanism

2009-10-29T03:04:00.001-07:00

Perl’s mechanism for importing symbols is simple, elegant, and shockingly ad hoc, all at the same time. In a nutshell, we call a subroutine called import in the package that we want to import symbols from. The import stage is a secondary stage beyond actually reading and compiling a module file, so it is not handled by the require directive; instead, it is a separate explicit step: require My::

Importing and Exporting

2009-04-29T22:29:00.000-07:00

The term ‘importing’ is used for the process of taking symbols from another package and adding them to our own. From the perspective of the module being imported from, it is ‘exporting’, of course. Either way, the process consists of taking a symbol visible in the namespace of one package and making it visible, without qualification, in another. For example, even if we can see it we would rather

Two-Phased Garbage Collection

2009-04-29T22:26:00.000-07:00

For most purposes, Perl uses a fast and simple reference-based garbage collection system. For this reason, there's an extra dereference going on at some level, so if you haven't built your Perl executable using your C compiler's -O flag, performance will suffer. If you have built Perl with cc -O, then this probably won't matter.A more serious concern is that unreachable memory with a non-zero

Destructors

2009-04-29T22:24:00.001-07:00

When the last reference to an object goes away, the object is automatically destroyed. (This may even be after you exit, if you've stored references in global variables.) If you want to capture control just before the object is freed, you may define a DESTROY method in your class. It will automatically be called at the appropriate moment, and you can do any extra cleanup you need to do. Perl

Method Invocation

2009-04-29T22:22:00.000-07:00

There are two ways to invoke a method, one of which you're already familiar with, and the other of which will look familiar. Perl 4 already had an ``indirect object'' syntax that you use when you say print STDERR "help!!!\n";This same syntax can be used to call either class or instance methods. We'll use the two methods defined above, the class method to lookup an object reference and the

A Method is Simply a Subroutine

2009-04-29T22:21:00.000-07:00

Unlike say C++, Perl doesn't provide any special syntax for method definition. (It does provide a little syntax for method invocation though. More on that later.) A method expects its first argument to be the object (reference) or package (string) it is being invoked on. There are just two types of methods, which we'll call class and instance. (Sometimes you'll hear these called static and

A Class is Simply a Package

2009-04-29T22:19:00.000-07:00

Unlike say C++, Perl doesn't provide any special syntax for class definitions. You use a package as a class by putting method definitions into the class. There is a special array within each package called @ISA, which says where else to look for a method if you can't find it in the current package. This is how Perl implements inheritance. Each element of the @ISA array is just the name of another

An Object is Simply a Reference

2009-04-15T22:30:00.000-07:00

Unlike say C++, Perl doesn't provide any special syntax for constructors. A constructor is merely a subroutine that returns a reference to something ``blessed'' into a class, generally the class that the subroutine is defined in. Here is a typical constructor: package Critter; sub new { bless {} }That word new isn't special. You could have written a construct this way, too: package

Object Oriented Perl

2009-04-15T22:29:00.000-07:00

The next series of posts are on Object Oriented Perl!

Perl Classes

2009-02-23T20:04:00.000-08:00

There is no special class syntax in Perl, but a package may act as a class if it provides subroutines to act as methods. Such a package may also derive some of its methods from another class (package) by listing the other package name(s) in its global @ISA array (which must be a package global, not a lexical). package Module; # assumes Module.pm use strict; use warnings; BEGIN {

Package Constructors and Destructors

2009-02-05T21:04:00.000-08:00

Four special subroutines act as package constructors and destructors. These are the BEGIN, CHECK, INIT, and DESTROY routines. The sub is optional for these routines.A BEGIN subroutine is executed as soon as possible, that is, the moment it is completely defined, even before the rest of the containing file is parsed. You may have multiple BEGIN blocks within a file--they will execute in order of

Perl modules

2009-02-05T21:01:00.000-08:00

Perl provides a mechanism for alternative namespaces to protect packages from stomping on each other's variables. In fact, there's really no such thing as a global variable in Perl. The package statement declares the compilation unit as being in the given namespace.A module is just a set of related function in a library file a Perl package with the same name as the file. It is specifically

Undefined Values

2009-01-05T02:09:00.000-08:00

The undefined value is a curious entity, being neither a scalar, list, hash, nor any other data type, which is essentially the point. Although it isn’t strictly speaking a datatype, it can be helpful to think of it as a special datatype with only one possible value (NULL). The concept of a ‘value that is not a value’ is common to many languages. In Perl, the undef function returns an undefined

TypeGlobes

2009-01-05T02:06: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 scalarb.array – A reference to arrayc.hash – A

Complex Data Structures

2009-01-05T02:01:00.000-08:00

Combining lists and hashes with references allows us to create arbitrarily complex data structures such as list of lists, hashes of hashes, and lists of hashes of lists of lists and so on. However, Perl lacks the ability to explicitly declare things like multidimensional arrays, because lists and hashes can only contain scalar values. Example 1:# List of list references@arr = ( [1,2], [3,4,5], [

Symbolic references

2008-12-09T05:27:00.001-08:00

The value of the scalar is taken to be the name of a variable, rather than a direct link to a (possibly) anonymous value. $name = "foo"; $$name = 1; # Sets $foo ${$name} = 2; # Sets $foo ${$name x 2} = 3; # Sets $foofoo $name->[0] = 4; # Sets $foo[0] @$name = (); # Clears @foo &$name(); # Calls &foo() (as in

Using References

2008-12-09T05:26:00.001-08:00

That's it for creating references. By now you're probably dying to know how to use references to get back to your long-lost data. There are several basic methods. 1. Anywhere you'd put an identifier (or chain of identifiers) as part of a variable or subroutine name, you can replace the identifier with a simple scalar variable containing a reference of the correct type: $bar = $$scalarref;

Making references

2008-12-09T05:25:00.001-08:00

References can be created in several ways. Three of them are as follows. By using the backslash operator on a variable, subroutine, or value. (This works much like the & (address-of) operator in C.) This typically creates another reference to a variable, because there's already a reference to the variable in the symbol table. But the symbol table reference might go away, and you'll still have the

Perl references

2008-12-09T05:19:00.000-08:00

Before release 5 of Perl it was difficult to represent complex data structures, because all references had to be symbolic--and even then it was difficult to refer to a variable instead of a symbol table entry. Perl now not only makes it easier to use symbolic references to variables, but also lets you have ``hard'' references to any piece of data or code. Any scalar may hold a hard reference.

Perl to write what??

2008-01-26T06:16:00.000-08:00

We all know that when faced with a job to do, we usually tend to reach for the most familiar tool in our belt. And while perl is certainly a versatile tool, it isn't the right tool for every job.Perl is the granddaddy of the open-source scripting languages, with the 1.0 release seeing the light of day way back in 1987. By comparison, PHP wasn't released until 1994, and Python didn't have its 0.9

Special Variables

2008-01-16T01:45:00.000-08:00

@ARGV Short Name: @ARGVScope: always global This variable is an array of the arguments passed to the script. Unlike the situation in the C language, the 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: $Example46String = "There were $#ARGV arguments, first argument

Regular Expression Meta-Characters, Meta-Brackets,and Meta-Sequences

2008-01-16T01:43:00.002-08:00

Meta-Character Description ^ This meta-character, the caret, matches the beginning of a string or, if the /m option isused, match the beginning of a line. It is one oftwo pattern anchors, the other anchor is the $. . This meta-character will match any single character except for the newline character unless the /s option is

Substitution

2008-01-16T01:43:00.001-08:00

When you get the hang of pattern matching, you'll find that substitutions are quite straightforward and very powerful. The substitution operator is s///, which resembles the match operator but has three rather than two slashes. Just as you can do with the match operator, you can substitute any other character for the forward slashes, and you can use the optional i, g, and o switches. The