Bash.CodeCompared.To/Perl

The semicolon is the visible change and the smallest one. say corresponds to echo almost exactly, including that it adds the newline; print is the one that does not, which is the reverse of what shell programmers expect from printf. Without use v5.38 (or use strict; use warnings;) Perl behaves like a shell in the one way you do not want — undeclared variables spring into existence — so treat it as mandatory rather than optional.

use strict is the important half. A misspelled variable in Bash expands to the empty string and the script carries on; under strict, a misspelled variable in Perl is a compile error and the script does not start at all. That is a stronger guarantee than set -u, which only fires when the line is reached. The habit worth forming: never write a Perl script without that first line, exactly as you would never write a shell script without set -euo pipefail.

Braces replace the matched keyword pairs, and unlike C the braces are required even for a single statement, so the dangling-else class of bug does not exist. Note eq rather than == for the string comparison: Perl has separate operators for numeric and string comparison (== against eq, < against lt), which is the same distinction Bash draws between -eq and == inside [[ ]] — with the spellings swapped, which catches everyone once.

The dollar sign staying on the left-hand side is the thing shell programmers find strangest: in Bash you write name= to set and $name to read, while in Perl the sigil is part of the variable's name and is always there. Once that clicks, the rest follows — and note that $count = 3 is a real number, not the one-character string that count=3 produces in the shell.

