Perl Programming

Scripting and Automation

Copyright © 2024 by HiTeX Press

All rights reserved. No part of this publication may be reproduced, distributed, or transmitted in any form or by any means, including photocopying, recording, or other electronic or mechanical methods, without the prior written permission of the publisher, except in the case of brief quotations embodied in critical reviews and certain other noncommercial uses permitted by copyright law.

Contents

1 Introduction to Perl

1.1 What is Perl?

1.2 History of Perl

1.3 Installing Perl

1.4 Running a Perl Script

1.5 Basic Structure of a Perl Program

1.6 The Perl Interpreter

1.7 Using the Perl Documentation

1.8 Getting Help with Perl

1.9 First Perl Program

1.10 Common Use Cases of Perl

2 Basic Perl Syntax

2.1 Perl Statements

2.2 Comments in Perl

2.3 Whitespace and Formatting

2.4 Data Types

2.5 Operators

2.6 Input and Output

2.7 String Interpolation

2.8 Escape Sequences

2.9 Perl Contexts

2.10 Basic Debugging Techniques

3 Variables and Data Types

3.1 Introduction to Variables

3.2 Scalar Variables

3.3 Array Variables

3.4 Hash Variables

3.5 Variable Interpolation

3.6 Context and Data Types

3.7 Variable Scope

3.8 Special Variables

3.9 Typeglobs

3.10 Constant Variables

4 Control Structures

4.1 Introduction to Control Structures

4.2 Conditional Statements

4.3 if-else Statements

4.4 unless Statements

4.5 Switch Statements

4.6 Loops in Perl

4.7 for Loops

4.8 foreach Loops

4.9 while Loops

4.10 until Loops

4.11 Loop Control Keywords

4.12 Nested Control Structures

5 Subroutines and Functions

5.1 Introduction to Subroutines

5.2 Defining a Subroutine

5.3 Calling a Subroutine

5.4 Passing Arguments to Subroutines

5.5 Returning Values from Subroutines

5.6 Private Variables and the ’my’ Keyword

5.7 Using local for Temporary Values

5.8 Subroutine Prototypes

5.9 Variable-Length Parameter Lists

5.10 Handling Exceptions in Subroutines

5.11 Recursive Subroutines

5.12 Built-in Functions vs. User-Defined Functions

6 Regular Expressions

6.1 Introduction to Regular Expressions

6.2 Basic Syntax and Patterns

6.3 Metacharacters

6.4 Character Classes

6.5 Quantifiers

6.6 Anchors

6.7 Grouping and Capturing

6.8 Alternation

6.9 Substitutions

6.10 Modifiers

6.11 Common Regex Functions in Perl

6.12 Practical Examples of Regular Expressions

6.13 Debugging Regular Expressions

7 File Handling

7.1 Introduction to File Handling

7.2 Opening and Closing Files

7.3 Reading from Files

7.4 Writing to Files

7.5 File Modes and Permissions

7.6 Working with Filehandles

7.7 File Tests and Operations

7.8 Reading and Writing Binary Files

7.9 Directory Operations

7.10 Error Handling in File Operations

7.11 Working with Large Files

7.12 Practical Examples of File Handling

8 Perl Modules

8.1 Introduction to Perl Modules

8.2 Using Built-in Modules

8.3 Installing CPAN Modules

8.4 Creating Your Own Modules

8.5 Module Namespaces

8.6 Loading Modules with ’use’ and ’require’

8.7 Exporting Functions and Variables

8.8 Module Documentation

8.9 Versioning in Modules

8.10 Managing Dependencies

8.11 Practical Examples of Module Usage

9 Object-Oriented Perl

9.1 Introduction to Object-Oriented Perl

9.2 Basic Concepts of OOP

9.3 Creating a Class in Perl

9.4 Creating and Using Objects

9.5 Class Inheritance

9.6 Encapsulation and Data Hiding

9.7 Overloading Methods

9.8 Polymorphism

9.9 Using Constructors and Destructors

9.10 Advanced Object-Oriented Techniques

9.11 Practical Examples of OOP in Perl

10 Advanced Perl Programming

10.1 Introduction to Advanced Perl Programming

10.2 References and Data Structures

10.3 Advanced Regular Expressions

10.4 Autoload and Ties

10.5 Closures and Anonymous Subroutines

10.6 Evaluation and Exception Handling

10.7 Interfacing with C/C++

