PERL Interview Questions

File handles are internal Perl structures associated with file names. It is similar to a connection that can be used to change the contents of a file, and the connection is named (the FileHandle) for speedy access. A Perl File Handler provides access to files such as texts, logs, or configuration files. It is possible to create, read, write, open, copy, and close files using Perl file handles. In Perl, there are three basic FileHandles as follows:

• STDIN  (Standard Input)
• STDOUT (Standard Output)
• STDERR Standard Error)

Usually, FileHandling occurs via the open method.

Syntax:  open(FileHandle, Mode, FileName);

Here,

• FileHandle: Refers to the file that can be used until its closure.
• Mode: The mode of opening a file.
• File Name: The file name to be opened.

The close function is used to close the FileHandle.

Syntax: close(FileHandle);

Here,

• FileHandle: The file handle to close.

Programmers with a background in computer programming can easily write, learn, and understand Perl. Several features of Perl come from C and Shell scripts, and the language is used in systems administration, networking, and other applications in which user interfaces are involved. Since it has good text manipulation capabilities and can deal with binary files, it is used to develop CGI (Common Gateway Interface) programs.

Application of Perl

Here are some characteristics of Perl:

• Most of the language's features, such as variables, statements, control structures, expressions, and subroutines, derive from C.
• Furthermore, it borrows shell scripting features for identifying data types such as scalars, arrays, and hashes.
• Furthermore, Perl includes inbuilt functions that are often used in shell programs, such as sorting and utilizing system facilities.
• Its Perl5 version supports complex data structures and has an object-oriented programming model that includes references, packages, and compiler directives.
• Auto-data typing and memory management are included in all versions of Perl. The interpreter determines the storage and memory requirements of each data type and allocates and deallocates memory accordingly.
• Additionally, it performs typecasting during the run time such as converting an integer to a string, and other conversions that are not legitimate.
• It comes with a number of powerful utilities (APIs) that enable you for text manipulation. These utilities are useful when working with markup languages such as HTML, XML, and others.
• The Perl language is also extendable, with libraries supporting XML and integrating with databases like MySQL and MySQL.
• With low defect density and fewer security flaws, Perl is one of the most secure programming languages, even being certified by Coverity, a third-party security organization.

The Perl programming language has several advantages and disadvantages. Here's a list of a few:

Advantages of Perl

• The text handling and parsing capabilities of Perl are among the best compared to those of other programming languages.
• Unlike C, Perl scripts do not need to be compiled, so they execute very quickly.
• It is open-source, cross-platform, and compatible with markup languages such as HTML and XML.
• In addition to being simple to program and understand, this language is also easy to learn.
• It is very efficient in text manipulation i.e., Regular Expression. It also provides socket capability.
• Most commonly used for Payment Gateways in Web development, for Automated Testing, and for most of the Storage-related stuff. Due to its embeddable nature, it can be embedded in database servers or Network web servers.
• A vast collection of open-source modules is available on the CPAN (Comprehensive Perl Archive Network) which provides many powerful extensions to Perl's standard library.
• The CPAN library makes Perl development easier.

Disadvantages of Perl

• Due to CPAN modules, Perl does not support portability.
• It has minimal GUI support compared to other programming languages.
• In this case, you will have to refer to complex library modules that are not easy to comprehend.
• Experience is required to understand complex patterns.
• Every time a program is modified, it must be interpreted again.
• Perl allows you to achieve the same result in several ways, which makes it untidy and difficult to read.
• Compared to other languages, usability is lower.

Perl programs typically consist of a series of statements and declarations running from top to bottom. Control structures such as loops and subroutines allow you to bounce around within the code. There must be a semicolon (;) at the end of every simple statement.

Perl identifiers are essentially the names that are used to identify classes, variables, modules, functions, and other objects. Variable names in Perl begin with either $, @, or % followed by letters, zero, underscores, or digits (0-9). A Perl identifier cannot contain punctuation characters such as @, $, or %. The Perl programming language is case-sensitive, for example, $Manpower and $manpower have different meanings.

It is not required to explicitly declare variables in Perl in order to reserve memory space. A variable is automatically declared when a value is assigned to it. In Perl, the = sign is used when assigning data to variables.

Perl's code also provides comment facilities, like those in other languages. A single-line comment is available as well as a multi-line comment.

