Ruby.CodeCompared.To/Perl

use v5.38 is the modern Perl preamble — it enables strict, warnings, and the say function all at once. say is Ruby's puts: it prints the string followed by a newline. Without say, the equivalent is print "Hello, World!\n" with an explicit newline. Every Perl statement ends with a semicolon.

Perl only has single-line comments with # — exactly like Ruby. There is no /* */ block comment syntax. Multi-line documentation uses Pod (Plain Old Documentation): =begin comment … =end comment, but this is rare in everyday code. Ruby's =begin / =end block comment was borrowed directly from Perl's Pod syntax.

Every Perl statement must end with a semicolon — there is no optional-semicolon rule. Forgetting a semicolon is the most common Perl beginner error. Ruby's newline-as-statement-terminator does not apply in Perl. The my keyword declares a lexically scoped variable; use v5.38 (which enables strict) makes my mandatory.

say (available since Perl 5.10, enabled by use v5.38) works exactly like Ruby's puts — it appends a newline automatically. print is like Ruby's print: no trailing newline. say is almost always preferred for interactive output.

Perl's false values are undef, 0, "" (empty string), and "0" (the string zero). Everything else is true — including "00", " " (a space), and even "false". Ruby is simpler: only false and nil are falsy. The "0" trap catches many Rubyists off guard.

All scalar variables begin with $. The my keyword declares a lexically scoped variable — always required when use strict is active (which use v5.38 enables). Ruby uses bare names for local variables; Perl requires the sigil always. Strings and numbers are the same scalar type — Perl coerces between them automatically.

Array variables use the @ sigil. Interpolating @colors in a double-quoted string inserts all elements separated by a space. Individual elements use $ (not @) because you are accessing a scalar value from the array. The scalar() function forces scalar context, returning the element count — Perl's equivalent of Ruby's .length.

Hash variables use the % sigil. The fat comma => auto-quotes the left side, so barewords like name do not need quotes. Individual values use $ because you are accessing a scalar. Hash elements use curly braces {} while array elements use square brackets [].

Perl's most distinctive feature is context: the same expression evaluates differently depending on whether a scalar or list is expected. In scalar context, an array returns its element count. In list context, it returns its elements. Forgetting this causes subtle bugs — for example, my $count = @array gives the count, not a reference. Ruby requires an explicit .length or .size call; Perl infers it from context.

The sigil changes based on what you are retrieving, not where it lives. A single element always uses $. A slice (multiple elements at once) uses @. This "sigil follows context" rule is one of Perl's most confusing aspects for newcomers, but it is perfectly consistent: $ means "one thing", @ means "multiple things".

undef is Perl's equivalent of Ruby's nil. Use defined() to test for it — a plain boolean test is insufficient because 0 and "" are also false but are defined. The // defined-or operator (Perl 5.10+) tests definedness rather than truthiness, making it safer than || when 0 or "" are valid values.

Perl uses . for string concatenation (not + as in JavaScript). The x operator repeats a string a given number of times — Ruby uses * for the same purpose. Using + for string concatenation in Perl silently coerces both sides to numbers, which is almost always a bug.

Double-quoted strings interpolate $scalar, @array (space-separated), and $hash{key} directly. Single-quoted strings interpolate nothing — only \\ and \' are special. Perl's interpolation is simpler than Ruby's #{} — you cannot embed arbitrary expressions directly, but scalar/array/hash access covers the common cases.

Perl heredocs use <<LABEL. Double-quoted heredocs interpolate variables; single-quoted heredocs (<<'LABEL') do not — matching the behavior of regular quoted strings. Perl 5.26+ added <<~LABEL (with tilde) which strips leading whitespace from each line, identical to Ruby's <<~HEREDOC.

chomp removes the trailing record separator (usually \n) from a string or all elements of an array, modifying in place. It is idiomatic in any Perl program that reads input line by line — while (<$fh>) { chomp; ... }. Ruby's String#chomp! is a direct descendant. Unlike Ruby's strip, chomp only removes the line separator, not all whitespace.