10.8 Manipulating Complex Data Structures

10.9 Advanced File and Data Handling

10.10 Memory Management and Optimization

10.11 Concurrency and Parallel Processing

10.12 Practical Examples of Advanced Perl Programming

Introduction

Perl, Practical Extraction and Report Language, is a highly versatile and dynamic programming language with a rich history dating back to its creation in 1987 by Larry Wall. Originally designed as a text-processing language, Perl has evolved over the years to become a robust and versatile tool suitable for a variety of tasks ranging from web development to system administration, and from data manipulation to network programming.

The purpose of this book, Perl Programming: Scripting and Automation, is to provide a comprehensive introduction to Perl for beginners. Through detailed explanations, practical examples, and logical progression of topics, this book aims to make learning Perl accessible and engaging to those new to programming and scripting.

This book begins with the foundational aspects of Perl, focusing initially on understanding what Perl is and its historical context. Following this, the book proceeds to guide readers through installing Perl on various platforms and running their first Perl scripts, thus establishing the basic structure of a Perl program. Thereafter, readers will become acquainted with the Perl interpreter and the extensive documentation available, equipping them with the necessary resources to seek help and expand their knowledge independently.

As the chapters advance, the book delves into core Perl concepts such as basic syntax, variables, data types, and control structures. Through clearly defined sections, readers will gain a solid understanding of Perl statements, operators, input and output operations, and string manipulations. Special emphasis is placed on debugging techniques, ensuring that readers can efficiently troubleshoot and refine their scripts.

In the following chapters, the book covers the essential topics of subroutines and functions, illustrating the significance of modular and reusable code. Regular expressions, a powerful feature of Perl, are explored in detail, providing readers with the skills to perform complex text-processing tasks efficiently. Practical examples demonstrate how to apply these concepts effectively in real-world scenarios.

A key component of Perl programming is file handling, and this book provides an in-depth exploration of various file operations, including reading from and writing to files, managing file handles, and handling errors. The book further extends this knowledge by introducing Perl modules, offering insights into using built-in and CPAN modules, and guiding readers on creating their own modules for enhanced functionality and organized code.

The introduction to object-oriented Perl marks the transition from fundamental to advanced programming techniques. Concepts such as classes, objects, inheritance, and encapsulation are thoroughly explained, enabling readers to build robust, scalable, and maintainable applications.

To conclude the journey, the book delves into advanced Perl programming topics such as complex data structures, advanced regular expressions, and memory management. Readers will also explore interfacing Perl with other languages, concurrency, and parallel processing techniques, thus preparing them to tackle sophisticated programming challenges.

The structured layout of this book ensures a smooth learning curve, allowing readers to build on their knowledge as they progress through the chapters. Each topic is presented in a clear, concise manner, supplemented with examples and exercises that reinforce the concepts discussed.

By the end of this book, readers will have acquired a well-rounded understanding of Perl programming and scripting. Equipped with this knowledge, they will be capable of developing effective and efficient scripts to automate tasks, process data, and build powerful applications.

Chapter 1

Introduction to Perl

This chapter provides an overview of Perl, detailing its definition, historical development, and primary uses. Readers will learn how to install Perl on different systems and run Perl scripts. The chapter also covers the basic structure of a Perl program, familiarizing readers with the Perl interpreter and available documentation. Practical information on seeking help with Perl and creating a first program is included, along with common use cases of the language.

1.1

What is Perl?

Perl, which stands for Practical Extraction and Report Language, is a high-level, general-purpose, interpreted, and dynamic programming language well known for its powerful text processing capabilities. It was developed by Larry Wall in 1987 as a highly flexible and capable language for handling text manipulation tasks in Unix scripting. Over the years, Perl has evolved substantially, integrating features from other programming languages such as C, awk, sed, and shell scripting, thereby establishing itself as a versatile tool for both task automation and complex programming challenges.

At its core, Perl excels in text processing, including tasks that involve pattern matching with regular expressions, extracting and formatting text, and converting data formats. The language syntax is designed to be straightforward and expressive, catering to a wide range of programming activities — from quick script writing to full-fledged application development.

Perl’s syntax facilitates these text-centric tasks exceptionally well. Consider the example of matching and replacing text within a string. Perl makes use of its powerful regular expression engine to perform such operations succinctly and efficiently. Here is an example of a Perl script designed to replace the word Perl with Perl Programming Language:

#

!/

usr

/

bin

/

perl