• Single line comment: Precede the comment with #.

Example:

$a = 5;  
print"$a\n";   #a is a variable  

Output:

5

• Multi-line comment: Add =begin and =cut statement before and after the comment.

Example:

$a = 3;  
print"$a\n";   
=begin  
Perl program to   
demonstrate multiple line comments. 
=cut  

Output:

3

Perl is extremely flexible when it comes to handling data. Perl variables can hold different types of data depending on their data types. When using Perl, you do not need to specify the data type since the language is loosely typed. Perl interpreters choose types according to the data context. There are no Boolean data types in Perl. The comment begins with a # sign. The following are the three basic data types supported by Perl:

1. Scalars: In this case, we are referring to a single unit of data that may be a floating-point number, integer number, a character, a string, or a reference. A $ sign precedes a scalar data type.

Example:

​​# Perl program  that illustrates the Scalars data type 
$empno = 3036;                  # An integer assignment
$name = "Scaler";               # A string assignment
$salary = 12.5;                 # A floating point  

# displaying result
print "Empno = $empno\n";
print "Name = $name\n";
print "Salary = $salary\n";

Output:

Empno = 3036
Name = Scaler
Salary = 12.5

Scalar data types can be operated on in a variety of ways, including multiplication, subtraction, addition, etc.

Example:

# Perl Program  that illustrates the Scalars operations
$str = "Scaler" . " by InterviewBit";   # Concatenates strings
$sum = 10 + 20;                         # adds two numbers  
$mul = 5 * 10;                          # multiplies two numbers   
$concat = $str . $sum;               # concatenates string and number    
# displaying result
print "str = $str\n";
print "sum = $sum\n";
print "mul = $mul\n";
print "concat = $concat\n";

Output:

str = Scaler by InterviewBit
sum = 30
mul = 50
concat = Scaler by InterviewBit30

2. Arrays of scalars: An array is an ordered list of scalar values that can be accessed through a numeric index that starts at 0. It stores the value of the same data type in the form of an ordered list. The '@' sign precedes the array name in Perl when declaring an array.

@empno= (23, 28, 30, 32)

It will create an array of integers that contains the values 23, 28, and 32. To access a single element of an array, we use the ‘$’ sign.

$empno[1];

It will produce an output of 28.

Example: 

# Perl program that illustrates the array data type 
#!/usr/bin/perl
@empno = (23, 24, 26, 28);                         # creation of arrays
@name = ("Scaler", "by", "InterviewBit");

# displaying result
print "\$empno[0] = $empno[0]\n";
print "\$empno[1] = $empno[1]\n";
print "\$empno[2] = $empno[2]\n";
print "\$empno[3] = $empno[3]\n";
print "\$name[0] = $name[0]\n";
print "\$name[1] = $name[1]\n";
print "\$name[2] = $name[2]\n";

Output:

$empno[0] = 23
$empno[1] = 24
$empno[2] = 26
$empno[3] = 28
$name[0] = Scaler
$name[1] = by
$name[2] = InterviewBit

3. Hashes of scalars: It is also known as an associative array. Hashes are lists of unordered key/value pairs that can be accessed by using their keys as subscripts. The symbol '%' is used in Perl to declare hash. In order to access a value, follow the '$' symbol by the key enclosed in braces.

Example

# Perl program that illustrates the Hashes data type 
%data = ('Scaler', 3, 'by', 5, 'InterviewBit', 9);
#displaying result
print "\$data{'Scaler'} = $data{'Scaler'}\n";
print "\$data{'by'} = $data{'by'}\n";
print "\$data{'InterviewBit'} = $data{'InterviewBit'}\n";

Output: 

$data{'scaler'} = 3
$data{'by'} = 5
$data{'InterviewBit'} = 9 

The scope of a variable refers to the part/area of the program in which it can be accessed. The scope of variables can also be referred to as their visibility in a program. A variable can be declared as either a global variable or a private variable in Perl. The term "lexical variable" also refers to private variables. Variables in Perl have a global scope by default.

1. Global Variable: Almost every function or block in a program can access and use global variables. A global variable is visible throughout the entire program. Each part of the program has access to global variables.

Example: The variable $employer declared at the beginning of the code will be visible till the end of the program, even inside blocks and even if those are in the function declarations. If we change the variable inside the block, that will change the value for the rest of the code, even outside of the block.