Perl's string functions are standalone functions, not methods — you pass the string as an argument: uc($string) rather than $string.upcase. The direct equivalents are: length → String#length, uc → #upcase, lc → #downcase, ucfirst → #capitalize, substr → #slice, index → #index.

The .. range operator creates a list of consecutive numbers or single characters, identical to Ruby's ... The qw(...) (quote-words) operator creates a list of whitespace-separated strings without requiring quotes around each word — Ruby's equivalent is the %w[] literal. Arrays in Perl are dynamic and grow automatically, just like Ruby arrays.

push/pop work on the tail; shift/unshift work on the head — identical in purpose to Ruby's Array#push, #pop, #shift, #unshift. In Perl these are standalone functions that take the array as the first argument rather than methods called on the array.

grep is Perl's equivalent of Ruby's select — it filters an array, keeping elements where the block is true. map transforms each element, identical to Ruby's map. Both use $_ as the current element in the block. They are fundamental Perl idioms that predate Ruby's equivalent methods — Ruby borrowed the concept from Perl.

sort without a comparison block sorts lexicographically. For numeric sort, provide a block using the special variables $a and $b. The <=> spaceship operator returns -1, 0, or 1 for numeric comparisons; cmp does the same for strings. Ruby's <=> is directly inherited from Perl, which invented the operator.

join takes the separator first, then the array — unlike Ruby's Array#join which takes the separator as a method argument. split takes a regex or string delimiter and the target string. Both work identically to Ruby's equivalents. Note the argument order: in Perl join(separator, @array); in Ruby array.join(separator).

splice is Perl's all-in-one array modifier. It can remove elements (like Ruby's slice! or delete_at), insert elements (like insert), or replace elements — all in one call. The arguments are the array, the starting offset, the number of elements to remove, and optionally replacement elements. The removed elements are returned.

Hashes use the % sigil and curly braces for element access. The fat comma => auto-quotes the left operand, so barewords are fine as keys. Hash values are accessed with $hash{key} — the $ sigil because you are retrieving a single scalar value. Ruby's hash[:key] and Perl's $hash{key} serve the same purpose.

keys and values return lists in arbitrary order — always sort when order matters. each iterates key-value pairs two at a time; it is Perl's equivalent of Ruby's Hash#each. The hash iteration order is randomized per-process in modern Perl (a security feature against hash-flooding attacks), mirroring Ruby's insertion-order guarantee only from Ruby 1.9 onward.

exists tests whether a key is present — not whether the value is defined. A key can exist with an undef value. delete removes a key-value pair entirely and returns the value. Ruby's equivalents are Hash#key? (or has_key?) and Hash#delete. Both languages use the same method names for the same operations.

A hash slice uses @hash{@keys} to access or assign multiple keys at once. The @ sigil signals a list result. qw(...) is the word-list quoting shorthand. You can also assign a slice: @hash{@keys} = @values. Ruby achieves the same with Hash#values_at for reading.

Perl uses elsif (no extra 'e') — a common stumbling block coming from other languages. The condition parentheses are required in Perl; Ruby makes them optional. Curly braces are always required around the body in Perl. This is the same structure Ruby uses, just with mandatory parentheses and braces.

Perl has unless — Ruby borrowed it directly. Both languages use the same keyword for the same purpose: run the block when the condition is false. The ternary operator ? : is also identical. Perl additionally has until (negate while) and postfix forms for both, all of which Ruby also adopted.

Postfix if, unless, while, until, and for/foreach are all valid in Perl. Ruby borrowed all of these directly. Postfix forms make short conditional statements read like English and are idiomatic in both languages. In Perl's postfix for, the current element is available in $_.

for and foreach are interchangeable aliases in Perl. The idiomatic form declares the loop variable with my. The C-style three-expression for loop also exists. Ruby's block-based each is the direct equivalent of foreach — the iteration mechanism differs (method + block vs. statement), but the purpose is identical.

