When the above code is executed, it produces the following result −

[source]

== Perl - Subroutines

A Perl subroutine or function is a group of statements that together performs a task. You can divide up your code into separate subroutines. How you divide up your code among different subroutines is up to you, but logically the division usually is so each function performs a specific task.

Perl uses the terms subroutine, method and function interchangeably.


=== Define and Call a Subroutine

The general form of a subroutine definition in Perl programming language is as follows −

[source]

The typical way of calling that Perl subroutine is as follows −

[source]

In versions of Perl before 5.0, the syntax for calling subroutines was slightly different as shown below. This still works in the newest versions of Perl, but it is not recommended since it bypasses the subroutine prototypes.

[source]

Let's have a look into the following example, which defines a simple function and then call it. Because Perl compiles your program before executing it, it doesn't matter where you declare your subroutine.

[source]

When above program is executed, it produces the following result −

[source]

=== Passing Arguments to a Subroutine

You can pass various arguments to a subroutine like you do in any other programming language and they can be acessed inside the function using the special array @_. Thus the first argument to the function is in $_[0], the second is in $_[1], and so on.

You can pass arrays and hashes as arguments like any scalar but passing more than one array or hash normally causes them to lose their separate identities. So we will use references ( explained in the next chapter ) to pass any array or hash.

Let's try the following example, which takes a list of numbers and then prints their average −

[source]

When above program is executed, it produces the following result −

[source]

=== Passing Lists to Subroutines

Because the @_ variable is an array, it can be used to supply lists to a subroutine. However, because of the way in which Perl accepts and parses lists and arrays, it can be difficult to extract the individual elements from @_. If you have to pass a list along with other scalar arguments, then make list as the last argument as shown below −

[source]

When above program is executed, it produces the following result −

[source]

=== Passing Hashes to Subroutines

When you supply a hash to a subroutine or operator that accepts a list, then hash is automatically translated into a list of key/value pairs. For example −

[source]

When above program is executed, it produces the following result −

[source]

=== Returning Value from a Subroutine

You can return a value from subroutine like you do in any other programming language. If you are not returning a value from a subroutine then whatever calculation is last performed in a subroutine is automatically also the return value.

You can return arrays and hashes from the subroutine like any scalar but returning more than one array or hash normally causes them to lose their separate identities. So we will use references ( explained in the next chapter ) to return any array or hash from a function.

Let's try the following example, which takes a list of numbers and then returns their average −

[source]

When above program is executed, it produces the following result −

[source]

=== Private Variables in a Subroutine

By default, all variables in Perl are global variables, which means they can be accessed from anywhere in the program. But you can create *private* variables called *lexical variables* at any time with the *my* operator.

The *my* operator confines a variable to a particular region of code in which it can be used and accessed. Outside that region, this variable cannot be used or accessed. This region is called its scope. A lexical scope is usually a block of code with a set of braces around it, such as those defining the body of the subroutine or those marking the code blocks of if, while, for, foreach, and eval statements.

Following is an example showing you how to define a single or multiple private variables using *my* operator −

[source]

Let's check the following example to distinguish between global and private variables −

[source]

When above program is executed, it produces the following result −

[source]

=== Temporary Values via local()

The *local* is mostly used when the current value of a variable must be visible to called subroutines. A local just gives temporary values to global (meaning package) variables. This is known as dynamic scoping. Lexical scoping is done with my, which works more like C's auto declarations.

If more than one variable or expression is given to local, they must be placed in parentheses. This operator works by saving the current values of those variables in its argument list on a hidden stack and restoring them upon exiting the block, subroutine, or eval.

Let's check the following example to distinguish between global and local variables −

[source]

When above program is executed, it produces the following result −

[source]

=== State Variables via state()

There are another type of lexical variables, which are similar to private variables but they maintain their state and they do not get reinitialized upon multiple calls of the subroutines. These variables are defined using the *state* operator and available starting from Perl 5.9.4.

Let's check the following example to demonstrate the use of *state* variables −

[source]

When above program is executed, it produces the following result −

[source]

Prior to Perl 5.10, you would have to write it like this −

[source]

=== Subroutine Call Context

The context of a subroutine or statement is defined as the type of return value that is expected. This allows you to use a single function that returns different values based on what the user is expecting to receive. For example, the following localtime() returns a string when it is called in scalar context, but it returns a list when it is called in list context.

[source]

In this example, the value of $timestr is now a string made up of the current date and time, for example, Thu Nov 30 15:21:33 2000. Conversely −

[source]

Now the individual variables contain the corresponding values returned by localtime() subroutine.


== Perl - References

A Perl reference is a scalar data type that holds the location of another value which could be scalar, arrays, or hashes. Because of its scalar nature, a reference can be used anywhere, a scalar can be used.

You can construct lists containing references to other lists, which can contain references to hashes, and so on. This is how the nested data structures are built in Perl.


=== Create References

It is easy to create a reference for any variable, subroutine or value by prefixing it with a backslash as follows −

[source]

You cannot create a reference on an I/O handle (filehandle or dirhandle) using the backslash operator but a reference to an anonymous array can be created using the square brackets as follows −

[source]

Similar way you can create a reference to an anonymous hash using the curly brackets as follows −

[source]

A reference to an anonymous subroutine can be created by using sub without a subname as follows −

[source]

=== Dereferencing

Dereferencing returns the value from a reference point to the location. To dereference a reference simply use $, @ or % as prefix of the reference variable depending on whether the reference is pointing to a scalar, array, or hash. Following is the example to explain the concept −

[source]

When above program is executed, it produces the following result −

[source]

If you are not sure about a variable type, then its easy to know its type using *ref*, which returns one of the following strings if its argument is a reference. Otherwise, it returns false −

[source]

Let's try the following example −

[source]

When above program is executed, it produces the following result −

[source]

=== Circular References

A circular reference occurs when two references contain a reference to each other. You have to be careful while creating references otherwise a circular reference can lead to memory leaks. Following is an example −

[source]

When above program is executed, it produces the following result −

[source]

=== References to Functions

This might happen if you need to create a signal handler so you can produce a reference to a function by preceding that function name with \& and to dereference that reference you simply need to prefix reference variable using ampersand &. Following is an example −

[source]

When above program is executed, it produces the following result −

[source]

== Perl - Formats

Perl uses a writing template called a 'format' to output reports. To use the format feature of Perl, you have to define a format first and then you can use that format to write formatted data.


=== Define a Format

Following is the syntax to define a Perl format −

[source]

Here *FormatName* represents the name of the format. The *fieldline* is the specific way, the data should be formatted. The values lines represent the values that will be entered into the field line. You end the format with a single period.

Next *fieldline* can contain any text or fieldholders. The fieldholders hold space for data that will be placed there at a later date. A fieldholder has the format −

[source]

This fieldholder is left-justified, with a field space of 5. You must count the @ sign and the < signs to know the number of spaces in the field. Other field holders include −

[source]

An example format would be −

[source]

In this example, $name would be written as left justify within 22 character spaces and after that age will be written in two spaces.


=== Using the Format

In order to invoke this format declaration, we would use the *write* keyword −

[source]

The problem is that the format name is usually the name of an open file handle, and the write statement will send the output to this file handle. As we want the data sent to the STDOUT, we must associate EMPLOYEE with the STDOUT filehandle. First, however, we must make sure that that STDOUT is our selected file handle, using the select() function.

[source]

We would then associate EMPLOYEE with STDOUT by setting the new format name with STDOUT, using the special variable $~ or $FORMAT_NAME as follows −

[source]

When we now do a write(), the data would be sent to STDOUT. Remember: if you are going to write your report in any other file handle instead of STDOUT then you can use select() function to select that file handle and rest of the logic will remain the same.

Let's take the following example. Here we have hard coded values just for showing the usage. In actual usage you will read values from a file or database to generate actual reports and you may need to write final report again into a file.

[source]

When executed, this will produce the following result −

[source]

=== Define a Report Header

Everything looks fine. But you would be interested in adding a header to your report. This header will be printed on top of each page. It is very simple to do this. Apart from defining a template you would have to define a header and assign it to $^ or $FORMAT_TOP_NAME variable −

[source]

Now your report will look like −

[source]

=== Define a Pagination

What about if your report is taking more than one page? You have a solution for that, simply use *$%* or $FORMAT_PAGE_NUMBER vairable along with header as follows −

[source]

Now your output will look like as follows −

[source]

=== Number of Lines on a Page

You can set the number of lines per page using special variable *$=* ( or $FORMAT_LINES_PER_PAGE ), By default $= will be 60.


=== Define a Report Footer

While $^ or $FORMAT_TOP_NAME contains the name of the current header format, there is no corresponding mechanism to automatically do the same thing for a footer. If you have a fixed-size footer, you can get footers by checking variable $- or $FORMAT_LINES_LEFT before each write() and print the footer yourself if necessary using another format defined as follows −

[source]

For a complete set of variables related to formating, please refer to the link:../perl/perl_special_variables.html[Perl Special Variables] section.


== Perl - File I/O

The basics of handling files are simple: you associate a *filehandle* with an external entity (usually a file) and then use a variety of operators and functions within Perl to read and update the data stored within the data stream associated with the filehandle.

A filehandle is a named internal Perl structure that associates a physical file with a name. All filehandles are capable of read/write access, so you can read from and update any file or device associated with a filehandle. However, when you associate a filehandle, you can specify the mode in which the filehandle is opened.

Three basic file handles are - *STDIN*, *STDOUT*, and *STDERR,* which represent standard input, standard output and standard error devices respectively.


=== Opening and Closing Files

There are following two functions with multiple forms, which can be used to open any new or existing file in Perl.

[source]

Here FILEHANDLE is the file handle returned by the *open* function and EXPR is the expression having file name and mode of opening the file.


=== Open Function

Following is the syntax to open *file.txt* in read-only mode. Here less than < sign indicates that file has to be opend in read-only mode.

[source]

Here DATA is the file handle, which will be used to read the file. Here is the example, which will open a file and will print its content over the screen.

[source]

Following is the syntax to open file.txt in writing mode. Here less than > sign indicates that file has to be opend in the writing mode.

[source]

This example actually truncates (empties) the file before opening it for writing, which may not be the desired effect. If you want to open a file for reading and writing, you can put a plus sign before the > or < characters.

For example, to open a file for updating without truncating it −

[source]

To truncate the file first −

[source]

You can open a file in the append mode. In this mode, writing point will be set to the end of the file.

[source]

A double >> opens the file for appending, placing the file pointer at the end, so that you can immediately start appending information. However, you can't read from it unless you also place a plus sign in front of it −

[source]

Following is the table, which gives the possible values of different modes
[%autowidth]
|===

|Sr.No.|Entities & Definition
|1|*< or r*
Read Only Access

|2|*> or w*
Creates, Writes, and Truncates

|3|*>> or a*
Writes, Appends, and Creates

|4|*+< or r+*
Reads and Writes

|5|*+> or w+*
Reads, Writes, Creates, and Truncates

|6|*+>> or a+*
Reads, Writes, Appends, and Creates

|===


=== Sysopen Function

The *sysopen* function is similar to the main open function, except that it uses the system *open()* function, using the parameters supplied to it as the parameters for the system function −

For example, to open a file for updating, emulating the *+<filename* format from open −

[source]

Or to truncate the file before updating −

[source]

You can use O_CREAT to create a new file and O_WRONLY- to open file in write only mode and O_RDONLY - to open file in read only mode.

The *PERMS* argument specifies the file permissions for the file specified, if it has to be created. By default it takes *0x666*.

Following is the table, which gives the possible values of MODE.
[%autowidth]
|===

|Sr.No.|Entities & Definition
|1|*O_RDWR*
Read and Write

|2|*O_RDONLY*
Read Only

|3|*O_WRONLY*
Write Only

|4|*O_CREAT*
Create the file

|5|*O_APPEND*
Append the file

|6|*O_TRUNC*
Truncate the file

|7|*O_EXCL*
Stops if file already exists

|8|*O_NONBLOCK*
Non-Blocking usability

|===


=== Close Function

To close a filehandle, and therefore disassociate the filehandle from the corresponding file, you use the *close* function. This flushes the filehandle's buffers and closes the system's file descriptor.

[source]

If no FILEHANDLE is specified, then it closes the currently selected filehandle. It returns true only if it could successfully flush the buffers and close the file.

[source]

=== Reading and Writing Files

Once you have an open filehandle, you need to be able to read and write information. There are a number of different ways of reading and writing data into the file.


=== The <FILEHANDL> Operator

The main method of reading the information from an open filehandle is the <FILEHANDLE> operator. In a scalar context, it returns a single line from the filehandle. For example −

[source]

When you use the <FILEHANDLE> operator in a list context, it returns a list of lines from the specified filehandle. For example, to import all the lines from a file into an array −

[source]

=== getc Function