# Perl program to demonstrate the scope of Global variables
$employer = "Scaler Academy";      # Global variable declaration
print "$employer\n";               # Printing the global variable
# block starting
{
  # Printing $name's value inside a block 
  # since global variables can be used within blocks. 
   print "$employer\n";
   $employer = "InterviewBit";    # changing the value of $name
   print "$employer\n"; 
}
print "$employer\n";

Output:

Scaler Academy
Scaler Academy
InterviewBit
InterviewBit

2. Private variables: Private variables in Perl are defined using my keyword before a variable. my keyword confines variables in a function or block in which it is declared. A block can either be a for loop, a while loop, or a block of code with curly braces around it. The local variable scope is local, its existence lies between those two curly braces(block of code), outside of that block this variable doesn’t exist. These variables are also known as lexical variables.

Example:

# Perl program to demonstrate the scope of Private variables  
$empname = "Sakshi";             # global variable 
$empid = 36;
print $empid." ".$empname."\n";  
$empid++;                        # value of empid is incremented to 2
# block starting
{      
   # my keyword to declare a private variable within block
   my $new_empname = "Swati";       
   
   # accessing global variable empid inside the block
   print $empid." ".$new_empname."\n";
   $empid++;                   # value of empid is incremented to 3
}
 
# $new_empname cannot be used outside block,
# so nothing will be printed 
print "Private variable in above block: ".$new_empname."\n"; 
 
# declaring function
sub scaler 
{
 
   #private variable declaration changes/hides 
   #the global variable $empname 
   my $empname = "Hide"; 
   print $empid." ".$empname."\n";
}
 
# calling the function
scaler();

Output:

36 Sakshi
37 Swati
Private variable in the above block: 
38 Hide

Perl is a high-level, general-purpose, dynamic, scripting (interpreted), feature-rich, and stable programming language that was originally designed for text manipulation and now comes in handy for a wide variety of tasks including web development, system administration, network programming, GUI (Graphical User Interface) development, and many more. Perl is a case-sensitive programming language and supports both Object-Oriented and Procedural Programming. Perl is similar in syntax to many widely used languages, so it is easier to learn and code. Notepad++, gedit, and other common text editors are good tools for writing Perl programs.

Perl Program Example: A program to add two numbers.

#!/usr/bin/perl
$x = 10;    # Assigning value to $b
$y = 20;    # Assigning value to $c
 
$z = $x + $y;   # Performing an addition
print "$z";     # Printing the result

Output:

30

On the Internet, there is a wide selection of programs designed for programmers. If you want your Perl script to be recognized as a functioning Perl script, you must save it with either the '.PL' or '.Pl' file extension.

File handling modes include:

The grep() function is used by Perl to retrieve any element from an array. This function extracts any element from the array whose value evaluates the true value for the regular expression given.

• Syntax: grep(Expression, @Array)

Here, 

• Expression: A regular expression runs on each element in an array.
• @Array: An array on which the grep() function is called.

If the expression matches an array of elements, this function returns a list of elements that match the expression in the scalar context.

Example1:

#!/usr/bin/perl
@list = (2,"Scaler", 0, "by", "InterviewBit", 26 );
@hasdigit = grep ( /\d/, @list );
print "@hasdigit\n";

Output:

2 0 26

This example extracts and returns all digits (digit elements) from the array by using a regular expression '//d/', and the remaining elements are discarded.

Example2:

#!/usr/bin/perl
@list = (2,"ScalerEdge", 0, "by", "Scaler", 26 );
@haschar = grep ( /^S/, @list );
print "@haschar\n";

Output:

ScalerEdge Scaler

As shown here, the regular expression /^S/ is used to retrieve the elements beginning with the letter 'S' from the array and discard the rest.

The Perl programming language supports many types of operators, but the following are some of the most important and frequently used operators:

• Arithmetic Operators (+ , - , / , * , % , **).
• Quote-like Operators (q{ } , qq{ } , qx{ }).
• Logical Operators (and , or , && , || , not).
• Assignment Operators (= , += , -= , *= , /= , %= , **=).
• Bitwise Operators (&, | , ^ , ~ , << , >>).
• Equality Operators (==, != , <=> , > , < , >= , <=).
• Miscellaneous Operators (. , x , .. , ++ , – , ->).