until is the negated while — Perl and Ruby share it. Perl also has do { ... } while (...) which runs the body at least once. Perl's ++ and -- operators are inherited from C; Ruby also has them. The string increment $str++ is a unique Perl feature: "aa"++ yields "ab".

last is Perl's break — equivalent to Ruby's break. next skips to the next iteration — equivalent to Ruby's next. Perl also has redo, which restarts the current iteration without re-evaluating the condition. Ruby's next keyword was borrowed directly from Perl.

Subroutines are declared with sub. All arguments arrive as a flat list in the special array @_. The idiomatic first line of any subroutine is my ($arg1, $arg2) = @_ to unpack arguments into named variables. The return keyword is optional — Perl returns the last evaluated expression, just like Ruby.

Perl has no built-in default parameter syntax. The idiomatic pattern is $var //= "default" — the defined-or assignment. This is safer than ||= because ||= treats 0 and "" as missing, while //= only treats undef as missing. Ruby 2.0+ added native keyword arguments with defaults; Perl relies on this convention.

Perl subroutines return a flat list — just use a list return and unpack with parallel assignment. There is no need to wrap results in an array. Ruby also supports multiple return values via array unpacking (return [a, b] and a, b = method), but Perl's mechanism is built into the language's core list semantics.

Anonymous subroutines are created with sub { ... } without a name and stored in a scalar. They are invoked using the arrow operator ->(). Perl closures capture lexical variables just as Ruby's blocks and lambdas do. This is Perl's equivalent of Ruby's -> lambda or Proc.new.

wantarray lets a subroutine detect whether its caller expects a list or a scalar, and return different things accordingly. This is a uniquely Perl capability — Ruby has no equivalent. Many built-in Perl functions are context-sensitive in this way. It is powerful but can make code surprising to read; modern Perl style prefers explicit return values.

The =~ binding operator applies a regex to a string — Ruby inherited this directly from Perl, including the operator name. Parentheses in the pattern capture into $1, $2, etc. — also identical to Ruby's $1, $2. Perl's regex engine is the canonical one that most modern languages reference.

s/pattern/replacement/flags substitutes the first match. Adding /g replaces all occurrences — like Ruby's gsub. Without /g, only the first match is replaced — like Ruby's sub. Perl's s/// modifies the string in place; Ruby's sub/gsub return new strings (use sub!/gsub! for in-place). The (my $copy = $orig) =~ s/... pattern creates a modified copy.

Named captures use (?<name>...) and are accessed via the %+ hash. Ruby uses the identical (?<name>...) syntax and accesses them via MatchData with match[:name]. Perl introduced named captures in version 5.10; Ruby adopted exactly the same syntax.

In list context, =~ with /g collects all matches at once — identical to Ruby's String#scan. In scalar context inside a while loop, /g iterates through matches one at a time using an internal position pointer (pos()). Both patterns are idiomatic Perl for processing all occurrences of a pattern in a string.

Perl regex modifiers follow the closing delimiter: /i for case-insensitive, /g for global, /x for extended (whitespace and comments allowed), /s for dot-matches-newline, /m for multiline anchors. Ruby uses the same modifiers in the same position — all inherited from Perl. The /x modifier is especially valuable for complex patterns.

A reference is a scalar holding the memory address of another value. References are created with \ and dereferenced with $$ (scalar), @$arr (array), or %$hash (hash). The ref() function returns the type string ("SCALAR", "ARRAY", "HASH", "CODE"). Ruby does not need explicit references because all objects are already reference types.

[...] creates an anonymous array reference and {...} creates an anonymous hash reference — these are directly analogous to Ruby's [] and {} which create Array and Hash objects. The arrow operator -> dereferences and accesses an element in one step: $arr->[0] and $hash->{key}.

Complex data structures in Perl are built from references. An array of hash references is the direct equivalent of Ruby's array of hashes. The -> arrow chains dereferencing: $person->{scores} gets the array reference, then @{...} dereferences it to a list. Perl requires explicit reference/dereference steps where Ruby's uniform object model makes this invisible.