use

strict

;

use

warnings

;

my

$text

=

"

Welcome

to

Perl

!

"

;

$text

=~

s

/

Perl

/

Perl

Programming

Language

/;

print

"

$text

\

n

"

;

In this example, the substitution operator s/// is used to find the word Perl in the variable $text and replace it with Perl Programming Language. The regular expression capability, symbolized by = , is a hallmark of Perl’s text processing strength.

A key attribute of Perl is the type system, which is context-sensitive rather than strictly typed as found in many other programming languages. Variables in Perl are prefixed with symbols that denote their type: $ for scalars (single values), @ for arrays (ordered lists), and % for hashes (key-value pairs). The following illustration highlights the use of different Perl data types:

#

!/

usr

/

bin

/

perl

use

strict

;

use

warnings

;

#

Scalar

example

my

$scalar

=

42;

print

"

Scalar

:

$scalar

\

n

"

;

#

Array

example

my

@array

=

(1,

2,

3)

;

print

"

Array

:

@array

\

n

"

;

#

Hash

example

my

%

hash

=

(

’

key1

’

=>

’

value1

’

,

’

key2

’

=>

’

value2

’

)

;

print

"

Hash

:

key1

=

$hash

{’

key1

’},

key2

=

$hash

{’

key2

’}\

n

"

;

Perl is designed to be pragmatic, which is reflected in its There’s more than one way to do it philosophy. This flexibility allows developers to solve problems in multiple ways, capitalizing on their personal experience and coding preferences. As a result, Perl code can be both concise and highly expressive, facilitating rapid development and debugging.

Furthermore, the Comprehensive Perl Archive Network (CPAN) plays an instrumental role in Perl’s ecosystem. CPAN is a vast repository containing over 185,000 open-source Perl modules that can be leveraged to extend Perl’s functionality without having to write code from scratch. These modules cover a wide range of applications including web development (with frameworks like Catalyst and Dancer), database interaction (DBI), network programming, and more. To illustrate, installing a CPAN module can be done as follows:

cpan

install

JSON

Once installed, the module can be used within a Perl script:

#

!/

usr

/

bin

/

perl

use

strict

;

use

warnings

;

use

JSON

;

my

$json_text

=

’

{"

name

":

"

Alice

",

"

age

":

30}

’

;

my

$data

=

decode_json

(

$json_text

)

;

print

"

Name

:

$data

->{’

name

’},

Age

:

$data

->{’

age

’}\

n

"

;

Given Perl’s combination of simplicity, flexibility, and power, it remains a valuable language in many fields, notably in system administration, web development, network programming, and bioinformatics. Its capacity to handle complex text manipulation and data extraction tasks efficiently makes it a go-to choice for many programmers worldwide. Through its continuous evolution, Perl retains its standing as a robust scripting language with a loyal and active community.

1.2

History of Perl

Perl, an acronym for Practical Extraction and Report Language, was created by Larry Wall in 1987. Wall, a linguist turned programmer, designed Perl as a Unix scripting language to make report processing easier.

The inception of Perl was driven by Wall’s necessity to produce numerous reports from various text files and searching through large log files. During this period, existing Unix tools such as ‘awk‘ and ‘sed‘ were somewhat limited in their capabilities. Wall sought a more powerful language that amalgamated the features of these tools while adding enhanced data manipulation abilities and greater flexibility.

Larry

Wall

first

released

Perl

on

18

December

1987.

print

"

Perl

1.0

was

introduced

on

December

18,

1987.\

n

"

;

Perl underwent substantial evolution through multiple versions since its original release. The initial release, Perl 1.0, encapsulated all the fundamental features that Larry Wall originally conceptualized. Over the next several years, the language would continually expand, both in terms of syntax and functionality.

The second major milestone was the release of Perl 2.0 in 1988, which included a variety of bug fixes and increased functionality. However, it was the release of Perl 3.0 in 1989 that marked a significant advancement, integrating regular expressions which are now integral to Perl’s identity. Perl’s capabilities with text processing firmly established it as a powerful scripting language.

Regular

expressions

were

integrated

into

Perl

with

version

3.0.

print

"

Perl

3.0

introduced

regular

expressions

in

1989.\

n

"

;

Perl 4.0, released in 1991, continued the trend of adding valuable features and improvements. This version improved the language’s stability and performance, as well as enhanced its documentation. Considered a significant evolution, Perl 4.0 became widely adopted and supported by a robust community of developers.