With over 250,000 software modules available in 40,000+ distributions, including documentation, CPAN is the world's largest repository of Perl software modules. In short, it is an international mirrored collection of reusable Perl packages. CPAN contains mostly free and open-source software. For CPAN packages that are not available, you may build a native package from the equivalent CPAN package.

When running a Perl program, it must go through the Perl interpreter. The opening line of many Perl applications is as follows: #!/usr/bin/perl

On the internal level, the interpreter compiles the program into a parse tree. If there is a space or mark after a pound symbol, the program interpreter ignores it. Upon transforming it into a parse tree, the interpreter immediately executes it.  Although Perl is frequently referred to as an interpreted language, this is not strictly true. Because interpreters convert programs into byte code before executing them, they are sometimes called interpreters/compilers. Although the compiled form isn't stored in a file.

Yes, it is possible for Perl programmers to load binary extensions dynamically. Programmers only need to make sure their system supports this. If the system doesn't allow the same, you can do this task statically.

A dynamic load is essentially when your program determines, at runtime, that it requires more functionality than what is currently available, so it loads it and continues to run. Perl code can always be dynamically loaded, but dynamically loading binary extensions is even more interesting. A dynamic approach can assist users in saving time by allowing them to perform some basic tasks according to their preferences.

A number of command-line options or switches are available in Perl. Due to their ability to turn on or off different behaviours, they are also called switches. The following are some of the command-line options:

• -a option: You must use this option in conjunction with either -n or -p. Input lines are automatically fed into the split function when using the -a option. At the end of the split, the results are placed in the @F variable.
• -c option: You can use this option to check your script's syntax without executing it. Due to the necessity of the compilation process, the BEGIN blocks and use statements are still executed.
• -d option: You can start the Perl debugger with this option.
• -n option: This option wraps your script in a loop. When it reads a line from the diamond operator, it will execute the script automatically. There is no limit on how many times users can use this option. The loops and scripts are not limited in size.
• -p option: This is a similar option to the -n option. When it reads a line from the diamond operator, it will execute the script automatically, and then print $_. There is no limit on how many times users can use this option. The loops and scripts are not limited in size.
• –i option: Files are moved to the right place using this option. You can edit files in place with this option. Use it with the -n or -p options. Any file is not backed up when you use this option.
• -s option: This option allows you to define a custom switch for your script.
• -e option: A single line of code can be specified on the command line with this option. It is possible to create a multiple-line program by using multiple -e options.

Modules or packages can be included in Perl using two directives.

• “use”: Using the Use directive, modules with .pm extensions can be included and the objects they include can then be verified during compilation. When "Use" is specified, the module included is compiled at compile time. The file extension does not need to be specified.
• “require”: The "require" directive can be used to include modules and libraries, and the included objects are verified at runtime. The file extension must be specified.

The Perl programming language is described as both a compiler and an interpreter. Perl first reads or takes in the source code, converts it into bytecode before executing the program, and then executes it. It is therefore possible to think of the Perl programming language as both a compiler and an interpreter.

Pragmas are specific modules in Perl packages that control some aspects or functions of Perl's run-time or compile-time behaviour. With Perl 5.10 and later versions, you can now create user pragmata for modifying how user functions behave within lexical scopes as opposed to using built-in pragmata. Two of the most commonly used built-in pragmas in Perl are:

1. use strict: This pragma forces the developer to code in a way that allows the program to run correctly and minimizes the likelihood of errors. When using the use strict pragma, for example, developers are required to declare variables first before utilizing them. The 'my' keyword in Perl can be used to declare variables, which changes the scope of the variables from global to local. With the Perl 5.12 version, this pragma is enabled implicitly. In other words, we do not have to use the use strict statement if we are using Perl 5.12 or later versions, since the pragma is enabled by default. This pragma should be placed at the beginning of the script as follows: use strict;

Example:

Using the use strict pragma and not declaring variables will result. Below is an example:

#!/usr/local/bin/perl 
use strict;
$s = "Scaler Academy!\n";
print $s;

Output:

Global symbol "$z" requires explicit package name (did you forget to declare "my $z"?) at main.pl line 3.
Global symbol "$z" requires explicit package name (did you forget to declare "my $z"?) at main.pl line 4.
Execution of main.pl aborted due to compilation errors.