The getc function returns a single character from the specified FILEHANDLE, or STDIN if none is specified −

[source]

If there was an error, or the filehandle is at end of file, then undef is returned instead.


=== read Function

The read function reads a block of information from the buffered filehandle: This function is used to read binary data from the file.

[source]

The length of the data read is defined by LENGTH, and the data is placed at the start of SCALAR if no OFFSET is specified. Otherwise data is placed after OFFSET bytes in SCALAR. The function returns the number of bytes read on success, zero at end of file, or undef if there was an error.


=== print Function

For all the different methods used for reading information from filehandles, the main function for writing information back is the print function.

[source]

The print function prints the evaluated value of LIST to FILEHANDLE, or to the current output filehandle (STDOUT by default). For example −

[source]

=== Copying Files

Here is the example, which opens an existing file file1.txt and read it line by line and generate another copy file file2.txt.

[source]

=== Renaming a file

Here is an example, which shows how we can rename a file file1.txt to file2.txt. Assuming file is available in /usr/test directory.

[source]

This function *renames* takes two arguments and it just renames the existing file.


=== Deleting an Existing File

Here is an example, which shows how to delete a file file1.txt using the *unlink* function.

[source]

=== Positioning inside a File

You can use to *tell* function to know the current position of a file and *seek* function to point a particular position inside the file.


==== tell Function

The first requirement is to find your position within a file, which you do using the tell function −

[source]

This returns the position of the file pointer, in bytes, within FILEHANDLE if specified, or the current default selected filehandle if none is specified.


==== seek Function

The seek function positions the file pointer to the specified number of bytes within a file −

[source]

The function uses the fseek system function, and you have the same ability to position relative to three different points: the start, the end, and the current position. You do this by specifying a value for WHENCE.

Zero sets the positioning relative to the start of the file. For example, the line sets the file pointer to the 256th byte in the file.

[source]

=== File Information

You can test certain features very quickly within Perl using a series of test operators known collectively as -X tests. For example, to perform a quick test of the various permissions on a file, you might use a script like this −

[source]

Here is the list of features, which you can check for a file or directory −
[%autowidth]
|===

|Sr.No.|Operator & Definition
|1|*-A*
Script start time minus file last access time, in days.

|2|*-B*
Is it a binary file?

|3|*-C*
Script start time minus file last inode change time, in days.

|3|*-M*
Script start time minus file modification time, in days.

|4|*-O*
Is the file owned by the real user ID?

|5|*-R*
Is the file readable by the real user ID or real group?

|6|*-S*
Is the file a socket?

|7|*-T*
Is it a text file?

|8|*-W*
Is the file writable by the real user ID or real group?

|9|*-X*
Is the file executable by the real user ID or real group?

|10|*-b*
Is it a block special file?

|11|*-c*
Is it a character special file?

|12|*-d*
Is the file a directory?

|13|*-e*
Does the file exist?

|14|*-f*
Is it a plain file?

|15|*-g*
Does the file have the setgid bit set?

|16|*-k*
Does the file have the sticky bit set?

|17|*-l*
Is the file a symbolic link?

|18|*-o*
Is the file owned by the effective user ID?

|19|*-p*
Is the file a named pipe?

|20|*-r*
Is the file readable by the effective user or group ID?

|21|*-s*
Returns the size of the file, zero size = empty file.

|22|*-t*
Is the filehandle opened by a TTY (terminal)?

|23|*-u*
Does the file have the setuid bit set?

|24|*-w*
Is the file writable by the effective user or group ID?

|25|*-x*
Is the file executable by the effective user or group ID?

|26|*-z*
Is the file size zero?

|===


== Perl - Directories

Following are the standard functions used to play with directories.

[source]

=== Display all the Files

There are various ways to list down all the files available in a particular directory. First let's use the simple way to get and list down all the files using the *glob* operator −

[source]

Here is another example, which opens a directory and list out all the files available inside this directory.

[source]

One more example to print the list of C source files you might use is −

[source]

=== Create new Directory

You can use *mkdir* function to create a new directory. You will need to have the required permission to create a directory.

[source]

=== Remove a directory

You can use *rmdir* function to remove a directory. You will need to have the required permission to remove a directory. Additionally this directory should be empty before you try to remove it.

[source]

=== Change a Directory

You can use *chdir* function to change a directory and go to a new location. You will need to have the required permission to change a directory and go inside the new directory.

[source]

== Perl - Error Handling

The execution and the errors always go together. If you are opening a file which does not exist. then if you did not handle this situation properly then your program is considered to be of bad quality.

The program stops if an error occurs. So a proper error handling is used to handle various type of errors, which may occur during a program execution and take appropriate action instead of halting program completely.

You can identify and trap an error in a number of different ways. Its very easy to trap errors in Perl and then handling them properly. Here are few methods which can be used.


=== The if statement

The *if statement* is the obvious choice when you need to check the return value from a statement; for example −

[source]

Here variable $! returns the actual error message. Alternatively, we can reduce the statement to one line in situations where it makes sense to do so; for example −

[source]

=== The unless Function

The *unless* function is the logical opposite to if: statements can completely bypass the success status and only be executed if the expression returns false. For example −

[source]

The *unless* statement is best used when you want to raise an error or alternative only if the expression fails. The statement also makes sense when used in a single-line statement −

[source]

Here we die only if the chdir operation fails, and it reads nicely.


=== The ternary Operator

For very short tests, you can use the conditional operator *?:*

[source]

It's not quite so clear here what we are trying to achieve, but the effect is the same as using an *if* or *unless* statement. The conditional operator is best used when you want to quickly return one of the two values within an expression or statement.


=== The warn Function

The warn function just raises a warning, a message is printed to STDERR, but no further action is taken. So it is more useful if you just want to print a warning for the user and proceed with rest of the operation −

[source]

=== The die Function

The die function works just like warn, except that it also calls exit. Within a normal script, this function has the effect of immediately terminating execution. You should use this function in case it is useless to proceed if there is an error in the program −

[source]

=== Errors within Modules

There are two different situations we should be able to handle −

. Reporting an error in a module that quotes the module's filename and line number - this is useful when debugging a module, or when you specifically want to raise a module-related, rather than script-related, error.


. Reporting an error within a module that quotes the caller's information so that you can debug the line within the script that caused the error. Errors raised in this fashion are useful to the end-user, because they highlight the error in relation to the calling script's origination line.


The *warn* and *die* functions work slightly differently than you would expect when called from within a module. For example, the simple module −

[source]

When called from a script like below −

[source]

It will produce the following result −

[source]

This is more or less what you might expected, but not necessarily what you want. From a module programmer's perspective, the information is useful because it helps to point to a bug within the module itself. For an end-user, the information provided is fairly useless, and for all but the hardened programmer, it is completely pointless.

The solution for such problems is the Carp module, which provides a simplified method for reporting errors within modules that return information about the calling script. The Carp module provides four functions: carp, cluck, croak, and confess. These functions are discussed below.


=== The carp Function

The carp function is the basic equivalent of warn and prints the message to STDERR without actually exiting the script and printing the script name.

[source]

When called from a script like below −

[source]

It will produce the following result −

[source]

=== The cluck Function

The cluck function is a sort of supercharged carp, it follows the same basic principle but also prints a stack trace of all the modules that led to the function being called, including the information on the original script.

[source]

When called from a script like below −

[source]

It will produce the following result −

[source]

=== The croak Function

The *croak* function is equivalent to *die*, except that it reports the caller one level up. Like die, this function also exits the script after reporting the error to STDERR −

[source]

When called from a script like below −

[source]

It will produce the following result −

[source]

As with carp, the same basic rules apply regarding the including of line and file information according to the warn and die functions.


=== The confess Function

The *confess* function is like *cluck*; it calls die and then prints a stack trace all the way up to the origination script.

[source]

When called from a script like below −

[source]

It will produce the following result −

[source]

== Perl - Special Variables

There are some variables which have a predefined and special meaning in Perl. They are the variables that use punctuation characters after the usual variable indicator ($, @, or %), such as $_ ( explained below ).

Most of the special variables have an english like long name, e.g., Operating System Error variable $! can be written as $OS_ERROR. But if you are going to use english like names, then you would have to put one line *use English;* at the top of your program file. This guides the interpreter to pickup exact meaning of the variable.

The most commonly used special variable is $_, which contains the default input and pattern-searching string. For example, in the following lines −

[source]

When executed, this will produce the following result −

[source]

Again, let's check the same example without using $_ variable explicitly −

[source]

When executed, this will also produce the following result −

[source]

The first time the loop is executed, "hickory" is printed. The second time around, "dickory" is printed, and the third time, "doc" is printed. That's because in each iteration of the loop, the current string is placed in $_, and is used by default by print. Here are the places where Perl will assume $_ even if you don't specify it −

. Various unary functions, including functions like ord and int, as well as the all file tests (-f, -d) except for -t, which defaults to STDIN.


. Various list functions like print and unlink.


. The pattern-matching operations m//, s///, and tr/// when used without an =~ operator.


. The default iterator variable in a foreach loop if no other variable is supplied.


. The implicit iterator variable in the grep and map functions.


. The default place to put an input record when a line-input operation's result is tested by itself as the sole criterion of a while test (i.e., ). Note that outside of a while test, this will not happen.



=== Special Variable Types

Based on the usage and nature of special variables, we can categorize them in the following categories −

. Global Scalar Special Variables.

. Global Array Special Variables.

. Global Hash Special Variables.

. Global Special Filehandles.

. Global Special Constants.

. Regular Expression Special Variables.

. Filehandle Special Variables.


=== Global Scalar Special Variables

Here is the list of all the scalar special variables. We have listed corresponding english like names along with the symbolic names.
[%autowidth]
|===

|$_|The default input and pattern-searching space.
|$ARG
|$.|The current input line number of the last filehandle that was read. An explicit close on the filehandle resets the line number.
|$NR
|$/|The input record separator; newline by default. If set to the null string, it treats blank lines as delimiters.
|$RS
|$,|The output field separator for the print operator.
|$OFS
|$\|The output record separator for the print operator.
|$ORS
|$"|Like "$," except that it applies to list values interpolated into a double-quoted string (or similar interpreted string). Default is a space.
|$LIST_SEPARATOR
|$;|The subscript separator for multidimensional array emulation. Default is "\034".
|$SUBSCRIPT_SEPARATOR
|$^L|What a format outputs to perform a formfeed. Default is "\f".
|$FORMAT_FORMFEED
|$:|The current set of characters after which a string may be broken to fill continuation fields (starting with ^) in a format. Default is "\n"".
|$FORMAT_LINE_BREAK_CHARACTERS
|$^A|The current value of the write accumulator for format lines.
|$ACCUMULATOR
|$#|Contains the output format for printed numbers (deprecated).
|$OFMT
|$?|The status returned by the last pipe close, backtick (``) command, or system operator.
|$CHILD_ERROR
|$!|If used in a numeric context, yields the current value of the errno variable, identifying the last system call error. If used in a string context, yields the corresponding system error string.
|$OS_ERROR or $ERRNO
|$@|The Perl syntax error message from the last eval command.
|$EVAL_ERROR
|$$|The pid of the Perl process running this script.
|$PROCESS_ID or $PID
|$<|The real user ID (uid) of this process.
|$REAL_USER_ID or $UID
|$>|The effective user ID of this process.
|$EFFECTIVE_USER_ID or $EUID
|$(|The real group ID (gid) of this process.
|$REAL_GROUP_ID or $GID
|$)|The effective gid of this process.
|$EFFECTIVE_GROUP_ID or $EGID
|$0|Contains the name of the file containing the Perl script being executed.
|$PROGRAM_NAME
|$[|The index of the first element in an array and of the first character in a substring. Default is 0.

|$]|Returns the version plus patchlevel divided by 1000.
|$PERL_VERSION
|$^D|The current value of the debugging flags.
|$DEBUGGING
|$^E|Extended error message on some platforms.
|$EXTENDED_OS_ERROR
|$^F|The maximum system file descriptor, ordinarily 2.
|$SYSTEM_FD_MAX
|$^H|Contains internal compiler hints enabled by certain pragmatic modules.

|$^I|The current value of the inplace-edit extension. Use undef to disable inplace editing.
|$INPLACE_EDIT
|$^M|The contents of $M can be used as an emergency memory pool in case Perl dies with an out-of-memory error. Use of $M requires a special compilation of Perl. See the INSTALL document for more information.

|$^O|Contains the name of the operating system that the current Perl binary was compiled for.
|$OSNAME
|$^P|The internal flag that the debugger clears so that it doesn't debug itself.
|$PERLDB
|$^T|The time at which the script began running, in seconds since the epoch.
|$BASETIME
|$^W|The current value of the warning switch, either true or false.
|$WARNING
|$^X|The name that the Perl binary itself was executed as.
|$EXECUTABLE_NAME
|$ARGV|Contains the name of the current file when reading from <ARGV>.

