Top 60 Perl Interview Questions (2026)

Perl is a high-level, interpreted language created by Larry Wall in 1987, built for text processing and report generation. It's dynamically typed and blends procedural, object-oriented, and functional styles.

It's still used for system administration, log and file parsing, bioinformatics, and legacy web backends. Its regular expression support is strong enough that Perl-compatible regex (PCRE) became a standard other languages copied.

Scalars, arrays, and hashes. A scalar ($) holds a single value: a number, string, or reference. An array (@) is an ordered list indexed by position. A hash (%) is an unordered set of key-value pairs.

The sigil in front of the variable tells you the type, and the same base name can carry different types: $count, @count, and %count are three separate variables.

A sigil is the symbol before a variable name: $ for scalar, @ for array, % for hash. It tells the parser what kind of value you mean.

When you access a single element, you're asking for one scalar value, so you use $ even on an array or hash: $items[0] reads one element of @items, and $prices{apple} reads one value from %prices. The sigil follows the value you get back, not the container.

use strict forces you to declare variables with my (or our), bans symbolic references, and blocks bareword confusion, so typos become compile errors instead of silent bugs. use warnings reports suspicious runtime behavior like using an undefined value or a number where text was expected.

Together they catch a large share of beginner mistakes before they reach production. Putting both at the top of every script is the mark of someone who's worked on real Perl.

Context is how Perl decides what an expression means based on where it's used. The same expression can produce different results in list context versus scalar context.

The clearest example is an array: in list context it gives all its elements, but in scalar context it gives its count. Assigning an array to a scalar (my $n = @array) forces scalar context and returns the length, which surprises people expecting the first element.

== compares numbers; eq compares strings. Perl keeps them separate because a scalar can be read as either, and the operator decides which comparison happens.

Using the wrong one is a common bug: "10" == "10.0" is true (numeric), but "10" eq "10.0" is false (string). The full pairs are ==, !=, <, > for numbers and eq, ne, lt, gt for strings.

$_ is the default variable. Many functions and constructs use it implicitly when you don't give an argument: print with no argument prints $_, a bare regex matches against $_, and a foreach loop without a named variable sets $_ each pass.

It makes short scripts compact but can hurt readability in longer code, so name your loop variables when clarity matters.

chomp removes a trailing newline (more precisely, the current input record separator $/) if it's there, and returns the number of characters removed. chop removes the very last character no matter what it is and returns that character.

In practice you almost always want chomp, to strip the newline off a line read from input without touching real data.

my declares a lexical variable, visible only inside the enclosing block or file, and is what you should reach for by default. our declares a package (global) variable and makes it accessible by its short name under use strict. local temporarily saves and replaces the value of a global variable for the duration of the current block, restoring it afterward.

The common confusion is thinking local creates a local variable; it doesn't. It dynamically scopes an existing global, which is a different and older mechanism.

push and pop work at the end of the array; shift and unshift work at the front. push adds to the end, pop removes from the end, unshift adds to the front, and shift removes from the front.

splice is the general tool for inserting or removing anywhere in the middle by index. Knowing which four verbs map to which ends is a routine warm-up question.

A hash stores key-value pairs with no guaranteed order. You set and read values with $hash{key}, get all keys with keys %hash, all values with values %hash, and test for a key with exists.

delete removes a pair, and each lets you iterate key-value pairs. Because keys are unique, assigning to an existing key overwrites it.

print writes its arguments as-is. printf writes formatted output using a format string, like C's printf, which is how you control decimals and padding. say (available with use feature 'say' or use v5.10) is print with an automatic trailing newline.

For simple output say saves typing the newline; for numeric formatting printf is the tool.

Open a filehandle with a three-argument open, then read line by line with the diamond operator in a while loop. Reading STDIN uses the special filehandle <STDIN> or the bare <> in a loop.

Always check whether open succeeded, chomp each line to drop the newline, and close the handle when done. The three-argument form with a lexical handle is the modern style.