The variable must be declared with my keyword so that we can avoid this error. The following program prints the string without any problems when executed.

#!/usr/local/bin/perl 
use strict;
my $s = "Scaler Academy!\n";
print $s;

Output:

Scaler Academy!

Note: The $a and $b variables are special Perl variables that have global access, so using them makes the program work perfectly. 

Below is an example:

#!/usr/local/bin/perl 
use strict;
$a = "Scaler Academy!\n";
print $a;

Output:

Scaler Academy!

2. use warning: Often, this pragma is used in conjunction with the use of strict pragmas. The use warning pragma alerts us when something went wrong and assists us in identifying any errors in the code. It can also be seen as a debugging tool since it aids in finding bugs in programs. Use strict and use warning have one primary difference. The use strict pragma will abort the program if it encounters an error, while the use warning pragma will just report the error and not abort it. Since the Perl 5.6 version, the use warning pragma has been available.

use strict;
use warnings;

Note: Perl 5.6 and later versions introduced the use of warning pragma. If you are using an older version, you can enable warnings by adding '-w' to your shebang/hashbang line:

#!/usr/local/bin/perl -w 

Chop() and Chomp() are quite similar functions. Each of them removes one character at the end of the input string.

1. Chop(): The chop() function in Perl is used to remove the last character from the input string completely. This function returns the last character that was removed.

• Syntax: chop(String)

Here,

String: A string whose last character must be removed.

Example:

#!/usr/bin/perl
$str = "Scaler by InterviewBit";     # String initialization
$a  = chop($str);                    # Invoking chop()
print "Chopped String: $str\n";
print "Character removed: $a\n";

Output:

Chopped String: Scaler by InterviewBi
Character removed: t

2. Chomp(): It removes any new line characters from the string's end. It removes the trailing newline from the specified input string. This function returns the total number of characters that have been removed from the string.

• Syntax: chomp(String)

Here, 

String: A String whose trailing newline must be removed.

Example:

#!/usr/bin/perl
$str = "Scaler by InterviewBit";
$a  = chomp( $str );               # Invoking chomp()
print "Chopped String: $str\n";
print "Number of characters removed: $a\n";
$str = "Scaler by InterviewBit\n";
$a  = chomp( $str );
print "Chopped String: $str\n";
print "Number of characters removed: $a\n";

Output:

Chopped String: Scaler by InterviewBit
Number of characters removed: 0
Chopped String: Scaler by InterviewBit
Number of characters removed: 1

In Perl, there are several built-in functions to remove or add elements to an array. These include push(), pop(), unshift(), and shift() functions.

1. Adding an element to the end of an array

An array is extended by adding a new element with the push() function. The function inserts a new element at the end of the array. With this function, you can insert multiple values separated by commas at the end of an array. The size of an array is increased by this function.

Syntax: push(Array, list)

Example:

#!/usr/bin/perl
# Initializing array
@arr = ('Scaler' , 'ScalerAcademy', 'ScalerEdge');
# Printing the initial array
print "Initial array: @arr \n";                                         

# Invoking push()
push(@arr, 'ScalerPlus', 'ScalerVerse');  
# Printing the updated array                      
print "Updated array: @arr";                                          

Output:

Initial array: Scaler ScalerAcademy ScalerEdge 
Updated array: Scaler ScalerAcademy ScalerEdge ScalerPlus ScalerVerse

2. Adding an element at the start of an array

Array elements are added at the beginning of the array using the unshift() function. Thus shifting all array values to the right by one. Adding multiple values is possible.

Syntax: unshift(Array, List)

Example:

#!/usr/bin/perl
# Initializing array
@arr = ('Scaler' , 'ScalerAcademy', 'ScalerEdge');
       
# Printing the initial array
print "Initial array: @arr \n";                                         

# Invoking unshift()
unshift(@arr, 'ScalerPlus', 'ScalerVerse');                    
# Printing the updated array
print "Updated array: @arr";                                          

Output:

Initial array: Scaler ScalerAcademy ScalerEdge 
Updated array: ScalerPlus ScalerVerse Scaler ScalerAcademy ScalerEdge

3. Removing an element from the end of an Array

The pop() function removes the last element from an array. When the pop function is executed, the array's size is decremented by one element.