|===


=== Global Array Special Variables
[%autowidth]
|===

|@ARGV|The array containing the command-line arguments intended for the script.
|@INC|The array containing the list of places to look for Perl scripts to be evaluated by the do, require, or use constructs.
|@F|The array into which the input lines are split when the -a command-line switch is given.
|===


=== Global Hash Special Variables
[%autowidth]
|===

|%INC|The hash containing entries for the filename of each file that has been included via do or require.
|%ENV|The hash containing your current environment.
|%SIG|The hash used to set signal handlers for various signals.
|===


=== Global Special Filehandles
[%autowidth]
|===

|ARGV|The special filehandle that iterates over command line filenames in @ARGV. Usually written as the null filehandle in <>.
|STDERR|The special filehandle for standard error in any package.
|STDIN|The special filehandle for standard input in any package.
|STDOUT|The special filehandle for standard output in any package.
|DATA|The special filehandle that refers to anything following the __END__ token in the file containing the script. Or, the special filehandle for anything following the __DATA__ token in a required file, as long as you're reading data in the same package __DATA__ was found in.
|_ (underscore)|The special filehandle used to cache the information from the last stat, lstat, or file test operator.
|===


=== Global Special Constants
[%autowidth]
|===

|__END__|Indicates the logical end of your program. Any following text is ignored, but may be read via the DATA filehandle.
|__FILE__|Represents the filename at the point in your program where it's used. Not interpolated into strings.
|__LINE__|Represents the current line number. Not interpolated into strings.
|__PACKAGE__|Represents the current package name at compile time, or undefined if there is no current package. Not interpolated into strings.
|===


=== Regular Expression Special Variables
[%autowidth]
|===

|$digit|Contains the text matched by the corresponding set of parentheses in the last pattern matched. For example, $1 matches whatever was contained in the first set of parentheses in the previous regular expression.
|$&|The string matched by the last successful pattern match.
|$MATCH
|$`|The string preceding whatever was matched by the last successful pattern match.
|$PREMATCH
|$'|The string following whatever was matched by the last successful pattern match.
|$POSTMATCH
|$+|The last bracket matched by the last search pattern. This is useful if you don't know which of a set of alternative patterns was matched. For example : /Version: (.*)|Revision: (.*)/ && ($rev = $+);
|$LAST_PAREN_MATCH
|===


=== Filehandle Special Variables
[%autowidth]
|===

|$||If set to nonzero, forces an fflush(3) after every write or print on the currently selected output channel.
|$OUTPUT_AUTOFLUSH
|$%|The current page number of the currently selected output channel.
|$FORMAT_PAGE_NUMBER
|$=|The current page length (printable lines) of the currently selected output channel. Default is 60.
|$FORMAT_LINES_PER_PAGE
|$-|The number of lines left on the page of the currently selected output channel.
|$FORMAT_LINES_LEFT
|$~|The name of the current report format for the currently selected output channel. Default is the name of the filehandle.
|$FORMAT_NAME
|$^|The name of the current top-of-page format for the currently selected output channel. Default is the name of the filehandle with _TOP appended.
|$FORMAT_TOP_NAME
|===


== Perl - Coding Standard

Each programmer will, of course, have his or her own preferences in regards to formatting, but there are some general guidelines that will make your programs easier to read, understand, and maintain.

The most important thing is to run your programs under the -w flag at all times. You may turn it off explicitly for particular portions of code via the no warnings pragma or the $^W variable if you must. You should also always run under use strict or know the reason why not. The use sigtrap and even use diagnostics pragmas may also prove useful.

Regarding aesthetics of code lay out, about the only thing Larry cares strongly about is that the closing curly bracket of a multi-line BLOCK should line up with the keyword that started the construct. Beyond that, he has other preferences that aren't so strong −

. 4-column indent.

. Opening curly on same line as keyword, if possible, otherwise line up.

. Space before the opening curly of a multi-line BLOCK.

. One-line BLOCK may be put on one line, including curlies.

. No space before the semicolon.

. Semicolon omitted in "short" one-line BLOCK.

. Space around most operators.

. Space around a "complex" subscript (inside brackets).

. Blank lines between chunks that do different things.

. Uncuddled elses.

. No space between function name and its opening parenthesis.

. Space after each comma.

. Long lines broken after an operator (except and and or).

. Space after last parenthesis matching on current line.

. Line up corresponding items vertically.

. Omit redundant punctuation as long as clarity doesn't suffer.

Here are some other more substantive style issues to think about: Just because you CAN do something a particular way doesn't mean that you SHOULD do it that way. Perl is designed to give you several ways to do anything, so consider picking the most readable one. For instance −

[source]

Is better than −

[source]

Because the second way hides the main point of the statement in a modifier. On the other hand,

[source]

Is better than −

[source]

Because the main point isn't whether the user typed -v or not.

Don't go through silly contortions to exit a loop at the top or the bottom, when Perl provides the last operator so you can exit in the middle. Just "outdent" it a little to make it more visible −

[source]

Let's see few more important points −

. Don't be afraid to use loop labels--they're there to enhance readability as well as to allow multilevel loop breaks. See the previous example.


. Avoid using grep() (or map()) or `backticks` in a void context, that is, when you just throw away their return values. Those functions all have return values, so use them. Otherwise use a foreach() loop or the system() function instead.


. For portability, when using features that may not be implemented on every machine, test the construct in an eval to see if it fails. If you know what version or patchlevel a particular feature was implemented, you can test $] ($PERL_VERSION in English) to see if it will be there. The Config module will also let you interrogate values determined by the Configure program when Perl was installed.


. Choose mnemonic identifiers. If you can't remember what mnemonic means, you've got a problem.


. While short identifiers like $gotit are probably ok, use underscores to separate words in longer identifiers. It is generally easier to read $var_names_like_this than $VarNamesLikeThis, especially for non-native speakers of English. It's also a simple rule that works consistently with VAR_NAMES_LIKE_THIS.


. Package names are sometimes an exception to this rule. Perl informally reserves lowercase module names for "pragma" modules like integer and strict. Other modules should begin with a capital letter and use mixed case, but probably without underscores due to limitations in primitive file systems' representations of module names as files that must fit into a few sparse bytes.


. If you have a really hairy regular expression, use the /x modifier and put in some whitespace to make it look a little less like line noise. Don't use slash as a delimiter when your regexp has slashes or backslashes.


. Always check the return codes of system calls. Good error messages should go to STDERR, include which program caused the problem, what the failed system call and arguments were, and (VERY IMPORTANT) should contain the standard system error message for what went wrong. Here's a simple but sufficient example −


[source]

. Think about reusability. Why waste brainpower on a one-shot when you might want to do something like it again? Consider generalizing your code. Consider writing a module or object class. Consider making your code run cleanly with use strict and use warnings (or -w) in effect. Consider giving away your code. Consider changing your whole world view. Consider... oh, never mind.


. Be consistent.


. Be nice.



== Perl - Regular Expressions

A regular expression is a string of characters that defines the pattern or patterns you are viewing. The syntax of regular expressions in Perl is very similar to what you will find within other regular expression.supporting programs, such as *sed*, *grep*, and *awk*.

The basic method for applying a regular expression is to use the pattern binding operators =~ and *!*~. The first operator is a test and assignment operator.

There are three regular expression operators within Perl.

. Match Regular Expression - m//

. Substitute Regular Expression - s///

. Transliterate Regular Expression - tr///

The forward slashes in each case act as delimiters for the regular expression (regex) that you are specifying. If you are comfortable with any other delimiter, then you can use in place of forward slash.


=== The Match Operator

The match operator, m//, is used to match a string or statement to a regular expression. For example, to match the character sequence "foo" against the scalar $bar, you might use a statement like this −

[source]

When above program is executed, it produces the following result −

[source]

The m// actually works in the same fashion as the q// operator series.you can use any combination of naturally matching characters to act as delimiters for the expression. For example, m{}, m(), and m>< are all valid. So above example can be re-written as follows −

[source]

You can omit m from m// if the delimiters are forward slashes, but for all other delimiters you must use the m prefix.

Note that the entire match expression, that is the expression on the left of =~ or !~ and the match operator, returns true (in a scalar context) if the expression matches. Therefore the statement −

[source]

will set $true to 1 if $foo matches the regex, or 0 if the match fails. In a list context, the match returns the contents of any grouped expressions. For example, when extracting the hours, minutes, and seconds from a time string, we can use −

[source]

=== Match Operator Modifiers

The match operator supports its own set of modifiers. The /g modifier allows for global matching. The /i modifier will make the match case insensitive. Here is the complete list of modifiers
[%autowidth]
|===

|Sr.No.|Modifier & Description
|1|*i*
Makes the match case insensitive.

|2|*m*
Specifies that if the string has newline or carriage return characters, the ^ and $ operators will now match against a newline boundary, instead of a string boundary.

|3|*o*
Evaluates the expression only once.

|4|*s*
Allows use of . to match a newline character.

|5|*x*
Allows you to use white space in the expression for clarity.

|6|*g*
Globally finds all matches.

|7|*cg*
Allows the search to continue even after a global match fails.

|===


=== Matching Only Once

There is also a simpler version of the match operator - the ?PATTERN? operator. This is basically identical to the m// operator except that it only matches once within the string you are searching between each call to reset.

For example, you can use this to get the first and last elements within a list −

[source]

When above program is executed, it produces the following result −

[source]

=== Regular Expression Variables

Regular expression variables include *$*, which contains whatever the last grouping match matched; *$&*, which contains the entire matched string; *$`*, which contains everything before the matched string; and *$'*, which contains everything after the matched string. Following code demonstrates the result −

[source]

When above program is executed, it produces the following result −

[source]

=== The Substitution Operator

The substitution operator, s///, is really just an extension of the match operator that allows you to replace the text matched with some new text. The basic form of the operator is −

[source]

The PATTERN is the regular expression for the text that we are looking for. The REPLACEMENT is a specification for the text or regular expression that we want to use to replace the found text with. For example, we can replace all occurrences of *dog* with *cat* using the following regular expression −

[source]

When above program is executed, it produces the following result −

[source]

=== Substitution Operator Modifiers

Here is the list of all the modifiers used with substitution operator.
[%autowidth]
|===

|Sr.No.|Modifier & Description
|1|*i*
Makes the match case insensitive.

|2|*m*
Specifies that if the string has newline or carriage return characters, the ^ and $ operators will now match against a newline boundary, instead of a string boundary.

|3|*o*
Evaluates the expression only once.

|4|*s*
Allows use of . to match a newline character.

|5|*x*
Allows you to use white space in the expression for clarity.

|6|*g*
Replaces all occurrences of the found expression with the replacement text.

|7|*e*
Evaluates the replacement as if it were a Perl statement, and uses its return value as the replacement text.

|===


=== The Translation Operator

Translation is similar, but not identical, to the principles of substitution, but unlike substitution, translation (or transliteration) does not use regular expressions for its search on replacement values. The translation operators are −

[source]

The translation replaces all occurrences of the characters in SEARCHLIST with the corresponding characters in REPLACEMENTLIST. For example, using the "The cat sat on the mat." string we have been using in this chapter −

[source]

When above program is executed, it produces the following result −

[source]

Standard Perl ranges can also be used, allowing you to specify ranges of characters either by letter or numerical value. To change the case of the string, you might use the following syntax in place of the *uc* function.

[source]

=== Translation Operator Modifiers

Following is the list of operators related to translation.
[%autowidth]
|===

|Sr.No.|Modifier & Description
|1|*c*
Complements SEARCHLIST.

|2|*d*
Deletes found but unreplaced characters.

|3|*s*
Squashes duplicate replaced characters.

|===

The /d modifier deletes the characters matching SEARCHLIST that do not have a corresponding entry in REPLACEMENTLIST. For example −

[source]

When above program is executed, it produces the following result −

[source]

The last modifier, /s, removes the duplicate sequences of characters that were replaced, so −

[source]

When above program is executed, it produces the following result −

[source]

=== More Complex Regular Expressions

You don't just have to match on fixed strings. In fact, you can match on just about anything you could dream of by using more complex regular expressions. Here's a quick cheat sheet −

Following table lists the regular expression syntax that is available in Python.
[%autowidth]
|===

|Sr.No.|Pattern & Description
|1|*^*
Matches beginning of line.

|2|*$*
Matches end of line.

|3|*.*
Matches any single character except newline. Using m option allows it to match newline as well.

|4|*[...]*
Matches any single character in brackets.

|5|*[^...]*
Matches any single character not in brackets.

|6|***
Matches 0 or more occurrences of preceding expression.

|7|*+*
Matches 1 or more occurrence of preceding expression.

|8|*?*
Matches 0 or 1 occurrence of preceding expression.

|9|*{ n}*
Matches exactly n number of occurrences of preceding expression.

|10|*{ n,}*
Matches n or more occurrences of preceding expression.