length for size, substr to extract or replace a slice, index and rindex to find positions, uc and lc for case, reverse, split to break a string into a list, and join to combine a list into a string.

sprintf builds a formatted string without printing it. These handle most day-to-day text work before you even reach regular expressions.

split takes a pattern and a string and returns a list of the pieces between matches, so split /,/, "a,b,c" gives ("a", "b", "c"). join does the reverse: it takes a separator string and a list and glues them into one string.

split's first argument is a regex, which means you can split on whitespace runs, punctuation, or any pattern. A special case, split ' ', collapses leading whitespace and splits on any whitespace run.

Conditionals: if, elsif, else, and unless (the negated if). Loops: while, until (negated while), for (C-style), and foreach for iterating a list. Perl also allows statement modifiers, a trailing condition on a single statement.

unless and until read naturally for negative conditions, and the statement-modifier form (print $_ for @list) is idiomatic for one-liners.

Perl treats these as false: the number 0, the string "0", the empty string "", and undef. Everything else is true, including the string "0.0", the string "00", and any non-empty string.

This catches people: "0" is false but "0.0" is true because it's a non-empty, non-"0" string. When in doubt, that's the rule to state.

undef is Perl's representation of no value: an unassigned variable, a missing hash key, or a value you explicitly cleared with undef $x. It indicates 0 in numeric context and "" in string context, usually with a warning.

Test for it with defined, not with a truth test, because a valid 0 or empty string is defined but false. defined $x is the correct check for presence.

$_ is the default variable. @_ holds a subroutine's arguments. $0 is the script name. $! is the last system error message. $@ holds the error from the most recent eval. @ARGV holds command-line arguments, and %ENV holds environment variables.

You don't need all of them memorized, but $_, @_, $!, and $@ come up constantly, so those four are worth knowing cold.

A one-liner is a whole program passed on the command line with -e, often with -n or -p to loop over input lines and -i to edit files in place. They turn Perl into a fast text tool for filtering, substituting, and reporting.

-n wraps your code in a read loop, -p does the same but prints each line, and combined with a substitution they replace many sed and awk tasks.

m// matches a pattern against a string, s/// substitutes matched text with a replacement, and tr/// transliterates characters one for one. You bind a pattern to a string with =~ (or !~ to negate).

Common modifiers: /g for all matches, /i for case-insensitive, /m for multiline anchors, /s to let . match newlines, and /x to allow whitespace and comments in the pattern. Regex is built into the language, which is a large part of why Perl exists.

Parentheses in a pattern capture the matched text into $1, $2, and so on, numbered by opening paren. In list context a match returns the captures directly. Named captures with (?<name>...) store into %+ for readability.

A backreference like \1 inside the pattern matches the same text a group already captured, which is how you find repeated words or balanced quotes.

/g replaces every match, not just the first. /e treats the replacement side as Perl code to evaluate, so you can compute the replacement. /r returns the modified copy and leaves the original untouched instead of editing in place.

/e is the one to highlight: it turns a substitution into a mini transform, letting you run a function on each match.

A reference is a scalar that points to another value: an array, a hash, another scalar, or a subroutine. You create one with the backslash operator and dereference it with a sigil to get the original value back.

References matter because Perl's arrays and hashes flatten when combined, so you can't nest them directly. A reference is a single scalar, so an array of array references gives you real nested data structures and lets you pass containers to subroutines without copying.

Square brackets create an anonymous array reference, and curly braces create an anonymous hash reference. You get a scalar reference directly, without naming an intermediate variable.

This is how you build nested structures: an array of hash references, a hash of array references, and so on. The arrow operator walks down the levels.

Put the right sigil in front of the reference: @$aref for the whole array, %$href for the whole hash, and $$sref for a scalar. For single elements use the arrow: $aref->[0] and $href->{key}. To get an array reference's length, use scalar @$aref.

The arrow can be omitted between subscripts, so $data->[0][1] and $data->[0]->[1] mean the same thing.