Syntax: pop(Array)

Example:

#!/usr/bin/perl
# Initializing array
@arr = ('Scaler' , 'ScalerAcademy', 'ScalerEdge');  
# Printing the initial array     
print "Initial array: @arr \n";                                          

# Invoking pop()
pop(@arr);
# Printing the updated array                                                                   
print "Updated array: @arr";                                          

Output:

Initial array: Scaler ScalerAcademy ScalerEdge 
Updated array: Scaler ScalerAcademy

4. Removing elements from the beginning of an Array

With shift(), the element is removed from the beginning of the array rather than from the end. Thus shifting all array values to the left by one.

Syntax: shift(Array)

Example:

#!/usr/bin/perl
# Initializing array
@arr = ('Scaler' , 'ScalerAcademy', 'ScalerEdge');      
# Printing the initial array
print "Initial array: @arr \n";                                         
                                                                 
# Invoking shift()
shift(@arr);  
# Printing the updated array
print "Updated array: @arr";                                          

Output:

Initial array: Scaler ScalerAcademy ScalerEdge 
Updated array: ScalerAcademy ScalerEdge

Multiple methods are available for accessing data stored in Perl arrays. Array elements are obtained by placing a $ sign before the array name and storing the index value of the element within square brackets. The downside of this method is that you can only extract only one element at a time, which might be confusing if there is a long list of elements to access. The array slicing method in Perl is designed to avoid such situations. In order to simplify the process of accessing multiple elements from an array, array slicing is implemented to access a range of elements in the array. There are two ways to do this:

1. Passing multiple Index values:

Array slicing can be achieved by passing several index values from an array whose elements you wish to access. In this case, the index values are passed as arguments to the array name. Based on the specified indices, Perl accesses these elements and performs the necessary action.

Example:

#!/usr/bin/perl
@arr = ('Scaler' , 'by' , 'InterviewBit');
print "Array= @arr\n";
@a = @arr[0, 2];                    # slicing method
print "Extracted elements: "."@a";  # Printing the extracted elements

Output: 

Array= Scaler by InterviewBit
Extracted elements: Scaler InterviewBit

When accessing a large number of values, this method of passing indexes becomes somewhat complicated.

2. Using range operator

Slicing methods can also be performed in arrays using the range operator[..]. By specifying the starting and ending indexes in square brackets separated by the range operator(..), we are able to access a range of array elements.

Example:

#!/usr/bin/perl
@arr = ('Scaler' , 'ScalerAcademy' , 'ScalerEdge' , 'ScalerPlus' , 'ScalerVerse');
print "Array= @arr\n";

@a = @arr[1..3];                    # slicing method
print "Extracted elements: "."@a";  # Printing the extracted elements

Output:

Array= Scaler ScalerAcademy ScalerEdge ScalerPlus ScalerVerse
Extracted elements: ScalerAcademy ScalerEdge ScalerPlus

An array can be spliced to remove and return a specific number of elements using the splice() function. The removed elements can be replaced with a list of new ones.

Syntax: splice(@arr, offset, length, replacelist)

Here,

• @ar: Array name.
• offset: The index or offset at which an element is to be removed.
• length: Total number of elements to remove starting at offset (including offset).
• replacelist: Element list to replace removed elements.

Example:

#!/usr/bin/perl
# Initializing array with char elements from a to h
@arr = (a..h);                 
print "Initial Array: @arr\n";        # Printing initial array
# splice() replaces elements from b to f elements with 4 to 8
@arr2 = splice(@arr, 1, 5, (4..8)); 
 
print("Updated array: @arr\n");        # Printing updated array
print("Removed elements: @arr2");      # Printing removed elements

Output:

Initial Array: a b c d e f g h
Updated array: a 4 5 6 7 8 g h
Removed elements: b c d e f

Perl arrays can easily be converted into strings, and vice versa.

1. String to Array Conversion

The split() function can be used to convert strings into arrays.

Syntax: @arr = split (/REGEX/, $str);

Here, 

• @arr: An array variable to which the resulting array will be assigned.
• $str: String to split.
• Regex: The string (pattern) to match, and the $str will be split accordingly.

Example:

#!/usr/bin/perl
print ("Enter a line of text: ");
$str = <stdin>;
# Removes trailing newlines from string str
chomp $str; 
             