The most groundbreaking change came with Perl 5.0, released in 1994. This version brought about extensive enhancements which fundamentally altered the language. Some key features of Perl 5.0 included the introduction of references, modules (packages of reusable code), and an enhanced object-oriented programming model. These changes made the language vastly more powerful and versatile.

Perl

5.0

introduced

references

and

support

for

objects

.

print

"

Perl

5.0

was

released

in

1994

with

major

enhancements

.\

n

"

;

Continuing from Perl 5, subsequent releases have brought incremental but significant improvements. Perl 5.8, released in 2002, introduced Unicode string representation, threading, and improvements in support for object-oriented programming.

In 2003, Perl 6 was announced as a major redesign of the language. However, it became clear that Perl 6 would diverge significantly from the principal development path of Perl. This led to two distinct languages: Perl 5 and Raku (formerly Perl 6), with Raku being officially renamed in 2019.

Perl

6

was

later

renamed

to

Raku

.

print

"

Raku

(

formerly

Perl

6)

diverged

from

Perl

5

development

.\

n

"

;

The persistence and adaptability of Perl underscored its continued relevance. Perl 5 maintained a steady release cycle, incorporating updates that ensured it adapted well to modern computing paradigms. This evolution maintained its compatibility with earlier scripts while enhancing performance and expanding capabilities.

Understanding the history of Perl provides important context about its development and adoption. This insight allows a deeper appreciation of its syntax and functionality, emphasizing the deliberate design decisions that informed its creation and evolution.

1.3

Installing Perl

Installing Perl on your system is a pivotal first step for leveraging its scripting and automation capabilities. Perl is versatile and can be installed on various operating systems such as Windows, macOS, and Linux. This section provides detailed instructions for installing Perl on each of these platforms.

Windows Installation