Arguments arrive flattened in the special array @_. You unpack them by assigning to a list, commonly my ($x, $y) = @_; at the top of the sub, or by shifting them off one at a time.

Because everything flattens into @_, passing arrays or hashes by value loses their boundaries; pass references instead so the sub knows where one container ends and the next begins.

A sub returns the value of its last expression unless you use an explicit return. What the caller gets can depend on context: you can check wantarray inside the sub to see whether it was called in list or scalar context and return accordingly.

A common pattern is returning a list in list context and a count or single value in scalar context, mirroring how built-ins like the match operator behave.

map transforms each element of a list and returns a new list, grep filters a list keeping elements where the block is true, and sort orders a list, by default as strings. All three set $_ to the current element inside their block.

sort takes an optional comparison block using $a and $b, so sort { $a <=> $b } sorts numerically. Chaining map, grep, and sort is idiomatic Perl for list pipelines.

By default sort compares elements as strings, so it orders them lexically: "10" comes before "2" because "1" is less than "2" character by character. That gives (10, 2, 33) as (10, 2, 33) ordered stringwise, not the numeric order you expect.

The fix is a numeric comparator: sort { $a <=> $b } @list. Use the spaceship operator <=> for numbers and cmp for strings.

wantarray returns true if the current subroutine was called in list context, false (but defined) if in scalar context, and undef if called in void context. It lets one sub adapt its return value to how it was called.

Use it sparingly; a sub that returns wildly different shapes depending on context can confuse callers. It's most justified when mirroring built-in behavior.

use loads a module at compile time and runs its import routine, bringing names into your namespace. require loads at runtime and does not import anything by itself. use Foo; is roughly a compile-time require Foo; plus Foo->import;.

Reach for use for normal module loading, and require when you want to defer loading until runtime, for example loading an optional dependency only if a feature is enabled.

CPAN is the Perl Archive Network, the central repository of open-source Perl modules and one of the language's oldest strengths: a large library of reusable code for everything from date handling to web frameworks.

You install modules with a client like cpan or cpanm, then load them with use. In real projects you pin versions and often use a local library setup (local::lib or a container) so installs are reproducible.

A slice reads or writes several elements at once. An array slice uses @ with a list of indices, and a hash slice uses @ with a list of keys, returning the matching values as a list.

Slices are compact for pulling a subset of a hash into variables or building a smaller hash. Since Perl 5.20 you can also take a key-value hash slice with the % sigil.

The x operator repeats: a string times a number repeats the string, and a list in parentheses times a number repeats the list. The range operator .. generates a sequence, numeric (1..5) or alphabetic (a..z), commonly used in for loops and slices.

In scalar context .. also works as a flip-flop operator for line-range selection, a niche feature worth naming but rarely written.

A heredoc is a multi-line string literal introduced with <<"LABEL" or <<'LABEL'. Everything up to a line containing only the label becomes the string. Double-quote-style interpolates variables; single-quote-style is literal.

Use heredocs for templates, SQL, HTML, or any block of text where line breaks matter. The indented form <<~LABEL (Perl 5.26+) strips leading whitespace so the closing label can be indented.

The ternary operator condition ? if_true : if_false chooses between two expressions. It reads well for a single decision and is fine chained for a few cases, but deeply nested ternaries become unreadable fast.

When a chain grows past two or three branches, a set of if/elsif blocks or a dispatch hash is clearer. Interviewers notice when readable structure loses to cleverness.

The classic mechanism is eval { ... }; which traps a die inside the block; after it, $@ holds the error message (empty on success). You check $@ to detect and handle the failure.

That pattern has subtle traps ($@ can be clobbered), so modern code uses Try::Tiny or the built-in try/catch feature to make the intent clear and the error handling reliable.

sprintf builds a formatted string from a template and a list of values, using the same conversion codes as C: %d for integers, %f for floats with a precision like %.2f, %s for strings, and width and padding flags in between.