# Split() function matches whitespaces here
@arr = split (/ /, $str);
foreach (@arr)
{
       print ("$_\n");
}

Output:

Enter a line of text: Scaler by InterviewBit
Scaler
by
InterviewBit

2. Array to String Conversion

The join() function can be used to convert arrays into strings.

Syntax: $str = join ($connectingstr ,@arr);

Here,

• @arr: Input array.
• $connectingstr: A string that connects the individual array elements.
• $str: Resulting string.

Example:

#!/usr/bin/perl
@arr = ("Scaler", "by", "InterviewBit!");
$str = join(" ", @arr);
print ("$str\n");

Output:

Scaler by InterviewBit!

There is a built-in function in Perl called sort() that allows you to sort an array of numbers and alphabets. The sort() function returns a sorted array once an array is passed to it.

Syntax: sort @array_name

There are multiple ways to sort arrays in Perl:

• Sorting an array using ASCII values.
• Using the comparison function (cmp).
• Sorting an array of Numbers.
• Sorting in alphabetical order (case-insensitive).

The loop control statement alters the sequence in which the loop executes. As soon as execution leaves a scope, any automatic objects created within that scope will be destroyed. Perl supports the following types of loop control statements:

• Next statement: This is equivalent to the continue statement in C language. There are times when you aren't ready for the loop to end but are done with the current iteration. You can do that with the next operator. The next statement stops the current interaction of the loop, and control is passed on to the next iteration.
• Redo statement: By using the redo statement, you will be able to restart the loop block without having to evaluate the conditional again. This causes the loop block to return to the top, without testing any conditional expressions or advancing to the next loop. If a continue block exists, it is not executed.
• Last statement: Basically, it functions like the break statement in C. Like an "emergency exit" for a loop block, it allows you to exit the loop safely. With this, the loop statement is terminated and execution is transferred to the statement following the loop statement.
• Goto statement: Goto is a jump statement in Perl, and is also referred to as an unconditional jump statement. You can use the goto statement to jump from one place to another within a program. Perl offers three forms of goto command:  goto expr, goto label, and goto &name.
  • goto LABEL: It causes the execution to jump to the statement marked with a LABEL, and then the execution will proceed from that point.
  • goto EXPR: It is similar to goto LABEL but more generalized. There will be an expression that, after evaluation, returns a label name, and execution will jump to that particular LABEL statement.
  • goto &NAME: This substitutes a call to the named subroutine for the current one.

• exit() function: In Perl, Exit() evaluates the expression passed to it and exits the interpreter, returning the value as an exit value. Usually, the exit() function calls the end routines before terminating the program, rather than exiting immediately. The exit function returns 0 as a default value if no expression is passed to it. It is not recommended to use exit() to exit subroutines. A subroutine can be exited by using either die or return.
  • Syntax: exit(value)
  • Here, valuer/parameter: The value to be returned on exit function call.
  • Example:

# Obtaining the user's bid in an online auction.
print "Input your bid amount: ";
$bid = <STDIN>;
 
# If a bid is less than 5000, exit returns $bid
if ($bid < 5000)
{
   exit $bid;
}
 
else
{
   # This message is printed if the bid exceeds 5000
   print "\nThank you for taking part!";
}

Sample Output1:

Input your bid amount: 4000

Sample Output2: 

Input your bid amount: 6000
Thank you for taking part!

• die() function: When a program is executed, errors also occur and if they are not handled properly, the program may crash. In order to run your program smoothly, you must catch and fix the error. Upon encountering an error, die() terminates the script immediately. It returns an appropriate error message. Without the die() function, your script will continue to run.

Example1: Without using die()

• Here, we have provided the wrong file path, resulting in an error. But the script keeps running when it encounters an error and prints 'Still Printing, No Die Used'.

use strict;  
use warnings;  
open(my $fh, '>', 'sssit/javatpoint/file1.txt');  
print $fh "An example to demonstrate Error Handling!!!\n";  
close $fh;  
print "Still Printing, No die used.\n";  

Output:

print() on closed filehandle $fh at main.pl line 4.
Still Printing, No die used.

Example2: With using die()

In this example, since the file path is incorrect, the die() function will execute and exit the script.