1. Navigate to the Strawberry Perl website (https://strawberryperl.com/) to download the latest version of Strawberry Perl. Strawberry Perl includes a compiler and make tools, which are essential for running and building some Perl modules.

2. Select the appropriate version for your system architecture (32-bit or 64-bit) and download the installer.

3. Once the download is complete, run the installer. You will be prompted through a series of installation steps.

- Accept the license agreement. - Choose the installation directory. The default is usually C:\Strawberry. - Proceed with the installation by clicking Next through the remaining prompts until the installation is complete.

4. After installation, verify that Perl is correctly installed by opening the Command Prompt and typing the following command:

perl

-

v

This command should output the version of Perl that has been installed.

This is perl 5, version 32, subversion 1 (v5.32.1) built for MSWin32-x64-multi-thread

macOS Installation

Perl comes pre-installed on macOS. However, to ensure that you have the latest version of Perl, you might want to use a package manager such as Homebrew.

1. If you do not already have Homebrew installed, you can install it by running the following command in the Terminal:

/

bin

/

bash

-

c

"

$

(

curl

-

fsSL

https

://

raw

.

githubusercontent

.

com

/

Homebrew

/

install

/

HEAD

/

install

.

sh

)

"

2. Once Homebrew is installed, install Perl by typing the following command in the Terminal:

brew

install

perl

3. After installation, verify that Perl is correctly installed by typing:

perl

-

v

The expected output should confirm the Perl version installed through Homebrew.

This is perl 5, version 34, subversion 0 (v5.34.0) built for darwin-thread-multi-2level

Linux Installation

Most Linux distributions come with Perl pre-installed. The instructions below provide steps to ensure you have the latest version or to install it if it is not already present.

1. For Debian-based distributions (e.g., Ubuntu), you can update or install Perl using the following commands:

sudo

apt

update

sudo

apt

install

perl

2. For Red Hat-based distributions (e.g., Fedora), use the following commands:

sudo

dnf

install

perl

3. After installation, verify that Perl is correctly installed by typing:

perl

-

v

The version information should be displayed as:

This is perl 5, version 30, subversion 3 (v5.30.3) built for x86_64-linux-gnu-thread-multi

Ensuring No Conflicts

After installation on any operating system, it is essential to ensure that there are no conflicting versions of Perl present, especially if multiple Perl versions were installed from different sources. Confirm the location of the Perl binary being used by executing:

which

perl

This command should output the path to the Perl interpreter, generally one of the following:

/usr/bin/perl /usr/local/bin/perl /opt/local/bin/perl

By following these detailed installation steps, you can successfully set up Perl on your system, ready to start scripting and automating tasks.

1.4

Running a Perl Script

Perl scripts can be executed in multiple environments, providing versatility in the development and deployment of code. This section covers the process of running a Perl script from different interfaces, including command-lines and Integrated Development Environments (IDEs). It also addresses execution permissions and essential troubleshooting steps.

To run a Perl script from the command line, first ensure that Perl is installed on your system. If Perl is correctly installed, verify its presence by executing the following command:

perl

-

v

This command will display the installed Perl version, confirming the installation. Next, navigate to the directory containing your Perl script using the cd command. Suppose the script is named example.pl; you can execute it by entering:

perl

example

.

pl

The system will process the script and return any output to the terminal. Consider the following simple script example.pl containing one line:

print

"

Hello

,

World

!\

n

"

;

Executing perl example.pl will produce:

Hello, World!

In some environments, it may be desirable to make the script directly executable, bypassing the need to invoke the Perl interpreter explicitly. To accomplish this on Unix-like systems, start the script with a shebang line:

#

!/

usr

/

bin

/

perl

print

"

Hello

,

World

!\

n

"

;

The shebang (#!) indicates the path to the Perl interpreter. After ensuring this line is at the top of the script, set the appropriate execute permissions using the chmod command:

chmod

+

x

example

.

pl

Now, the script can be run directly:

./

example

.

pl

The output remains:

Hello, World!

To streamline the execution process, consider configuring your environment’s PATH variable to include the directory containing your scripts. This allows execution without navigating to the exact script location each time.

Running a Perl script in Integrated Development Environments (IDEs) can further enhance productivity by offering a graphical interface and numerous development tools. Popular Perl-compatible IDEs include Padre, Eclipse with EPIC plugin, and Visual Studio Code with Perl extensions. While each IDE has unique features, most require configuring project settings to specify the location of the Perl interpreter. Once configured, running the script typically involves a few clicks, providing an integrated approach to coding, testing, and debugging.

Troubleshooting common errors when running Perl scripts involves examining error messages returned by the interpreter. Syntax errors, for example, often yield messages specifying the erroneous line number:

syntax

error

at

example

.

pl

line

1,

near

"

,

"

Execution

of

example

.

pl

aborted

due

to

compilation

errors

.

This output suggests an issue on line 1, guiding the user to investigate the script for misplaced commas or other syntactic mistakes. Other common issues include missing modules or incorrect shebang lines—each prominently indicated in the error messages.

Attention to detail when setting permissions and using accurate paths ensures a smooth experience running Perl scripts across various platforms and environments.

1.5

Basic Structure of a Perl Program

A Perl program typically begins with the declaration of the interpreter, known as the shebang line, at the top of the script file. This line tells the operating system which interpreter to use to execute the script. The shebang line is written as:

#

!/

usr

/

bin

/

perl

The #!/usr/bin/perl line specifies the path to the Perl interpreter on a Unix-like system. On Windows, this line is not strictly necessary, as the association of .pl files with the Perl interpreter is handled differently.

Immediately following the shebang line, it is common practice to use strict and warnings directives to enforce good coding practices. These pragmas, when enabled, help catch common errors and enforce a cleaner and more maintainable coding style. This is done with the following lines:

use

strict

;

use

warnings

;

The use of strict ensures that all variables must be declared either via my, our, or local before they are used, thus preventing accidental creation of global variables due to typos. The warnings pragma provides helpful warnings about dubious constructs, which can aid in debugging and improving code quality.

Next, the actual code of the Perl script follows. Perl scripts are essentially a sequence of statements, each ending with a semicolon (;). Variables in Perl are prefixed with special characters ($, @, %), which denote scalar, array, and hash variables respectively.

The standard variable types and a few typical operations are as follows:

#

Scalar

variable

my

$name

=

"

John

"

;

print

"

Hello

,

$name

\

n

"

;

#

Array

variable

my

@numbers

=

(1,

2,

3,

4,

5)

;

print

"

First

number

is

$numbers

[0]\

n

"

;

#

Hash

variable

my

%

ages

=

(

"

John

"

=>

30,

"

Lisa

"

=>

28)

;

print

"

John

’

s

age

is

$ages

{\"

John

\"}\

n

"

;

In the above example:

A scalar variable $name holds a string value.

An array variable @numbers holds a list of numeric values.

A hash variable %ages holds key-value pairs.

Control structures in Perl, such as conditional statements and loops, are similar to those in C-like languages. Below are examples of an if conditional and a for loop:

#

Conditional

statement

if

(

$name

eq

"

John

"

)

{

print

"

It

’

s

John

.\

n

"

;

}

#

Loop

for

my

$num

(

@numbers

)

{

print

"

Number

:

$num

\

n

"

;

}

In the first block, the if statement checks if the scalar variable $name contains the string John. The eq operator is used for string comparison. In the second block, a for loop iterates over the array @numbers, printing each number.

Perl subroutines (functions) encapsulate reusable code and are defined using the sub keyword:

sub

greet

{

my

(

$person

)

=

@_

;

print

"

Hello

,

$person

!\

n

"

;

}

greet

(

"

Alice

"

)

;

In this example, the greet subroutine takes one argument $person and prints a greeting. The subroutine is then called with the argument Alice.

While this covers only the most basic elements, the structure and syntax presented here form the foundation of Perl programming. Despite its simplicity, Perl’s flexibility allows for a wide range of programming styles and paradigms.

1.6

The Perl Interpreter

The Perl interpreter is the essential component that executes Perl scripts. Understanding its operation and features is crucial for efficient Perl programming. Perl is both a language and an interpreter. The interpreter reads Perl code, compiles it into bytecode, and then executes it. This section will delve into various aspects of the Perl interpreter, showcasing how to start it, use command-line options, and understand its execution process.

To begin using the Perl interpreter, it is typically invoked from the command line or terminal with the perl command followed by the script name. For example, to run a script named example.pl, one would use:

$

perl

example

.

pl

Command-line Options

The Perl interpreter supports numerous command-line options that allow for flexible script execution. Some of the most commonly used options include:

-e: Execute code provided directly on the command line.

$

perl

-

e

’

print

"

Hello

,

World

!\

n

";

’

This option is useful for executing short scripts or testing small pieces of code without creating a file.

-w: Enable warnings.

$

perl

-

w

script

.

pl

Enabling warnings is highly recommended as it helps identify potential issues and deprecated features in the code.

-c: Check syntax without executing.

$

perl

-

c

script

.

pl

This option is valuable for verifying the correctness of code without running it, ensuring there are no syntax errors.

-d: Run the script under the Perl debugger.

$

perl

-

d

script

.

pl

The debugger is a powerful tool for tracing through scripts and identifying logic errors.

-T: Enable taint checking.

$

perl

-

T

script

.

pl

Taint checking is crucial for security, especially in scripts that interact with external data, ensuring that potentially unsafe data does not compromise system integrity.

-I: Specify directories to include in the search path for libraries.

$

perl

-

I

/

path

/

to

/

library

script

.

pl

This option is used to include additional directories where Perl should look for modules and libraries.

Execution Process

When a Perl script is run, the Perl interpreter performs a series of steps to execute the script:

Compilation Phase: The script is read and compiled into an internal bytecode representation. During this phase, the interpreter checks for syntax errors and translates the code into an executable format.

Execution Phase: Once the code is compiled, the interpreter executes the bytecode. The execution might involve multiple stages such as variable initialization, subroutine calls, and handling of control structures.

Both phases occur in-depth and encompass various sub-steps. It’s essential to understand some of the key internal mechanisms:

Contexts

Perl uses different contexts to evaluate expressions, primarily scalar and list contexts. The context determines how expressions are parsed and evaluated.

my

@array

=

(1,

2,

3)

;

my

$count

=

@array

;

#

Scalar

context

:

$count

gets

the

number

of

elements

in

@array

my

@copy

=

@array

;

#

List

context

:

@copy

gets

a

copy

of

@array

Environment Variables

The behavior of the Perl interpreter can be influenced by environment variables. Some of the most significant ones are:

PERL5LIB: Specifies additional directories to search for modules.

PERL5OPT: Provides default command-line options to the Perl interpreter for every execution.

PERLLIB: Similar to PERL5LIB, used primarily for backward compatibility.

Embedding Perl

Perl can also be embedded into other applications using the perlxs and perlembed interfaces. This allows for extending applications with Perl’s scripting capabilities or writing Perl scripts that interface directly with C code.

Example Execution

To illustrate a typical execution, consider the following simple script example.pl:

#

!/

usr

/

bin

/

perl

use

strict

;

use

warnings

;

print

"

Enter

your

name

:

"

;

my

$name

=

<

STDIN