Code references (anonymous subroutines stored in scalars or hashes) are Perl's first-class functions. They can be stored in data structures, passed as arguments, and returned from subroutines — exactly like Ruby's Proc and lambda objects. The ref($func) eq "CODE" check confirms a variable holds a code reference.

Perl OOP is built on bless — a function that associates a hash reference with a package name, making it an object. The new constructor is a convention, not a keyword. my $self = shift is the idiomatic way to extract the invocant (the object the method was called on). Ruby's class, initialize, and self make OOP more ergonomic; Perl's approach is explicit and manual.

Perl has no built-in accessor generation — every getter and setter is written by hand. The combined getter/setter pattern (if @_ to detect a setter call) is a common Perl idiom. Ruby's attr_reader, attr_writer, and attr_accessor generate these methods automatically; the CPAN modules Moose and Moo provide similar convenience for Perl.

Perl inheritance is declared by setting @ISA to a list of parent class names. Method resolution searches @ISA depth-first. SUPER:: calls a parent method. This manual mechanism does what Ruby's class Dog < Animal does automatically. Modern Perl typically uses use parent 'Animal' instead of manipulating @ISA directly.

die is Perl's raise; eval { } is the try-block equivalent of Ruby's begin/rescue/end. After an eval, $@ holds the caught exception (or "" on success). If die is given a string ending in \n, Perl omits the at file line N suffix — a useful convention for user-facing error messages.

warn prints to STDERR and continues execution — identical to Ruby's warn. Without a trailing \n, Perl appends the file and line number to the message, which is useful for debugging. The $SIG{__WARN__} handler can intercept warnings, similar to Ruby's Warning module.

The or die pattern is ubiquitous in Perl: open(...) or die "Could not open: $!". Any expression that returns false can have or die "message" chained to it. $! contains the operating system error string (errno). Ruby's equivalent raises exceptions directly from the method (File.open raises Errno::ENOENT) rather than returning false.

die can throw any value, including a blessed object — Perl's equivalent of raising a custom exception class. The ref $error check confirms it is a reference (not a plain string), and isa checks the class hierarchy. Ruby's rescue AppError => e handles the type check automatically; Perl requires manual inspection of $@.

The three-argument form of open is always preferred: mode and filename are separate arguments, preventing a class of injection vulnerabilities. <$fh> reads one line at a time in a while loop — the canonical Perl idiom for line-by-line processing. chomp strips the trailing newline. Ruby's File.open with a block automatically closes the file; Perl requires explicit close.

> truncates and writes; >> appends. say $fh $data and print $fh $data accept a filehandle as the first argument with no comma — an unusual Perl syntax. Ruby uses file.puts line (method call syntax). File::Slurp or Path::Tiny from CPAN simplify file I/O the way Ruby's File.write and File.read do.

Perl file test operators are single or double-character operators prefixed with -: -e (exists), -f (plain file), -d (directory), -r (readable), -s (non-zero size). Ruby's File.exist?, File.file?, File.directory? are the equivalents. Ruby borrowed its file test design from Perl.

$_ is Perl's implicit "topic" variable — the default argument for many built-in functions (print, chomp, length, uc, etc.) and the implicit loop variable in for and while (<>). Ruby's block parameters make this implicit topic explicit, but Perl one-liners rely heavily on $_ to keep code short.

$0 holds the script name, @ARGV holds command-line arguments, %ENV is the environment hash, and $$ is the process ID. Ruby's $PROGRAM_NAME (or $0), ARGV, ENV, and $$ are direct descendants — Ruby preserved Perl's naming conventions for these global variables.

$@ captures the value passed to die inside an eval block — Perl's exception variable. $! is the operating system error string (like C's errno), set automatically when a system call fails. Ruby uses exception objects caught by rescue instead of these global variables, but Errno exception classes correspond directly to $! values.