The shell has the same idea buried in worse syntax: ${names[1]} and ${names[@]} differ only by the subscript, and ${#names[@]} adds a hash on the front to mean something else entirely. Perl uses square brackets for arrays and curly braces for hashes, consistently, which is one fewer thing to look up. And a Perl hash key needs no quoting in the common case — $role{web} — where the shell's declare -A is easy to forget and silently ruins the subscript when you do.

Perl does have a version of this hazard and it is worth knowing about rather than being surprised by: an array interpolated into a string ("@names") is joined with spaces, and a list assigned to a scalar gives you its length rather than the list. But those are explicit conversions between explicit types, not an invisible re-splitting of every unquoted expansion, and neither is triggered by a space inside a filename.

This alone retires bc from a great many scripts. Note int() for the truncating division that $(( )) gives you — and note that int truncates toward zero rather than flooring, so int(-7/2) is -3, matching the shell. Perl also has the shell's numeric/string split in its operators rather than its syntax: + always adds numbers and . always joins strings, so "3" + 4 is 7 and 3 . 4 is "34", with no ambiguity about which was meant.

Perl adds qq{...} and q{...} as the same two quotes with a delimiter you choose, which is what saves you when the text is full of quotation marks — qq{he said "no"} needs no escaping at all. The habit that carries over badly is the shell's reflex to quote absolutely everything: in Perl, a variable is a variable whether or not it is inside quotes, so foo($name) is correct and foo("$name") is a needless copy.

The /r flag on the substitution is worth learning early: without it, s/// modifies the variable in place and returns how many replacements it made, which is a surprise if you expected the new string. File::Basename is core, so it needs no installation. For anything involving real paths prefer it — or File::Spec — over pattern-matching the string, for the same reason you would in any language.

The IFS dance in the left column is the source of a specific and nasty bug: forget the subshell parentheses around the assignment and IFS stays changed for the rest of the script, so unrelated code splits its words on the wrong character. Perl's split takes the separator as an argument, so nothing global changes, and the separator is a full regular expression — split /\s*,\s*/ handles the spaces around the commas in the same call.

Sorting is the row to notice. In the shell, sorting an array means printing it, piping it through sort, and reading the text back — a subprocess and a round trip through a stream. In Perl sort is an operator on the list itself, it takes a comparison block for anything non-alphabetical (sort { $a <=> $b } @numbers for numeric order), and nothing leaves the process. The @{[ ... ]} around it is the trick for running an expression inside a string.

Hashes are where Perl earns its reputation and where the shell most obviously runs out. keys, values, exists and delete are operators; a hash may be passed to a subroutine, returned from one, nested inside another hash, and sorted by value with a comparison block. Bash associative arrays can do none of those, need version 4 or later, and hold only strings — and the ${!counts[@]} spelling for the keys is a piece of punctuation nobody remembers unaided.

This is the single most-typed line in the history of Perl, and it is the reason so many sort | uniq -c | sort -rn pipelines became Perl scripts. The sort block shows the other half of the gain: <=> compares numbers, cmp compares strings, and || chains them into a tiebreak — sort by count descending, then by name — which in the shell means either a second sort -k with the right field numbers or giving up.

🚨 "0" being false is the Perl-specific trap, and it has no shell equivalent: a string containing just the digit zero is false, so if ($answer) on user input that is legitimately "0" takes the wrong branch. Use if (length $answer) or if (defined $answer) when the empty case is what you actually mean. Note also the operator pairs — ==/eq, !=/ne, </lt — which are the same numeric-versus-string distinction [[ ]] makes with -eq and ==, spelled the other way round.

One real gain: 1 .. $limit works, where the shell's {1..$limit} does not. Brace expansion happens before variables are substituted, so the shell version produces the literal text {1..3} and the loop runs once over a nonsense value — a bug that has caught everyone at least once and that seq exists to work around.

The dispatch table is a genuinely different capability rather than a translation. The handlers are values, so they can be added at run time, built from a configuration file, wrapped for logging, or tested one at a time — none of which a case statement allows. For the simple string-matching cases an if/elsif chain is perfectly good and clearer; reach for the table when there are more than about four branches or when the set of branches is not fixed.

Three things improve at once. The captures have names, so line 40 of the script is readable. The result is a value rather than a global, so an unrelated match two lines later cannot clobber it. And the pattern is not passing through the shell's quoting first — notice the backslash-escaped spaces the Bash version needs, and the fact that quoting the pattern in [[ ]] would turn the whole regular expression off. Perl was designed around this operator and it shows.

Two Perl-side gains. The replacement is Perl code if you ask for it (s/(\d+)/$1 * 2/e doubles every number, which sed cannot do at all), and the captures are $1, $2, $3 rather than \1 after shell quoting has had a turn. The /r flag returns the modified copy and leaves the original alone; without it, s/// modifies the variable in place and returns a count, which is the single most common surprise for someone arriving from sed.

The shell has no way to say "give me every match" — [[ =~ ]] finds one, BASH_REMATCH holds that one, and getting the rest means either a loop that eats the string as it goes or shelling out to grep -o. Perl returns them as a list. List::Util is core — no installation — and brings sum0, max, min, first, any and uniq, which between them retire a large fraction of the awk in a typical script.

awk is very good at this and a one-line field extraction should stay one line of awk. What Perl offers is names instead of $2, and the fact that the same program can then do something the pipeline cannot — look a value up in a hash, keep a running total in a real number, or write two output files at once. The line where a script stops being a pipeline and starts being a program is usually the line where a second stage needs to remember something.

This is the argument of the whole page in one row. The left column is a small program written in four languages — shell quoting, a basic regular expression, an extended one, and awk — each with its own escaping rules, running as four processes. The right column is one language, one set of rules, one process, and every intermediate value is available to be counted, reused or written somewhere else. The right column is also, honestly, harder to read at a glance than the pipeline; the trade is that it stays readable as the job grows, and the pipeline does not.

The for @lines at the end of the substitution is doing something the shell cannot: $_ is an alias to each element, so modifying it modifies the array in place. That is why the loop needs no assignment. If the edit has any conditional logic in it — change this line only when that other line said something — the one-liner stops being enough, and the script form is where you were always going to end up.

chomp is the one to remember: <$read> keeps the newline on the end of each line, where the shell's read strips it. Forgetting chomp produces output with blank lines in it and comparisons that mysteriously fail, and it is the most common first-week Perl bug. The three-argument open shown here is the only form to use — the older two-argument version interprets characters in the filename and is a genuine security hazard.

One difference is useful rather than annoying: -s returns the file's size rather than merely a true value, so it can be used in arithmetic. Another is -M and -A, giving age in days since the script started, which the shell has no equivalent for at all. And because these are expressions rather than commands, they combine with ordinary boolean operators instead of needing [[ ... && ... ]].

An unmatched shell glob expands to the pattern itself, so a loop body runs once with a filename that does not exist — the bug shopt -s nullglob exists to prevent and that nobody remembers to enable. glob returns an empty list, so the loop simply does not run. For walking a tree, File::Find is core and replaces find without a subprocess or a -print0/xargs -0 dance over filenames with spaces in them.

🚨 $? holds the wait status rather than the exit code, so it must be shifted right by eight to get the number the shell puts in $?. That is a genuine wart. The bigger warning is that qx and the one-argument system both hand your string to a shell, so a filename with a space or a semicolon in it is an injection: use the list form, system('sort', $file), whenever any part of the command comes from data.

Notice that the sorting moved out of the pipeline and into Perl, which is the usual outcome: once the data is inside the program there is rarely a reason to send it back out to a utility. The list form of open is the safe one and is worth making a habit, exactly as it is in every other language on this site. There is a matching |- mode for writing to a program's standard input.

Assigning to %ENV is the equivalent of export: it affects processes this script starts afterwards and nothing else. The shell's distinction between a plain variable and an exported one has no counterpart, because a Perl variable is not in the environment at all unless you put it there — which is the clearer arrangement of the two.

The local that the shell version depends on is not needed, because my in a subroutine is already scoped to it and use strict will not let you forget. Perl's own local is a different and rarer thing — a temporary value for a global, restored when the block exits — and it is not the keyword you want here.

Three costs vanish at once. There is no fork, so a script can be decomposed into small subroutines without paying for it. The value keeps its type, so a number stays a number and a list stays a list. And returning two things is return ($low, $high) rather than an encoding the caller has to reverse — which is the point at which shell scripts usually start passing data through global variables and become hard to follow.

References are how Perl holds anything nested: \@array and \%hash make one, $reference->{key} and $reference->[0] follow one, and %$reference treats it as a whole hash again. It takes an afternoon and it is the whole difference between a script that can describe its data and one that has to encode it into a string. Note the port is a real number here, comparable and addable, where every value in the left column is text.

Bash 4.3 added namerefs, which pass the variable's name and let the callee alias it — it works, it is not widely known, and it puts the caller's variable name into the callee's hands, which is exactly backwards. Perl's version has the ordinary property you expect: the reference is a value, so it can be stored in another structure, returned, or put in a list of references. Note that a plain @names passed to a subroutine is flattened into the argument list, which is why the reference is needed to keep it whole.

Encoding takes a data structure rather than text, so quoting is not a decision the caller can get wrong — the same argument that applies to building SQL, HTML or a shell command. canonical sorts the keys so the output is reproducible, which matters when it is compared or checked into version control. Decoding with decode_json gives you nested hashes and arrays, where jq can only hand back text for the shell to re-parse.

Perl 5.34 added real try/catch blocks under use feature 'try', and they are worth using in new code — the eval form shown here is what you will read in everything older. Either way, the gain over set -e is that a failure carries a message and a type rather than a number from 0 to 255, and that the rule for what propagates is one sentence rather than the list of exceptions set -e has accumulated.

An exit status is one number out of 256 and the message is unstructured text on another stream, so a caller can only tell failures apart by convention. A thrown error carries whatever you put in it, including an object with fields, and die automatically appends the file and line when the message does not end in a newline — which is why the examples here end theirs with \n, to suppress it. exit still exists for the boundary where a Perl script really does have to answer a shell.

So moving to Perl does not mean abandoning the shell — a Perl one-liner sits in a pipeline exactly where awk did, and reaches for a hash or a module when the job outgrows a single expression. -p is -n plus printing each line, which with -i is the in-place editor from the Text section. The migration this page describes is usually gradual for exactly this reason: one stage at a time.

Long options are the whole point. getopts handles single letters and nothing else, so every shell script that accepts --dry-run contains a hand-rolled parsing loop with its own bugs and its own usage message that drifts out of date. Getopt::Long also does abbreviation, negation (--no-verbose), repeated options collecting into an array, and =i for values that must be integers.

A module is loaded once however many files ask for it, so there is no include-guard problem, and the use lines at the top of a file are an honest inventory of what it depends on. The other half is CPAN, which is the largest and oldest module archive of its kind — and the counterweight is that a script depending on CPAN modules needs them installed wherever it runs, which is precisely the deployment simplicity that keeps things in shell.

Testability is the quiet reason scripts get rewritten. A shell function can only be tested through the text it prints, so the test asserts on formatting as well as behavior and breaks when a message is reworded. A subroutine returns a value, so the test checks the value and ignores the presentation — and prove, also core, runs a directory of such files and summarizes them.

The test is not length, it is whether the script has logic — data with more than one level, arithmetic beyond counting, error handling that must tell failures apart, several options, or anything the next person will have to modify under pressure. Orchestration and glue belong in the shell. And the migration need not be all at once: a Perl one-liner is a pipeline stage, so the usual path is to replace the gnarliest stage first and leave the rest alone.