|11|*{ n, m}*
Matches at least n and at most m occurrences of preceding expression.

|12|*a| b*
Matches either a or b.

|13|*\w*
Matches word characters.

|14|*\W*
Matches nonword characters.

|15|*\s*
Matches whitespace. Equivalent to [\t\n\r\f].

|16|*\S*
Matches nonwhitespace.

|17|*\d*
Matches digits. Equivalent to [0-9].

|18|*\D*
Matches nondigits.

|19|*\A*
Matches beginning of string.

|20|*\Z*
Matches end of string. If a newline exists, it matches just before newline.

|21|*\z*
Matches end of string.

|22|*\G*
Matches point where last match finished.

|23|*\b*
Matches word boundaries when outside brackets. Matches backspace (0x08) when inside brackets.

|24|*\B*
Matches nonword boundaries.

|25|*\n, \t, etc.*
Matches newlines, carriage returns, tabs, etc.

|26|*\1...\9*
Matches nth grouped subexpression.

|27|*\10*
Matches nth grouped subexpression if it matched already. Otherwise refers to the octal representation of a character code.

|28|*[aeiou]*
Matches a single character in the given set

|29|*[^aeiou]*
Matches a single character outside the given set

|===

The ^ metacharacter matches the beginning of the string and the $ metasymbol matches the end of the string. Here are some brief examples.

[source]

Lets have a look at another example.

[source]

When above program is executed, it produces the following result −

[source]

=== Matching Boundaries

The *\b* matches at any word boundary, as defined by the difference between the \w class and the \W class. Because \w includes the characters for a word, and \W the opposite, this normally means the termination of a word. The *\B* assertion matches any position that is not a word boundary. For example −

[source]

=== Selecting Alternatives

The | character is just like the standard or bitwise OR within Perl. It specifies alternate matches within a regular expression or group. For example, to match "cat" or "dog" in an expression, you might use this −

[source]

You can group individual elements of an expression together in order to support complex matches. Searching for two people’s names could be achieved with two separate tests, like this −

[source]

=== Grouping Matching

From a regular-expression point of view, there is no difference between except, perhaps, that the former is slightly clearer.

[source]

However, the benefit of grouping is that it allows us to extract a sequence from a regular expression. Groupings are returned as a list in the order in which they appear in the original. For example, in the following fragment we have pulled out the hours, minutes, and seconds from a string.

[source]

As well as this direct method, matched groups are also available within the special $x variables, where x is the number of the group within the regular expression. We could therefore rewrite the preceding example as follows −

[source]

When above program is executed, it produces the following result −

[source]

When groups are used in substitution expressions, the $x syntax can be used in the replacement text. Thus, we could reformat a date string using this −

[source]

When above program is executed, it produces the following result −

[source]

=== The \G Assertion

The \G assertion allows you to continue searching from the point where the last match occurred. For example, in the following code, we have used \G so that we can search to the correct position and then extract some information, without having to create a more complex, single regular expression −

[source]

When above program is executed, it produces the following result −

[source]

The \G assertion is actually just the metasymbol equivalent of the pos function, so between regular expression calls you can continue to use pos, and even modify the value of pos (and therefore \G) by using pos as an lvalue subroutine.


=== Regular-expression Examples


==== Literal Characters
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*Perl*
Match "Perl".

|===


==== Character Classes
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*[Pp]ython*
Matches "Python" or "python"

|2|*rub[ye]*
Matches "ruby" or "rube"

|3|*[aeiou]*
Matches any one lowercase vowel

|4|*[0-9]*
Matches any digit; same as [0123456789]

|5|*[a-z]*
Matches any lowercase ASCII letter

|6|*[A-Z]*
Matches any uppercase ASCII letter

|7|*[a-zA-Z0-9]*
Matches any of the above

|8|*[^aeiou]*
Matches anything other than a lowercase vowel

|9|*[^0-9]*
Matches anything other than a digit

|===


==== Special Character Classes
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*.*
Matches any character except newline

|2|*\d*
Matches a digit: [0-9]

|3|*\D*
Matches a nondigit: [^0-9]

|4|*\s*
Matches a whitespace character: [ \t\r\n\f]

|5|*\S*
Matches nonwhitespace: [^ \t\r\n\f]

|6|*\w*
Matches a single word character: [A-Za-z0-9_]

|7|*\W*
Matches a nonword character: [^A-Za-z0-9_]

|===


==== Repetition Cases
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*ruby?*
Matches "rub" or "ruby": the y is optional

|2|*ruby**
Matches "rub" plus 0 or more ys

|3|*ruby+*
Matches "rub" plus 1 or more ys

|4|*\d{3}*
Matches exactly 3 digits

|5|*\d{3,}*
Matches 3 or more digits

|6.|*\d{3,5}*
Matches 3, 4, or 5 digits

|===


==== Nongreedy Repetition

This matches the smallest number of repetitions −
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*<.*>*
Greedy repetition: matches "<python>perl>"

|2|*<.*?>*
Nongreedy: matches "<python>" in "<python>perl>"

|===


==== Grouping with Parentheses
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*\D\d+*
No group: + repeats \d

|2|*(\D\d)+*
Grouped: + repeats \D\d pair

|3|*([Pp]ython(, )?)+*
Match "Python", "Python, python, python", etc.

|===


==== Backreferences

This matches a previously matched group again −
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*([Pp])ython&\1ails*
Matches python&pails or Python&Pails