It's the tool for aligned columns, fixed decimals, zero-padding, and hex or binary output. printf does the same but prints directly.

The built-in localtime and gmtime turn an epoch timestamp into date parts, but their return list is easy to misuse (the month is 0-based and the year is offset from 1900). For real work most teams use the DateTime module from CPAN, which handles arithmetic, time zones, and formatting correctly.

The honest interview coverage names both: localtime for a quick timestamp, DateTime when correctness across time zones matters.

Classic Perl OO is built from three pieces: a package is a class, a blessed reference (usually a hash reference) is an object, and a subroutine in the package is a method that receives the object as its first argument. bless ties a reference to a package so method calls dispatch to that package.

It's more manual than most languages, which is why modern code reaches for Moose or Moo to get attributes, accessors, and type checks declaratively. Knowing the raw mechanism and the modern tooling is The production-ready answer.

bless associates a reference with a package (class), so calling a method on it, like $obj->method, looks up method in that package and passes $obj as the first argument. Before bless, the reference is just data; after, it's an object.

You can ask an object what it is with ref($obj), which returns the package name for a blessed reference. That's how isa and can checks and duck-typing work under the hood.

Moose is a full object system for Perl that adds declarative attributes, type constraints, roles, method modifiers, and more, at the cost of a slower startup. Moo is a lighter subset with most of the everyday features and much faster load time, and it upgrades to Moose transparently if needed.

Reach for Moo in small tools and short-lived processes where startup time matters, and Moose in larger applications that use its deeper features. Both remove the hand-rolled constructor and accessor boilerplate of classic Perl OO.

Inheritance sets a package's @ISA (or use parent/use base) so method lookup falls through to parent classes. Perl supports multiple inheritance, with method resolution walking @ISA depth-first by default, or C3 order if you enable it.

Roles (via Moose or Moo) compose behavior into a class without an is-a relationship, which sidesteps the diamond problems of deep multiple inheritance. The modern guidance is composition through roles over deep inheritance trees.

A closure is an anonymous subroutine that captures lexical variables from the scope where it was defined, keeping them alive after that scope exits. Each closure gets its own copy of the captured variables.

Closures power counters, callbacks, iterators, and private state. A factory that returns a sub with a captured my variable is the canonical example, and it's how you get encapsulated state without a full class.

Each package has a symbol table, a hash mapping names to typeglobs. A typeglob (written *name) is the collection of everything a name can refer to at once: the scalar, array, hash, code, and filehandle slots for that name.

Aliasing a typeglob makes two names refer to the same underlying data, which is how older code shared filehandles or created aliases before references were common. Modern code rarely touches globs directly, but understanding them explains how symbolic references and Exporter work.

Perl uses reference counting: every value tracks how many references point to it, and when that count drops to zero the memory is freed. This is deterministic, so objects clean up as soon as the last reference goes away.

The weakness is circular references: two structures pointing at each other keep each other's count above zero and never free. The fix is Scalar::Util::weaken to make one side a weak reference that doesn't raise the count.

Symptoms are steady memory growth in a long-running process with no obvious unbounded cache. Because reference counting can't free a cycle, structures like parent-child trees or observer lists that point both ways leak until the process exits.