use strict;  
use warnings;  
open(my $fh, '>', 'sssit/javatpoint/file1.txt') or die;   
print $fh "An example to demonstrate Error Handling!!!\n";  
close $fh;  
print "Still Printing, No die used.\n";  

Output:

Died at main.pl line 3.

Subroutines are groups of statements that perform a specific task together. Your code can be broken up into separate subroutines. You can divide your code however you like, but logically, you should make each subroutine perform a specific task. In Perl, a subroutine is defined in the following manner:

sub subroutine_name
{
  body of the subroutine
}

Having defined the subroutine, we can call it with the following statement: &subroutine_name;

It is not necessary to use the ampersand(&), except when using references to subroutine names. You can also call Perl subroutines as follows: subroutine_name();

Example:

sub scaler{
print "Welcome to Scaler Family!";
}
scaler();

Output: 

Welcome to Scaler Family!

 Reusability of code is possible in Perl. There is, however, a limit to how many times the same code can be used in the same program. As Perl has an inbuilt code trimming feature, users will not need to worry about complexity since it automatically suggests how to keep the code as short as possible. A prime example of this is code reusability. With "Inheritance", users can simply stay on track towards this goal. This feature allows child classes to use parent class methods.

A user is asked to enter numbers when the following program is executed, and the average of those numbers is shown as an output.

$sum = 0;
$count = 0;
print "Enter number: ";
$n = <>;
chomp($n);
while ($n >= 0)
{
$count++;
$sum += $n;
print "Enter another number: ";
$n = <>;
chomp($n);
}
print "$count numbers were entered\n";
if ($count > 0)
{
print "The average is: ",$sum/$count,"\n";
}
exit(0);

Output:

Enter number: 5
Enter another number: 10
Enter another number: 4
Enter another number: -1
3 numbers were entered
The average is 6.33333333333333

Using C over Perl has the following advantages:

• There are more development tools available in C, as well as faster execution speed than in Perl. Due to Perl's interpretative nature, it is comparatively slower than other compiled languages like C.
• C doesn't require you to hide your code if you don't want others to use it. Perl, on the other hand, requires you to hide your code so that others cannot use it.
• Without the use of additional tools, creating an executable Perl program is difficult.

It is true that Perl is equipped with a number of very useful objects. The best thing about them is that programmers are not required to make use of them. During the code writing process, the developers can easily skip them if they do not feel the need for them. In Perl, there are some Object-Oriented modules available for developers to utilize without even understanding them. However, if the program is too complex, it is recommended that programmers use Objects.

Database Independent Interface (DBI) is a module used in Perl for connecting to databases. DBI provides an abstraction layer between Perl code and database tables. DBI uses Structured Query Language, commonly called SQL, to communicate or interact with the database.

Example: The following is an example of connecting to the MySQL database "ScalerDB".

#!/usr/bin/perl
use DBI
use strict;
my $driver = "mysql"; 
my $database = "ScalerDB";
my $dsn = "DBI:$driver:database=$database";
my $userid = "vishalraj";
my $password = "scaler123";
my $dbh = DBI->connect($dsn, $userid, $password ) or die $DBI::errstr;
$dbh->disconnect;  

Conclusion

An interview for a technical position requires you to demonstrate both your technical and communication skills. Job interviews vary depending on the position and the company, so you can expect to be asked behavioural, technical, and personal questions. Perl interviews are nothing to be anxious about, especially if you prepare for them beforehand. There will be knowledge-based questions that test your proficiency with programming tools, standards, and best practices. The more prepared you are, the more likely you are to impress the hiring manager and move on to the next stage of the hiring process. 

In this article, you will find a comprehensive list of 30+ questions frequently asked about Perl programming during interviews to help job seekers begin or advance their careers. These interview questions cover several topics like Perl scripting interview questions, Perl OOPs interview questions, Perl coding interview questions, and so on. If you are starting to learn Perl, this list is a great way to measure your abilities. A candidate should possess a deep conceptual understanding as well as be able to articulate ideas clearly. With a little study and practice, a good candidate should be able to answer all of these questions confidently. 

Useful Resources

• https://www.interviewbit.com/shell-scripting-interview-questions/
• https://www.interviewbit.com/blog/scripting-language-vs-programming-language/
• https://www.interviewbit.com/technical-interview-questions/
• https://www.interviewbit.com/coding-interview-questions/