|2|*(['"])[^\1]*\1*
Single or double-quoted string. \1 matches whatever the 1st group matched. \2 matches whatever the 2nd group matched, etc.

|===


==== Alternatives
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*python|perl*
Matches "python" or "perl"

|2|*rub(y|le))*
Matches "ruby" or "ruble"

|3|*Python(!+|\?)*
"Python" followed by one or more ! or one ?

|===


==== Anchors

This need to specify match positions.
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*^Python*
Matches "Python" at the start of a string or internal line

|2|*Python$*
Matches "Python" at the end of a string or line

|3|*\APython*
Matches "Python" at the start of a string

|4|*Python\Z*
Matches "Python" at the end of a string

|5|*\bPython\b*
Matches "Python" at a word boundary

|6|*\brub\B*
\B is nonword boundary: match "rub" in "rube" and "ruby" but not alone

|7|*Python(?=!)*
Matches "Python", if followed by an exclamation point

|8|*Python(?!!)*
Matches "Python", if not followed by an exclamation point

|===


==== Special Syntax with Parentheses
[%autowidth]
|===

|Sr.No.|Example & Description
|1|*R(?#comment)*
Matches "R". All the rest is a comment

|2|*R(?i)uby*
Case-insensitive while matching "uby"

|3|*R(?i:uby)*
Same as above

|4|*rub(?:y|le))*
Group only without creating \1 backreference

|===


== Perl - Sending Email


=== Using sendmail Utility


==== Sending a Plain Message

If you are working on Linux/Unix machine then you can simply use *sendmail* utility inside your Perl program to send email. Here is a sample script that can send an email to a given email ID. Just make sure the given path for sendmail utility is correct. This may be different for your Linux/Unix machine.

[source]

Actually, the above script is a client email script, which will draft email and submit to the server running locally on your Linux/Unix machine. This script will not be responsible for sending email to actual destination. So you have to make sure email server is properly configured and running on your machine to send email to the given email ID.


==== Sending an HTML Message

If you want to send HTML formatted email using sendmail, then you simply need to add *Content-type: text/html\n* in the header part of the email as follows −

[source]

=== Using MIME::Lite Module

If you are working on windows machine, then you will not have access on sendmail utility. But you have alternate to write your own email client using MIME:Lite perl module. You can download this module from link:http://search.cpan.org/CPAN/authors/id/Y/YV/YVES/MIME-Lite-3.01.tar.gz[MIME-Lite-3.01.tar.gz] and install it on your either machine Windows or Linux/Unix. To install it follow the simple steps −

[source]

That's it and you will have MIME::Lite module installed on your machine. Now you are ready to send your email with simple scripts explained below.


==== Sending a Plain Message

Now following is a script which will take care of sending email to the given email ID −

[source]

==== Sending an HTML Message

If you want to send HTML formatted email using sendmail, then you simply need to add *Content-type: text/html\n* in the header part of the email. Following is the script, which will take care of sending HTML formatted email −

[source]

==== Sending an Attachment

If you want to send an attachment, then following script serves the purpose −

[source]

You can attach as many files as you like in your email using attach() method.


=== Using SMTP Server

If your machine is not running an email server then you can use any other email server available at the remote location. But to use any other email server you will need to have an id, its password, URL, etc. Once you have all the required information, you simple need to provide that information in *send()* method as follows −

[source]

You can contact your email server administrator to have the above used information and if a user id and password is not already available then your administrator can create it in minutes.


== Perl - Socket Programming


=== What is a Socket?

Socket is a Berkeley UNIX mechanism of creating a virtual duplex connection between different processes. This was later ported on to every known OS enabling communication between systems across geographical location running on different OS software. If not for the socket, most of the network communication between systems would never ever have happened.

Taking a closer look; a typical computer system on a network receives and sends information as desired by the various applications running on it. This information is routed to the system, since a unique IP address is designated to it. On the system, this information is given to the relevant applications, which listen on different ports. For example an internet browser listens on port 80 for information received from the web server. Also we can write our custom applications which may listen and send/receive information on a specific port number.

For now, let's sum up that a socket is an IP address and a port, enabling connection to send and recieve data over a network.

To explain above mentioned socket concept we will take an example of Client - Server Programming using Perl. To complete a client server architecture we would have to go through the following steps −


=== To Create a Server

. Create a socket using *socket* call.


. Bind the socket to a port address using *bind* call.


. Listen to the socket at the port address using *listen* call.


. Accept client connections using *accept* call.



=== To Create a Client

. Create a socket with *socket* call.


. Connect (the socket) to the server using *connect* call.


Following diagram shows the complete sequence of the calls used by Client and Server to communicate with each other −

image::https://www.iokays.com/tutorialspoint/perl/_images/perl_socket.jpg[Perl Socket]


=== Server Side Socket Calls


==== The socket() call

The *socket()* call is the first call in establishing a network connection is creating a socket. This call has the following syntax −

[source]

The above call creates a SOCKET and other three arguments are integers which should have the following values for TCP/IP connections.

. *DOMAIN* should be PF_INET. It's probable 2 on your computer.


. *TYPE* should be SOCK_STREAM for TCP/IP connection.


. *PROTOCOL* should be *(getprotobyname('tcp'))[2]*. It is the particular protocol such as TCP to be spoken over the socket.


So socket function call issued by the server will be something like this −

[source]

==== The bind() call

The sockets created by socket() call are useless until they are bound to a hostname and a port number. Server uses the following *bind()* function to specify the port at which they will be accepting connections from the clients.

[source]

Here SOCKET is the descriptor returned by socket() call and ADDRESS is a socket address ( for TCP/IP ) containing three elements −

. The address family (For TCP/IP, that's AF_INET, probably 2 on your system).


. The port number (for example 21).


. The internet address of the computer (for example 10.12.12.168).


As the bind() is used by a server, which does not need to know its own address so the argument list looks like this −

[source]

The *or die* clause is very important because if a server dies without outstanding connections, the port won't be immediately reusable unless you use the option SO_REUSEADDR using *setsockopt()* function. Here *pack_sockaddr_in()* function is being used to pack the Port and IP address into binary format.


==== The listen() call

If this is a server program, then it is required to issue a call to *listen()* on the specified port to listen, i.e., wait for the incoming requests. This call has the following syntax −

[source]

The above call uses SOCKET descriptor returned by socket() call and QUEUESIZE is the maximum number of outstanding connection request allowed simultaneously.


==== The accept() call

If this is a server program then it is required to issue a call to the *access()* function to accept the incoming connections. This call has the following syntax −

[source]

The accept call receive SOCKET descriptor returned by socket() function and upon successful completion, a new socket descriptor NEW_SOCKET is returned for all future communication between the client and the server. If access() call fails, then it returns FLASE which is defined in Socket module which we have used initially.

Generally, accept() is used in an infinite loop. As soon as one connection arrives the server either creates a child process to deal with it or serves it himself and then goes back to listen for more connections.

[source]

Now all the calls related to server are over and let us see a call which will be required by the client.


=== Client Side Socket Calls


==== The connect() call

If you are going to prepare client program, then first you will use *socket()* call to create a socket and then you would have to use *connect()* call to connect to the server. You already have seen socket() call syntax and it will remain similar to server socket() call, but here is the syntax for *connect()* call −

[source]

Here SCOKET is the socket descriptor returned by socket() call issued by the client and ADDRESS is a socket address similar to bind call, except that it contains the IP address of the remote server.

[source]

If you connect to the server successfully, then you can start sending your commands to the server using SOCKET descriptor, otherwise your client will come out by giving an error message.


=== Client - Server Example

Following is a Perl code to implement a simple client-server program using Perl socket. Here server listens for incoming requests and once connection is established, it simply replies Smile from the server. The client reads that message and print on the screen. Let's see how it has been done, assuming we have our server and client on the same machine.


==== Script to Create a Server

[source]

To run the server in background mode issue the following command on Unix prompt −

[source]

==== Script to Create a Client

[source]

Now let's start our client at the command prompt, which will connect to the server and read message sent by the server and displays the same on the screen as follows −

[source]

*NOTE* − If you are giving the actual IP address in dot notation, then it is recommended to provide IP address in the same format in both client as well as server to avoid any confusion.


== Object Oriented Programming in PERL

We have already studied references in Perl and Perl anonymous arrays and hashes. Object Oriented concept in Perl is very much based on references and anonymous array and hashes. Let's start learning basic concepts of Object Oriented Perl.


=== Object Basics

There are three main terms, explained from the point of view of how Perl handles objects. The terms are object, class, and method.

. An *object* within Perl is merely a reference to a data type that knows what class it belongs to. The object is stored as a reference in a scalar variable. Because a scalar only contains a reference to the object, the same scalar can hold different objects in different classes.


. A *class* within Perl is a package that contains the corresponding methods required to create and manipulate objects.


. A *method* within Perl is a subroutine, defined with the package. The first argument to the method is an object reference or a package name, depending on whether the method affects the current object or the class.


Perl provides a *bless()* function, which is used to return a reference which ultimately becomes an object.


=== Defining a Class

It is very simple to define a class in Perl. A class is corresponding to a Perl Package in its simplest form. To create a class in Perl, we first build a package.

A package is a self-contained unit of user-defined variables and subroutines, which can be re-used over and over again.

Perl Packages provide a separate namespace within a Perl program which keeps subroutines and variables independent from conflicting with those in other packages.

To declare a class named Person in Perl we do −

[source]

The scope of the package definition extends to the end of the file, or until another package keyword is encountered.


=== Creating and Using Objects

To create an instance of a class (an object) we need an object constructor. This constructor is a method defined within the package. Most programmers choose to name this object constructor method new, but in Perl you can use any name.

You can use any kind of Perl variable as an object in Perl. Most Perl programmers choose either references to arrays or hashes.

Let's create our constructor for our Person class using a Perl hash reference. When creating an object, you need to supply a constructor, which is a subroutine within a package that returns an object reference. The object reference is created by blessing a reference to the package's class. For example −

[source]

Now Let us see how to create an Object.

[source]

You can use simple hash in your consturctor if you don't want to assign any value to any class variable. For example −

[source]

=== Defining Methods

Other object-oriented languages have the concept of security of data to prevent a programmer from changing an object data directly and they provide accessor methods to modify object data. Perl does not have private variables but we can still use the concept of helper methods to manipulate object data.

Lets define a helper method to get person’s first name −

[source]

Another helper function to set person’s first name −

[source]

Now lets have a look into complete example: Keep Person package and helper functions into Person.pm file.

[source]

Now let's make use of Person object in employee.pl file as follows −

[source]

When we execute above program, it produces the following result −

[source]

=== Inheritance

Object-oriented programming has very good and useful concept called inheritance. Inheritance simply means that properties and methods of a parent class will be available to the child classes. So you don't have to write the same code again and again, you can just inherit a parent class.

For example, we can have a class Employee, which inherits from Person. This is referred to as an "isa" relationship because an employee is a person. Perl has a special variable, @ISA, to help with this. @ISA governs (method) inheritance.

Following are the important points to be considered while using inheritance −

. Perl searches the class of the specified object for the given method or attribute, i.e., variable.


. Perl searches the classes defined in the object class's @ISA array.


. If no method is found in steps 1 or 2, then Perl uses an AUTOLOAD subroutine, if one is found in the @ISA tree.


. If a matching method still cannot be found, then Perl searches for the method within the UNIVERSAL class (package) that comes as part of the standard Perl library.


. If the method still has not found, then Perl gives up and raises a runtime exception.


So to create a new Employee class that will inherit methods and attributes from our Person class, we simply code as follows: Keep this code into Employee.pm.

[source]

Now Employee Class has all the methods and attributes inherited from Person class and you can use them as follows: Use main.pl file to test it −

[source]

When we execute above program, it produces the following result −

[source]

=== Method Overriding

The child class Employee inherits all the methods from the parent class Person. But if you would like to override those methods in your child class then you can do it by giving your own implementation. You can add your additional functions in child class or you can add or modify the functionality of an existing methods in its parent class. It can be done as follows: modify Employee.pm file.

[source]

Now let's again try to use Employee object in our main.pl file and execute it.

[source]

When we execute above program, it produces the following result −

[source]

=== Default Autoloading

Perl offers a feature which you would not find in any other programming languages: a default subroutine. Which means, if you define a function called *AUTOLOAD(),* then any calls to undefined subroutines will call AUTOLOAD() function automatically. The name of the missing subroutine is accessible within this subroutine as $AUTOLOAD.

Default autoloading functionality is very useful for error handling. Here is an example to implement AUTOLOAD, you can implement this function in your own way.

[source]

=== Destructors and Garbage Collection

If you have programmed using object oriented programming before, then you will be aware of the need to create a *destructor* to free the memory allocated to the object when you have finished using it. Perl does this automatically for you as soon as the object goes out of scope.

In case you want to implement your destructor, which should take care of closing files or doing some extra processing then you need to define a special method called *DESTROY*. This method will be called on the object just before Perl frees the memory allocated to it. In all other respects, the DESTROY method is just like any other method, and you can implement whatever logic you want inside this method.

A destructor method is simply a member function (subroutine) named DESTROY, which will be called automatically in following cases −

. When the object reference's variable goes out of scope.

. When the object reference's variable is undef-ed.

. When the script terminates

. When the perl interpreter terminates

For Example, you can simply put the following method DESTROY in your class −

[source]

=== Object Oriented Perl Example

Here is another nice example, which will help you to understand Object Oriented Concepts of Perl. Put this source code into any perl file and execute it.

[source]

When we execute above program, it produces the following result −

[source]

== Perl - Database Access

This chapter teaches you how to access a database inside your Perl script. Starting from Perl 5 has become very easy to write database applications using *DBI* module. DBI stands for *Database Independent Interface* for Perl, which means DBI provides an abstraction layer between the Perl code and the underlying database, allowing you to switch database implementations really easily.

The DBI is a database access module for the Perl programming language. It provides a set of methods, variables, and conventions that provide a consistent database interface, independent of the actual database being used.


=== Architecture of a DBI Application

DBI is independent of any database available in backend. You can use DBI whether you are working with Oracle, MySQL or Informix, etc. This is clear from the following architure diagram.

image::https://www.iokays.com/tutorialspoint/perl/_images/dbiarch.gif[Perl Database Module DBI Architecture]

Here DBI is responsible of taking all SQL commands through the API, (i.e., Application Programming Interface) and to dispatch them to the appropriate driver for actual execution. And finally, DBI is responsible of taking results from the driver and giving back it to the calling scritp.


=== Notation and Conventions

Throughout this chapter following notations will be used and it is recommended that you should also follow the same convention.

[source]

=== Database Connection

Assuming we are going to work with MySQL database. Before connecting to a database make sure of the followings. You can take help of our MySQL tutorial in case you are not aware about how to create database and tables in MySQL database.

. You have created a database with a name TESTDB.


. You have created a table with a name TEST_TABLE in TESTDB.


. This table is having fields FIRST_NAME, LAST_NAME, AGE, SEX and INCOME.


. User ID "testuser" and password "test123" are set to access TESTDB.


. Perl Module DBI is installed properly on your machine.


. You have gone through MySQL tutorial to understand MySQL Basics.


Following is the example of connecting with MySQL database "TESTDB" −

[source]

If a connection is established with the datasource then a Database Handle is returned and saved into $dbh for further use otherwise $dbh is set to undef value and $DBI::errstr returns an error string.


=== INSERT Operation

INSERT operation is required when you want to create some records into a table. Here we are using table TEST_TABLE to create our records. So once our database connection is established, we are ready to create records into TEST_TABLE. Following is the procedure to create single record into TEST_TABLE. You can create as many as records you like using the same concept.

Record creation takes the following steps −

. Preparing SQL statement with INSERT statement. This will be done using *prepare()* API.


. Executing SQL query to select all the results from the database. This will be done using *execute()* API.


. Releasing Stattement handle. This will be done using *finish()* API.


. If everything goes fine then *commit* this operation otherwise you can *rollback* complete transaction. Commit and Rollback are explained in next sections.


[source]

=== Using Bind Values

There may be a case when values to be entered is not given in advance. So you can use bind variables which will take the required values at run time. Perl DBI modules make use of a question mark in place of actual value and then actual values are passed through execute() API at the run time. Following is the example −

[source]

=== READ Operation

READ Operation on any databasse means to fetch some useful information from the database, i.e., one or more records from one or more tables. So once our database connection is established, we are ready to make a query into this database. Following is the procedure to query all the records having AGE greater than 20. This will take four steps −

. Preparing SQL SELECT query based on required conditions. This will be done using *prepare()* API.


. Executing SQL query to select all the results from the database. This will be done using *execute()* API.


. Fetching all the results one by one and printing those results.This will be done using *fetchrow_array()* API.


. Releasing Stattement handle. This will be done using *finish()* API.


[source]

=== Using Bind Values

There may be a case when condition is not given in advance. So you can use bind variables, which will take the required values at run time. Perl DBI modules makes use of a question mark in place of actual value and then the actual values are passed through execute() API at the run time. Following is the example −

[source]

=== UPDATE Operation

UPDATE Operation on any database means to update one or more records already available in the database tables. Following is the procedure to update all the records having SEX as 'M'. Here we will increase AGE of all the males by one year. This will take three steps −

. Preparing SQL query based on required conditions. This will be done using *prepare()* API.


. Executing SQL query to select all the results from the database. This will be done using *execute()* API.


. Releasing Stattement handle. This will be done using *finish()* API.


. If everything goes fine then *commit* this operation otherwise you can *rollback* complete transaction. See next section for commit and rollback APIs.


[source]

=== Using Bind Values

There may be a case when condition is not given in advance. So you can use bind variables, which will take required values at run time. Perl DBI modules make use of a question mark in place of actual value and then the actual values are passed through execute() API at the run time. Following is the example −

[source]

In some case you would like to set a value, which is not given in advance so you can use binding value as follows. In this example income of all males will be set to 10000.

[source]

=== DELETE Operation

DELETE operation is required when you want to delete some records from your database. Following is the procedure to delete all the records from TEST_TABLE where AGE is equal to 30. This operation will take the following steps.

. Preparing SQL query based on required conditions. This will be done using *prepare()* API.


. Executing SQL query to delete required records from the database. This will be done using *execute()* API.


. Releasing Stattement handle. This will be done using *finish()* API.


. If everything goes fine then *commit* this operation otherwise you can *rollback* complete transaction.


[source]

=== Using do Statement

If you're doing an UPDATE, INSERT, or DELETE there is no data that comes back from the database, so there is a short cut to perform this operation. You can use *do* statement to execute any of the command as follows.

[source]

*do* returns a true value if it succeeded, and a false value if it failed. Actually, if it succeeds it returns the number of affected rows. In the example it would return the number of rows that were actually deleted.


=== COMMIT Operation

Commit is the operation which gives a green signal to database to finalize the changes and after this operation no change can be reverted to its orignal position.

Here is a simple example to call *commit* API.

[source]

=== ROLLBACK Operation

If you are not satisfied with all the changes or you encounter an error in between of any operation , you can revert those changes to use *rollback* API.

Here is a simple example to call *rollback* API.

[source]

=== Begin Transaction

Many databases support transactions. This means that you can make a whole bunch of queries which would modify the databases, but none of the changes are actually made. Then at the end, you issue the special SQL query *COMMIT*, and all the changes are made simultaneously. Alternatively, you can issue the query ROLLBACK, in which case all the changes are thrown away and database remains unchanged.

Perl DBI module provided *begin_work* API, which enables transactions (by turning AutoCommit off) until the next call to commit or rollback. After the next commit or rollback, AutoCommit will automatically be turned on again.

[source]

=== AutoCommit Option

If your transactions are simple, you can save yourself the trouble of having to issue a lot of commits. When you make the connect call, you can specify an *AutoCommit* option which will perform an automatic commit operation after every successful query. Here's what it looks like −

[source]

Here AutoCommit can take value 1 or 0, where 1 means AutoCommit is on and 0 means AutoCommit is off.


=== Automatic Error Handling

When you make the connect call, you can specify a RaiseErrors option that handles errors for you automatically. When an error occurs, DBI will abort your program instead of returning a failure code. If all you want is to abort the program on an error, this can be convenient. Here's what it looks like −

[source]

Here RaiseError can take value 1 or 0.


=== Disconnecting Database

To disconnect Database connection, use *disconnect* API as follows −

[source]

The transaction behaviour of the disconnect method is, sadly, undefined. Some database systems (such as Oracle and Ingres) will automatically commit any outstanding changes, but others (such as Informix) will rollback any outstanding changes. Applications not using AutoCommit should explicitly call commit or rollback before calling disconnect.


=== Using NULL Values

Undefined values, or undef, are used to indicate NULL values. You can insert and update columns with a NULL value as you would a non-NULL value. These examples insert and update the column age with a NULL value −

[source]

Here *qq{}* is used to return a quoted string to *prepare* API. However, care must be taken when trying to use NULL values in a WHERE clause. Consider −

[source]

Binding an undef (NULL) to the placeholder will not select rows, which have a NULL age! At least for database engines that conform to the SQL standard. Refer to the SQL manual for your database engine or any SQL book for the reasons for this. To explicitly select NULLs you have to say "WHERE age IS NULL".

A common issue is to have a code fragment handle a value that could be either defined or undef (non-NULL or NULL) at runtime. A simple technique is to prepare the appropriate statement as needed, and substitute the placeholder for non-NULL cases −

[source]

=== Some Other DBI Functions


==== available_drivers

[source]

Returns a list of all available drivers by searching for DBD::* modules through the directories in @INC. By default, a warning is given if some drivers are hidden by others of the same name in earlier directories. Passing a true value for $quiet will inhibit the warning.


==== installed_drivers

[source]

Returns a list of driver name and driver handle pairs for all drivers 'installed' (loaded) into the current process. The driver name does not include the 'DBD::' prefix.


==== data_sources

[source]

Returns a list of data sources (databases) available via the named driver. If $driver is empty or undef, then the value of the DBI_DRIVER environment variable is used.


==== quote

[source]

Quote a string literal for use as a literal value in an SQL statement, by escaping any special characters (such as quotation marks) contained within the string and adding the required type of outer quotation marks.

[source]

For most database types, quote would return 'Don''t' (including the outer quotation marks). It is valid for the quote() method to return an SQL expression that evaluates to the desired string. For example −

[source]

=== Methods Common to All Handles


==== err

[source]

Returns the native database engine error code from the last driver method called. The code is typically an integer but you should not assume that. This is equivalent to $DBI::err or $h->err.


==== errstr

[source]

Returns the native database engine error message from the last DBI method called. This has the same lifespan issues as the "err" method described above. This is equivalent to $DBI::errstr or $h->errstr.


==== rows

[source]

This returns the number of rows effected by previous SQL statement and equivalent to $DBI::rows.


==== trace

[source]

DBI sports an extremely useful ability to generate runtime tracing information of what it's doing, which can be a huge time-saver when trying to track down strange problems in your DBI programs. You can use different values to set trace level. These values varies from 0 to 4. The value 0 means disable trace and 4 means generate complete trace.


=== Interpolated Statements are Prohibited

It is highly recommended not to use interpolated statements as follows −

[source]

Thus don't use interpolated statement instead use *bind value* to prepare dynamic SQL statement.


== Perl - CGI Programming


=== What is CGI ?

. A Common Gateway Interface, or CGI, is a set of standards that defines how information is exchanged between the web server and a custom script.


. The CGI specs are currently maintained by the NCSA and NCSA defines CGI is as follows −


. The Common Gateway Interface, or CGI, is a standard for external gateway programs to interface with information servers such as HTTP servers.


. The current version is CGI/1.1 and CGI/1.2 is under progress.



=== Web Browsing

To understand the concept of CGI, lets see what happens when we click a hyper link available on a web page to browse a particular web page or URL.

. Your browser contacts web server using HTTP protocol and demands for the URL, i.e., web page filename.


. Web Server will check the URL and will look for the filename requested. If web server finds that file then it sends the file back to the browser without any further execution otherwise sends an error message indicating that you have requested a wrong file.


. Web browser takes response from web server and displays either the received file content or an error message in case file is not found.


However, it is possible to set up HTTP server in such a way so that whenever a file in a certain directory is requested that file is not sent back; instead it is executed as a program, and whatever that program outputs as a result, that is sent back for your browser to display. This can be done by using a special functionality available in the web server and it is called *Common Gateway Interface* or CGI and such programs which are executed by the server to produce final result, are called CGI scripts. These CGI programs can be a PERL Script, Shell Script, C or C++ program, etc.


=== CGI Architecture Diagram

image::https://www.iokays.com/tutorialspoint/perl/_images/cgiarch.gif[CGI Architecture]


=== Web Server Support and Configuration

Before you proceed with CGI Programming, make sure that your Web Server supports CGI functionality and it is configured to handle CGI programs. All the CGI programs to be executed by the web server are kept in a pre-configured directory. This directory is called CGI directory and by convention it is named as /cgi-bin. By convention Perl CGI files will have extention as *.cgi*.


=== First CGI Program

Here is a simple link which is linked to a CGI script called link:../cgi-bin/hello.cgi[hello.cgi]. This file has been kept in */cgi-bin/* directory and it has the following content. Before running your CGI program, make sure you have change mode of file using *chmod 755 hello.cgi* UNIX command.

[source]

Now if you click *hello.cgi* link then request goes to web server who search for hello.cgi in /cgi-bin directory, execute it and whatever result got generated, web server sends that result back to the web browser, which is as follows −

[source]

This hello.cgi script is a simple Perl script which is writing its output on STDOUT file, i.e., screen. There is one important and extra feature available which is first line to be printed *Content-type:text/html\r\n\r\n*. This line is sent back to the browser and specifies the content type to be displayed on the browser screen. Now you must have undertood basic concept of CGI and you can write many complicated CGI programs using Perl. This script can interact with any other exertnal system also to exchange information such as a database, web services, or any other complex interfaces.


=== Understanding HTTP Header

The very first line *Content-type:text/html\r\n\r\n* is a part of HTTP header, which is sent to the browser so that browser can understand the incoming content from server side. All the HTTP header will be in the following form −

[source]

For Example −

[source]

There are few other important HTTP headers, which you will use frequently in your CGI Programming.
[%autowidth]
|===

|Sr.No.|Header & Description
|1|*Content-type: String*
A MIME string defining the format of the content being returned. Example is Content-type:text/html

|2|*Expires: Date String*
The date when the information becomes invalid. This should be used by the browser to decide when a page needs to be refreshed. A valid date string should be in the format 01 Jan 1998 12:00:00 GMT.

|3|*Location: URL String*
The URL that should be returned instead of the URL requested. You can use this filed to redirect a request to any other location.

|4|*Last-modified: String*
The date of last modification of the file.

|5|*Content-length: String*
The length, in bytes, of the data being returned. The browser uses this value to report the estimated download time for a file.

|6|*Set-Cookie: String*
Set the cookie passed through the string

|===


=== CGI Environment Variables

All the CGI program will have access to the following environment variables. These variables play an important role while writing any CGI program.
[%autowidth]
|===

|Sr.No.|Variables Names & Description
|1|*CONTENT_TYPE*
The data type of the content. Used when the client is sending attached content to the server. For example file upload, etc.

|2|*CONTENT_LENGTH*
The length of the query information. It's available only for POST requests

|3|*HTTP_COOKIE*
Returns the set cookies in the form of key & value pair.

|4|*HTTP_USER_AGENT*
The User-Agent request-header field contains information about the user agent originating the request. Its name of the web browser.

|5|*PATH_INFO*
The path for the CGI script.

|6|*QUERY_STRING*
The URL-encoded information that is sent with GET method request.

|7|*REMOTE_ADDR*
The IP address of the remote host making the request. This can be useful for logging or for authentication purpose.

|8|*REMOTE_HOST*
The fully qualified name of the host making the request. If this information is not available then REMOTE_ADDR can be used to get IR address.

|9|*REQUEST_METHOD*
The method used to make the request. The most common methods are GET and POST.

|10|*SCRIPT_FILENAME*
The full path to the CGI script.

|11|*SCRIPT_NAME*
The name of the CGI script.

|12|*SERVER_NAME*
The server's hostname or IP Address.

|13|*SERVER_SOFTWARE*
The name and version of the software the server is running.

|===

Here is a small CGI program to list down all the CGI variables supported by your Web server. Click this link to see the result link:https://www.tutorialspoint.com/cgi-bin/get_env.cgi[Get Environment]

[source]

=== Raise a "File Download" Dialog Box?

Sometime it is desired that you want to give option where a user will click a link and it will pop up a "File Download" dialogue box to the user instead of displaying actual content. This is very easy and will be achived through HTTP header.

This HTTP header will be different from the header mentioned in previous section. For example, if you want to make a *FileName* file downloadable from a given link then it's syntax will be as follows −

[source]

=== GET and POST Methods

You must have come across many situations when you need to pass some information from your browser to the web server and ultimately to your CGI Program handling your requests. Most frequently browser uses two methods to pass this information to the web server. These methods are *GET* Method and *POST* Method. Let's check them one by one.


=== Passing Information using GET Method

The GET method sends the encoded user information appended to the page URL itself. The page and the encoded information are separated by the ? character as follows −

[source]

The GET method is the defualt method to pass information from a browser to the web server and it produces a long string that appears in your browser's Location:box. You should never use GET method if you have password or other sensitive information to pass to the server. The GET method has size limitation: only 1024 characters can be passed in a request string.

This information is passed using *QUERY_STRING* header and will be accessible in your CGI Program through QUERY_STRING environment variable which you can parse and use in your CGI program.

You can pass information by simply concatenating key and value pairs alongwith any URL or you can use HTML <FORM> tags to pass information using GET method.


=== Simple URL Example: Get Method

Here is a simple URL which will pass two values to hello_get.cgi program using GET method.

Below is *hello_get.cgi* script to handle input given by web browser.

[source]

=== Simple FORM Example: GET Method

Here is a simple example, which passes two values using HTML FORM and submit button. We are going to use the same CGI script hello_get.cgi to handle this input.

[source]

Here is the actual output of the above form coding. Now you can enter First and Last Name and then click submit button to see the result.


=== Passing Information using POST Method

A more reliable method of passing information to a CGI program is the *POST* method. This packages the information in exactly the same way as GET methods, but instead of sending it as a text string after a *?* in the URL, it sends it as a separate message as a part of HTTP header. Web server provides this message to the CGI script in the form of the standard input.

Below is the modified *hello_post.cgi* script to handle input given by the web browser. This script will handle GET as well as POST method.

[source]

Let us take again same examle as above, which passes two values using HTML FORM and submit button. We are going to use CGI script hello_post.cgi to handle this input.

[source]

Here is the actual output of the above form coding, You enter First and Last Name and then click submit button to see the result.


=== Passing Checkbox Data to CGI Program

Checkboxes are used when more than one option is required to be selected. Here is an example HTML code for a form with two checkboxes.

[source]

The result of this code is the following form −

Below is *checkbox.cgi* script to handle input given by web browser for radio button.

[source]

=== Passing Radio Button Data to CGI Program

Radio Buttons are used when only one option is required to be selected. Here is an example HTML code for a form with two radio button −

[source]

The result of this code is the following form −

Below is *radiobutton.cgi* script to handle input given by the web browser for radio button.

[source]

=== Passing Text Area Data to CGI Program

A textarea element is used when multiline text has to be passed to the CGI Program. Here is an example HTML code for a form with a TEXTAREA box −

[source]

The result of this code is the following form −

Below is the *textarea.cgi* script to handle input given by the web browser.

[source]

=== Passing Drop Down Box Data to CGI Program

A drop down box is used when we have many options available but only one or two will be selected. Here is example HTML code for a form with one drop down box

[source]

The result of this code is the following form −

Below is the *dropdown.cgi* script to handle input given by web browser.

[source]

=== Using Cookies in CGI

HTTP protocol is a stateless protocol. But for a commercial website it is required to maintain session information among different pages. For example one user registration ends after transactions which spans through many pages. But how to maintain user's session information across all the web pages?

In many situations, using cookies is the most efficient method of remembering and tracking preferences, purchases, commissions, and other information required for better visitor experience or site statistics.


=== How It Works

Your server sends some data to the visitor's browser in the form of a cookie. The browser may accept the cookie. If it does, it is stored as a plain text record on the visitor's hard drive. Now, when the visitor arrives at another page on your site, the cookie is available for retrieval. Once retrieved, your server knows/remembers what was stored.

Cookies are a plain text data record of 5 variable-length fields −

. *Expires* − The date the cookie will expire. If this is blank, the cookie will expire when the visitor quits the browser.


. *Domain* − The domain name of your site.


. *Path* − The path to the directory or web page that set the cookie. This may be blank if you want to retrieve the cookie from any directory or page.


. *Secure* − If this field contains the word "secure" then the cookie may only be retrieved with a secure server. If this field is blank, no such restriction exists.


. *Name = Value* − Cookies are set and retrviewed in the form of key and value pairs.



=== Setting up Cookies

It is very easy to send cookies to browser. These cookies will be sent along with the HTTP Header. Assuming you want to set UserID and Password as cookies. So it will be done as follows −

[source]

Here we used *Set-Cookie* HTTP header to set cookies. It is optional to set cookies attributes like Expires, Domain, and Path. It is important to note that cookies are set before sending magic line *"Content-type:text/html\r\n\r\n*.


=== Retrieving Cookies

It is very easy to retrieve all the set cookies. Cookies are stored in CGI environment variable HTTP_COOKIE and they will have following form.

[source]

Here is an example of how to retrieve cookies.

[source]

This will produce the following result, provided above cookies have been set before calling retrieval cookies script.

[source]

=== CGI Modules and Libraries

You will find many built-in modules over the internet which provides you direct functions to use in your CGI program. Following are the important once.

. link:http://search.cpan.org/src/LDS/CGI.pm-3.25/cgi_docs.html[CGI Module]


. link:http://cgi-lib.berkeley.edu/[Berkeley cgi-lib.pl]



== Perl - Packages and Modules


=== What are Packages?

The *package* statement switches the current naming context to a specified namespace (symbol table). Thus −

. A package is a collection of code which lives in its own namespace.


. A namespace is a named collection of unique variable names (also called a symbol table).


. Namespaces prevent variable name collisions between packages.


. Packages enable the construction of modules which, when used, won't clobber variables and functions outside of the modules's own namespace.


. The package stays in effect until either another package statement is invoked, or until the end of the current block or file.


. You can explicitly refer to variables within a package using the *::* package qualifier.


Following is an example having main and Foo packages in a file. Here special variable __PACKAGE__ has been used to print the package name.

[source]

When above code is executed, it produces the following result −

[source]

=== BEGIN and END Blocks

You may define any number of code blocks named BEGIN and END, which act as constructors and destructors respectively.

[source]

. Every *BEGIN* block is executed after the perl script is loaded and compiled but before any other statement is executed.


. Every END block is executed just before the perl interpreter exits.


. The BEGIN and END blocks are particularly useful when creating Perl modules.


Following example shows its usage −

[source]

When above code is executed, it produces the following result −

[source]

=== What are Perl Modules?

A Perl module is a reusable package defined in a library file whose name is the same as the name of the package with a .pm as extension.

A Perl module file called *Foo.pm* might contain statements like this.

[source]

Few important points about Perl modules

. The functions *require* and *use* will load a module.


. Both use the list of search paths in *@INC* to find the module.


. Both functions *require* and *use* call the *eval* function to process the code.


. The *1;* at the bottom causes eval to evaluate to TRUE (and thus not fail).



=== The Require Function

A module can be loaded by calling the *require* function as follows −

[source]

You must have noticed that the subroutine names must be fully qualified to call them. It would be nice to enable the subroutine *bar* and *blat* to be imported into our own namespace so we wouldn't have to use the Foo:: qualifier.


=== The Use Function

A module can be loaded by calling the *use* function.

[source]

Notice that we didn't have to fully qualify the package's function names. The *use* function will export a list of symbols from a module given a few added statements inside a module.

[source]

Then, provide a list of symbols (scalars, lists, hashes, subroutines, etc) by filling the list variable named *@EXPORT*: For Example −

[source]

=== Create the Perl Module Tree

When you are ready to ship your Perl module, then there is standard way of creating a Perl Module Tree. This is done using *h2xs* utility. This utility comes along with Perl. Here is the syntax to use h2xs −

[source]

For example, if your module is available in *Person.pm* file, then simply issue the following command −

[source]

This will produce the following result −

[source]

Here is the descritpion of these options −

. *-A* omits the Autoloader code (best used by modules that define a large number of infrequently used subroutines).


. *-X* omits XS elements (eXternal Subroutine, where eXternal means external to Perl, i.e., C).


. *-n* specifies the name of the module.


So above command creates the following structure inside Person directory. Actual result is shown above.

. Changes

. Makefile.PL

. MANIFEST (contains the list of all files in the package)

. README

. t/ (test files)

. lib/ ( Actual source code goes here

So finally, you *tar* this directory structure into a file Person.tar.gz and you can ship it. You will have to update README file with the proper instructions. You can also provide some test examples files in t directory.


=== Installing Perl Module

Download a Perl module in the form tar.gz file. Use the following sequence to install any Perl Module *Person.pm* which has been downloaded in as *Person.tar.gz* file.

[source]

The Perl interpreter has a list of directories in which it searches for modules (global array @INC).


== Perl - Process Management

You can use Perl in various ways to create new processes as per your requirements. This tutorial will list down few important and most frequently used methods of creating and managing Perl processes.

. You can use special variables *$$* or *$PROCESS_ID* to get current process ID.


. Every process created using any of the mentioned methods, maintains its own virtual environment with-in *%ENV* variable.


. The *exit()* function always exits just the child process which executes this function and the main process as a whole will not exit unless all running child-processes have exited.


. All open handles are dup()-ed in child-processes, so that closing any handles in one process does not affect the others.



=== Backstick Operator

This simplest way of executing any Unix command is by using backstick operator. You simply put your command inside the backstick operator, which will result in execution of the command and returns its result which can be stored as follows −

[source]

When the above code is executed, it lists down all the files and directories available in the current directory −

[source]

=== The system() Function

You can also use *system()* function to execute any Unix command, whose output will go to the output of the perl script. By default, it is the screen, i.e., STDOUT, but you can redirect it to any file by using redirection operator > −

[source]

When above code is executed, it lists down all the files and directories available in the current directory −

[source]

Be careful when your command contains shell environmental variables like $PATH or $HOME. Try following three scenarios −

[source]

When above code is executed, it produces the following result depending on what is set in shell variable $PATH.

[source]

=== The fork() Function

Perl provides a *fork()* function that corresponds to the Unix system call of the same name. On most Unix-like platforms where the fork() system call is available, Perl's fork() simply calls it. On some platforms such as Windows where the fork() system call is not available, Perl can be built to emulate fork() at the interpreter level.

The fork() function is used to clone a current process. This call create a new process running the same program at the same point. It returns the child pid to the parent process, 0 to the child process, or undef if the fork is unsuccessful.

You can use *exec()* function within a process to launch the requested executable, which will be executed in a separate process area and exec() will wait for it to complete before exiting with the same exit status as that process.

[source]

When above code is executed, it produces the following result −

[source]

The *wait()* and *waitpid()* can be passed as a pseudo-process ID returned by fork(). These calls will properly wait for the termination of the pseudo-process and return its status. If you fork without ever waiting on your children using *waitpid()* function, you will accumulate zombies. On Unix systems, you can avoid this by setting $SIG{CHLD} to "IGNORE" as follows −

[source]

When above code is executed, it produces the following result −

[source]

=== The kill() Function

Perl *kill('KILL', (Process List))* function can be used to terminate a pseudo-process by passing it the ID returned by fork().

Note that using kill('KILL', (Process List)) on a pseudo-process() may typically cause memory leaks, because the thread that implements the pseudo-process does not get a chance to clean up its resources.

You can use *kill()* function to send any other signal to target processes, for example following will send SIGINT to a process IDs 104 and 102 −

[source]

== Perl - Embedded Documentation

You can embed Pod (Plain Old Text) documentation in your Perl modules and scripts. Following is the rule to use embedded documentation in your Perl Code −

Start your documentation with an empty line, a =*head1* command at the beginning, and end it with a =*cut*

Perl will ignore the Pod text you entered in the code. Following is a simple example of using embedded documentation inside your Perl code −

[source]

When above code is executed, it produces the following result −

[source]

If you're going to put your Pod at the end of the file, and you're using an __END__ or __DATA__ cut mark, make sure to put an empty line there before the first Pod command as follows, otherwise without an empty line before the =*head1*, many translators wouldn't have recognized the =*head1* as starting a Pod block.

[source]

When above code is executed, it produces the following result −

[source]

Let's take one more example for the same code without reading DATA part −

[source]

When above code is executed, it produces the following result −

[source]

=== What is POD?

Pod is a simple-to-use markup language used for writing documentation for Perl, Perl programs, and Perl modules. There are various translators available for converting Pod to various formats like plain text, HTML, man pages, and more. Pod markup consists of three basic kinds of paragraphs −

. *Ordinary Paragraph* − You can use formatting codes in ordinary paragraphs, for bold, italic, code-style , hyperlinks, and more.


. *Verbatim Paragraph* − Verbatim paragraphs are usually used for presenting a codeblock or other text which does not require any special parsing or formatting, and which shouldn't be wrapped.


. *Command Paragraph* − A command paragraph is used for special treatment of whole chunks of text, usually as headings or parts of lists. All command paragraphs start with =, followed by an identifier, followed by arbitrary text that the command can use however it pleases. Currently recognized commands are −


[source]

=== POD Examples

Consider the following POD −

[source]

You can use *pod2html* utility available on Linux to convert above POD into HTML, so it will produce following result −


== Copyright 2005 [TUTORIALSOPOINT].

Next, consider the following example −

[source]

When you convert the above POD into HTML using pod2html, it will produce the following result −

[source]

== Perl - Functions References

Here is the list of all the important functions supported by standard Perl.

. link:../perl/perl_abs.html[abs] - absolute value function


. link:../perl/perl_accept.html[accept] - accept an incoming socket connect


. link:../perl/perl_alarm.html[alarm] - schedule a SIGALRM


. link:../perl/perl_atan2.html[atan2] - arctangent of Y/X in the range -PI to PI


. link:../perl/perl_bind.html[bind] - binds an address to a socket


. link:../perl/perl_binmode.html[binmode] - prepare binary files for I/O


. link:../perl/perl_bless.html[bless] - create an object


. link:../perl/perl_caller.html[caller] - get context of the current subroutine call


. link:../perl/perl_chdir.html[chdir] - change your current working directory


. link:../perl/perl_chmod.html[chmod] - changes the permissions on a list of files


. link:../perl/perl_chomp.html[chomp] - remove a trailing record separator from a string


. link:../perl/perl_chop.html[chop] - remove the last character from a string


. link:../perl/perl_chown.html[chown] - change the owership on a list of files


. link:../perl/perl_chr.html[chr] - get character this number represents


. link:../perl/perl_chroot.html[chroot] - make directory new root for path lookups


. link:../perl/perl_close.html[close] - close file (or pipe or socket) handle


. link:../perl/perl_closedir.html[closedir] - close directory handle


. link:../perl/perl_connect.html[connect] - connect to a remote socket


. link:../perl/perl_continue.html[continue] - optional trailing block in a while or foreach


. link:../perl/perl_cos.html[cos] - cosine function


. link:../perl/perl_crypt.html[crypt] - one-way passwd-style encryption


. link:../perl/perl_dbmclose.html[dbmclose] - breaks binding on a tied dbm file


. link:../perl/perl_dbmopen.html[dbmopen] - create binding on a tied dbm file


. link:../perl/perl_defined.html[defined] - test whether a value, variable, or function is defined or not


. link:../perl/perl_delete.html[delete] - deletes a value from a hash


. link:../perl/perl_die.html[die] - raise an exception or bail out


. link:../perl/perl_do.html[do] - turn a BLOCK into a TERM


. link:../perl/perl_dump.html[dump] - create an immediate core dump


. link:../perl/perl_each.html[each] - retrieve the next key/value pair from a hash


. link:../perl/perl_endgrent.html[endgrent] - be done using group file


. link:../perl/perl_endhostent.html[endhostent] - be done using hosts file


. link:../perl/perl_endnetent.html[endnetent] - be done using networks file


. link:../perl/perl_endprotoent.html[endprotoent] - be done using protocols file


. link:../perl/perl_endpwent.html[endpwent] - be done using passwd file


. link:../perl/perl_endservent.html[endservent] - be done using services file


. link:../perl/perl_eof.html[eof] - test a filehandle for its end


. link:../perl/perl_eval.html[eval] - catch exceptions or compile and run code


. link:../perl/perl_exec.html[exec] - abandon this program to run another


. link:../perl/perl_exists.html[exists] - test whether a hash key is present


. link:../perl/perl_exit.html[exit] - terminate this program


. link:../perl/perl_exp.html[exp] - raise I
to a power


. link:../perl/perl_fcntl.html[fcntl] - file control system call


. link:../perl/perl_fileno.html[fileno] - return file descriptor from filehandle


. link:../perl/perl_flock.html[flock] - lock an entire file with an advisory lock


. link:../perl/perl_fork.html[fork] - create a new process just like this one


. link:../perl/perl_format.html[format] - declare a picture format with use by the write() function


. link:../perl/perl_formline.html[formline] - internal function used for formats


. link:../perl/perl_getc.html[getc] - get the next character from the filehandle


. link:../perl/perl_getgrent.html[getgrent] - get next group record


. link:../perl/perl_getgrgid.html[getgrgid] - get group record given group user ID


. link:../perl/perl_getgrnam.html[getgrnam] - get group record given group name


. link:../perl/perl_gethostbyaddr.html[gethostbyaddr] - get host record given its address


. link:../perl/perl_gethostbyname.html[gethostbyname] - get host record given name


. link:../perl/perl_gethostent.html[gethostent] - get next hosts record


. link:../perl/perl_getlogin.html[getlogin] - return who logged in at this tty


. link:../perl/perl_getnetbyaddr.html[getnetbyaddr] - get network record given its address


. link:../perl/perl_getnetbyname.html[getnetbyname] - get networks record given name


. link:../perl/perl_getnetent.html[getnetent] - get next networks record


. link:../perl/perl_getpeername.html[getpeername] - find the other end of a socket connection


. link:../perl/perl_getpgrp.html[getpgrp] - get process group


. link:../perl/perl_getppid.html[getppid] - get parent process ID


. link:../perl/perl_getpriority.html[getpriority] - get current nice value


. link:../perl/perl_getprotobyname.html[getprotobyname] - get protocol record given name


. link:../perl/perl_getprotobynumber.html[getprotobynumber] - get protocol record numeric protocol


. link:../perl/perl_getprotoent.html[getprotoent] - get next protocols record


. link:../perl/perl_getpwent.html[getpwent] - get next passwd record


. link:../perl/perl_getpwnam.html[getpwnam] - get passwd record given user login name


. link:../perl/perl_getpwuid.html[getpwuid] - get passwd record given user ID


. link:../perl/perl_getservbyname.html[getservbyname] - get services record given its name


. link:../perl/perl_getservbyport.html[getservbyport] - get services record given numeric port


. link:../perl/perl_getservent.html[getservent] - get next services record


. link:../perl/perl_getsockname.html[getsockname] - retrieve the sockaddr for a given socket


. link:../perl/perl_getsockopt.html[getsockopt] - get socket options on a given socket


. link:../perl/perl_glob.html[glob] - expand filenames using wildcards


. link:../perl/perl_gmtime.html[gmtime] - convert UNIX time into record or string using Greenwich time format.


. link:../perl/perl_goto.html[goto] - create spaghetti code


. link:../perl/perl_grep.html[grep] - locate elements in a list test true against a given criterion


. link:../perl/perl_hex.html[hex] - convert a string to a hexadecimal number


. link:../perl/perl_import.html[import] - patch a module's namespace into your own


. link:../perl/perl_index.html[index] - find a substring within a string


. link:../perl/perl_int.html[int] - get the integer portion of a number


. link:../perl/perl_ioctl.html[ioctl] - system-dependent device control system call


. link:../perl/perl_join.html[join] - join a list into a string using a separator


. link:../perl/perl_keys.html[keys] - retrieve list of indices from a hash


. link:../perl/perl_kill.html[kill] - send a signal to a process or process group


. link:../perl/perl_last.html[last] - exit a block prematurely


. link:../perl/perl_lc.html[lc] - return lower-case version of a string


. link:../perl/perl_lcfirst.html[lcfirst] - return a string with just the next letter in lower case


. link:../perl/perl_length.html[length] - return the number of bytes in a string


. link:../perl/perl_link.html[link] - create a hard link in the filesytem


. link:../perl/perl_listen.html[listen] - register your socket as a server


. link:../perl/perl_local.html[local] - create a temporary value for a global variable (dynamic scoping)


. link:../perl/perl_localtime.html[localtime] - convert UNIX time into record or string using local time


. link:../perl/perl_lock.html[lock] - get a thread lock on a variable, subroutine, or method


. link:../perl/perl_log.html[log] - retrieve the natural logarithm for a number


. link:../perl/perl_lstat.html[lstat] - stat a symbolic link


. link:../perl/perl_m.html[m] - match a string with a regular expression pattern


. link:../perl/perl_map.html[map] - apply a change to a list to get back a new list with the changes


. link:../perl/perl_mkdir.html[mkdir] - create a directory


. link:../perl/perl_msgctl.html[msgctl] - SysV IPC message control operations


. link:../perl/perl_msgget.html[msgget] - get SysV IPC message queue


. link:../perl/perl_msgrcv.html[msgrcv] - receive a SysV IPC message from a message queue


. link:../perl/perl_msgsnd.html[msgsnd] - send a SysV IPC message to a message queue


. link:../perl/perl_my.html[my] - declare and assign a local variable (lexical scoping)


. link:../perl/perl_next.html[next] - iterate a block prematurely


. link:../perl/perl_no.html[no] - unimport some module symbols or semantics at compile time


. link:../perl/perl_oct.html[oct] - convert a string to an octal number


. link:../perl/perl_open.html[open] - open a file, pipe, or descriptor


. link:../perl/perl_opendir.html[opendir] - open a directory


. link:../perl/perl_ord.html[ord] - find a character's numeric representation


. link:../perl/perl_our.html[our] - declare and assign a package variable (lexical scoping)


. link:../perl/perl_pack.html[pack] - convert a list into a binary representation


. link:../perl/perl_package.html[package] - declare a separate global namespace


. link:../perl/perl_pipe.html[pipe] - open a pair of connected filehandles


. link:../perl/perl_pop.html[pop] - remove the last element from an array and return it


. link:../perl/perl_pos.html[pos] - find or set the offset for the last/next m//g search


. link:../perl/perl_print.html[print] - output a list to a filehandle


. link:../perl/perl_printf.html[printf] - output a formatted list to a filehandle


. link:../perl/perl_prototype.html[prototype] - get the prototype (if any) of a subroutine


. link:../perl/perl_push.html[push] - append one or more elements to an array


. link:../perl/perl_q.html[q] - singly quote a string


. link:../perl/perl_qq.html[qq] - doubly quote a string


. link:../perl/perl_qr.html[qr] - Compile pattern


. link:../perl/perl_quotemeta.html[quotemeta] - quote regular expression magic characters


. link:../perl/perl_qw.html[qw] - quote a list of words


. link:../perl/perl_qx.html[qx] - backquote quote a string


. link:../perl/perl_rand.html[rand] - retrieve the next pseudorandom number


. link:../perl/perl_read.html[read] - fixed-length buffered input from a filehandle


. link:../perl/perl_readdir.html[readdir] - get a directory from a directory handle


. link:../perl/perl_readline.html[readline] - fetch a record from a file


. link:../perl/perl_readlink.html[readlink] - determine where a symbolic link is pointing


. link:../perl/perl_readpipe.html[readpipe] - execute a system command and collect standard output


. link:../perl/perl_recv.html[recv] - receive a message over a Socket


. link:../perl/perl_redo.html[redo] - start this loop iteration over again


. link:../perl/perl_ref.html[ref] - find out the type of thing being referenced


. link:../perl/perl_rename.html[rename] - change a filename


. link:../perl/perl_require.html[require] - load in external functions from a library at runtime


. link:../perl/perl_reset.html[reset] - clear all variables of a given name


. link:../perl/perl_return.html[return] - get out of a function early


. link:../perl/perl_reverse.html[reverse] - flip a string or a list


. link:../perl/perl_rewinddir.html[rewinddir] - reset directory handle


. link:../perl/perl_rindex.html[rindex] - right-to-left substring search


. link:../perl/perl_rmdir.html[rmdir] - remove a directory


. link:../perl/perl_s.html[s] - replace a pattern with a string


. link:../perl/perl_scalar.html[scalar] - force a scalar context


. link:../perl/perl_seek.html[seek] - reposition file pointer for random-access I/O


. link:../perl/perl_seekdir.html[seekdir] - reposition directory pointer


. link:../perl/perl_select.html[select] - reset default output or do I/O multiplexing


. link:../perl/perl_semctl.html[semctl] - SysV semaphore control operations


. link:../perl/perl_semget.html[semget] - get set of SysV semaphores


. link:../perl/perl_semop.html[semop] - SysV semaphore operations


. link:../perl/perl_send.html[send] - send a message over a socket


. link:../perl/perl_setgrent.html[setgrent] - prepare group file for use


. link:../perl/perl_sethostent.html[sethostent] - prepare hosts file for use


. link:../perl/perl_setnetent.html[setnetent] - prepare networks file for use


. link:../perl/perl_setpgrp.html[setpgrp] - set the process group of a process


. link:../perl/perl_setpriority.html[setpriority] - set a process's nice value


. link:../perl/perl_setprotoent.html[setprotoent] - prepare protocols file for use


. link:../perl/perl_setpwent.html[setpwent] - prepare passwd file for use


. link:../perl/perl_setservent.html[setservent] - prepare services file for use


. link:../perl/perl_setsockopt.html[setsockopt] - set some socket options


. link:../perl/perl_shift.html[shift] - remove the first element of an array, and return it


. link:../perl/perl_shmctl.html[shmctl] - SysV shared memory operations


. link:../perl/perl_shmget.html[shmget] - get SysV shared memory segment identifier


. link:../perl/perl_shmread.html[shmread] - read SysV shared memory


. link:../perl/perl_shmwrite.html[shmwrite] - write SysV shared memory


. link:../perl/perl_shutdown.html[shutdown] - close down just half of a socket connection


. link:../perl/perl_sin.html[sin] - return the sine of a number


. link:../perl/perl_sleep.html[sleep] - block for some number of seconds


. link:../perl/perl_socket.html[socket] - create a socket


. link:../perl/perl_socketpair.html[socketpair] - create a pair of sockets


. link:../perl/perl_sort.html[sort] - sort a list of values


. link:../perl/perl_splice.html[splice] - add or remove elements anywhere in an array


. link:../perl/perl_split.html[split] - split up a string using a regexp delimiter


. link:../perl/perl_sprintf.html[sprintf] - formatted print into a string


. link:../perl/perl_sqrt.html[sqrt] - square root function


. link:../perl/perl_srand.html[srand] - seed the random number generator


. link:../perl/perl_stat.html[stat] - get a file's status information


. link:../perl/perl_study.html[study] - optimize input data for repeated searches


. link:../perl/perl_sub.html[sub] - declare a subroutine, possibly anonymously


. link:../perl/perl_substr.html[substr] - get or alter a portion of a stirng


. link:../perl/perl_symlink.html[symlink] - create a symbolic link to a file


. link:../perl/perl_syscall.html[syscall] - execute an arbitrary system call


. link:../perl/perl_sysopen.html[sysopen] - open a file, pipe, or descriptor


. link:../perl/perl_sysread.html[sysread] - fixed-length unbuffered input from a filehandle


. link:../perl/perl_sysseek.html[sysseek] - position I/O pointer on handle used with sysread and syswrite


. link:../perl/perl_system.html[system] - run a separate program


. link:../perl/perl_syswrite.html[syswrite] - fixed-length unbuffered output to a filehandle


. link:../perl/perl_tell.html[tell] - get current seekpointer on a filehandle


. link:../perl/perl_telldir.html[telldir] - get current seekpointer on a directory handle


. link:../perl/perl_tie.html[tie] - bind a variable to an object class


. link:../perl/perl_tied.html[tied] - get a reference to the object underlying a tied variable


. link:../perl/perl_time.html[time] - return number of seconds since 1970


. link:../perl/perl_times.html[times] - return elapsed time for self and child processes


. link:../perl/perl_tr.html[tr] - transliterate a string


. link:../perl/perl_truncate.html[truncate] - shorten a file


. link:../perl/perl_uc.html[uc] - return upper-case version of a string


. link:../perl/perl_ucfirst.html[ucfirst] - return a string with just the next letter in upper case


. link:../perl/perl_umask.html[umask] - set file creation mode mask


. link:../perl/perl_undef.html[undef] - remove a variable or function definition


. link:../perl/perl_unlink.html[unlink] - remove one link to a file


. link:../perl/perl_unpack.html[unpack] - convert binary structure into normal perl variables


. link:../perl/perl_unshift.html[unshift] - prepend more elements to the beginning of a list


. link:../perl/perl_untie.html[untie] - break a tie binding to a variable


. link:../perl/perl_use.html[use] - load in a module at compile time


. link:../perl/perl_utime.html[utime] - set a file's last access and modify times


. link:../perl/perl_values.html[values] - return a list of the values in a hash


. link:../perl/perl_vec.html[vec] - test or set particular bits in a string


. link:../perl/perl_wait.html[wait] - wait for any child process to die


. link:../perl/perl_waitpid.html[waitpid] - wait for a particular child process to die


. link:../perl/perl_wantarray.html[wantarray] - get void vs scalar vs list context of current subroutine call


. link:../perl/perl_warn.html[warn] - print debugging info


. link:../perl/perl_write.html[write] - print a picture record


. link:../perl/perl_-X.html[-X] - a file test (-r, -x, etc)


. link:../perl/perl_y.html[y] - transliterate a string