Find them by reasoning about which structures reference each other, or with tools like Devel::Cycle and Devel::Leak. Fix by weakening the back-reference (the child's pointer to its parent) so only the strong direction keeps the object alive.

Taint mode, enabled with the -T flag, marks all data from outside the program (command-line arguments, environment, file input, network) as tainted and refuses to use it in operations that affect the system, like running a shell command or opening a file for writing, until you explicitly untaint it.

You untaint by extracting the safe part through a regex capture. It's a defense against injection in setuid scripts and any program handling untrusted input, so naming it signals security awareness.

Data::Dumper serializes any nested Perl data structure into readable, re-parseable text, so you can print exactly what a reference contains. It's the first tool most Perl developers reach for when a structure isn't what they expect.

For interactive debugging, the built-in debugger (perl -d) lets you step, set breakpoints, and inspect variables. Between Data::Dumper for structure and perl -d for control flow, most bugs get cornered quickly.

A hard reference is a real pointer to a value: it keeps that value alive and is what \@array or [ ... ] produces. A symbolic reference is a string used as a variable name at runtime, so $$name looks up the package variable whose name is in $name.

Symbolic references are dangerous and blocked by use strict 'refs' because they let arbitrary strings poke at globals. Always prefer hard references; that's the whole point of the strict pragma flagging them.

Prototypes are an older, easily misunderstood feature that hints at how a sub should parse its arguments (for example forcing a block or a single array). They affect parsing, not validation, so they surprise people and are best avoided for normal code.

Signatures (stable since Perl 5.36) are the modern feature: sub add ($x, $y) { $x + $y } declares named parameters directly, with defaults and a slurpy final parameter. Use signatures for readable argument handling and reserve prototypes for the rare cases that need them.

binds an ordinary variable (scalar, array, hash, or filehandle) maps to a class so that every access to that variable runs a method behind the scenes. Reading a tied hash key can hit a database, and storing to a tied scalar can validate or log.

It's how modules like DB_File present an on-disk store as a normal hash. It's a specialty tool: clever, occasionally the right answer, but a maintenance surprise if overused, so name it and note its cost.

Measure before changing anything: Devel::NYTProf is the standard profiler and shows time per line and per subroutine against a real workload. Then fix in order of impact: better algorithms and data structures, avoiding needless copies of large arrays and hashes, precompiling regexes with qr//, and reducing I/O by batching.

The discipline the question needs is profile-first: assumptions about Perl bottlenecks are often wrong, and NYTProf points at the real hot spot.

qr// compiles a regular expression once into a reusable pattern object you can store in a variable and use later with =~. Without it, a pattern built from a variable can be recompiled on every match inside a loop.

Precompiling with qr// removes that repeated compilation and lets you build patterns from parts, combine them, and pass them around like any other value. In a hot loop the saving is real and measurable.

Perl distinguishes bytes from characters. To work with text correctly you decode input bytes into Perl's internal character strings and encode again on output, usually with the Encode module or by setting the encoding on a filehandle. use utf8; tells Perl your source file itself is UTF-8.

The classic bug is treating UTF-8 bytes as characters, which breaks length and regex on multibyte text. The rule to state: decode on input, work in characters, encode on output.

Perl's testing is built on Test::More, which gives functions like ok, is, and is_deeply that emit TAP (Test Anything Protocol) output. Test files live in a t/ directory and run with prove, which summarizes pass and fail counts.

For larger suites, Test2 is the modern framework, and modules like Test::MockModule handle mocking. A strong answer mentions testing behavior, using is_deeply for structures, and running the suite in CI.

A dispatch table is a hash mapping keys to code references, so you look up and call the right subroutine by key instead of walking a long if/elsif chain. It's faster to read, easy to extend, and turns control flow into data.

It shines for command handlers, state machines, and plugin-style routing. Adding a new case means adding a hash entry, not editing a branch, which keeps the logic flat.

Raku, originally announced as Perl 6, turned into a separate language with its own design and runtime rather than a new version of Perl 5. It was renamed Raku in 2019 to make the split clear. Perl 5 kept developing independently and is the Perl in production today.

So the correct framing in an interview is that they're two different languages that share heritage, not old and new versions of one. Answer Perl questions for Perl 5 unless the interviewer says Raku.

Start by reproducing or observing: check the exact Perl version and installed module versions, since a CPAN version drift is a frequent cause, then read the logs and any die or warn output around the failure. Confirm use strict and use warnings are on, because a silent undef or an uninitialized value is a common culprit.

For a leak, watch memory over time and look for unbounded structures or circular references, using Devel::NYTProf for CPU and Data::Dumper or Devel::Cycle for state. Then fix at the right layer and confirm with a measurement. The methodology, observe, hypothesize, verify, fix, confirm, is what matters.