PERLOP(1perl)
โจ NAME โจ
okay so bestie, this is perlop โ the manual page for Perl expressions: operators, precedence, string literals. And it's from the Perl Programmers Reference Guide, section 1perl. No cap, this is the whole vibe. ๐
๐ฌ DESCRIPTION ๐ฌ
In Perl, the operator is the main character โ it decides what operation happens, no matter what type the operands are. Like, $x + $y is always a numeric addition, periodt. And if $x or $y don't contain numbers? Perl's gonna try to convert them to numbers first. It's giving "math is math". โจ
This is highkey different from lots of other dynamic languages, where the operation is like "whatever the first argument's type is, I guess." So Perl has two versions of some operators: one for numeric, one for string comparison. For example, $x == $y compares two numbers for equality, and $x eq $y compares two strings. Slay. ๐
But wait, there are a few exceptions though, bestie: The operator x can be either string repetition or list repetition, depending on the type of the left operand. And &, |, ^, and ~ can be either string or numeric bit operations โ unless use v5.28 or later, or The 'bitwise' feature in feature is in effect. In that case, a different version of each operator exists for manipulating strings. Iconic. ๐
๐ Operator Precedence and Associativity ๐
Operator precedence and associativity in Perl work more or less like they do in mathematics. ๐งฎ
Operator precedence means some operators group more tightly than others. For example, in 2 + 4 * 5, the multiplication has higher precedence, so 4 * 5 is grouped together as the right-hand operand of the addition, rather than 2 + 4 being grouped together as the left-hand operand of the multiplication. It's as if the expression were written 2 + (4 * 5), not (2 + 4) * 5. So the expression yields 2 + 20 == 22, rather than 6 * 5 == 30. No cap. ๐ฅ
Operator associativity defines what happens if a sequence of the same operators is used one after another: usually that they'll be grouped at the left or the right. For example, in 9 - 3 - 2, subtraction is left associative, so 9 - 3 is grouped together as the left-hand operand of the second subtraction, rather than 3 - 2 being grouped together as the right-hand operand of the first subtraction. It's as if the expression were written (9 - 3) - 2, not 9 - (3 - 2). So the expression yields 6 - 2 == 4, rather than 9 - 1 == 8. ๐ฏ
For simple operators that evaluate all their operands and then combine the values in some way, precedence and associativity (and parentheses) imply some ordering requirements on those combining operations. For example, in 2 + 4 * 5, the grouping implied by precedence means that the multiplication of 4 and 5 must be performed before the addition of 2 and 20, simply because the result of that multiplication is required as one of the operands of the addition. But the order of operations is not fully determined by this: in 2 * 2 + 4 * 5 both multiplications must be performed before the addition, but the grouping doesn't say anything about the order in which the two multiplications are performed. In fact Perl has a general rule that the operands of an operator are evaluated in left-to-right order. A few operators such as &&= have special evaluation rules that can result in an operand not being evaluated at all; in general, the top-level operator in an expression has control of operand evaluation. ๐
Some comparison operators, as their associativity, chain with some operators of the same precedence (but never with operators of different precedence). This chaining means that each comparison is performed on the two arguments surrounding it, with each interior argument taking part in two comparisons, and the comparison results are implicitly ANDed. Thus $x < $y <= $z behaves exactly like $x < $y && $y <= $z, assuming that $y is as simple a scalar as it looks. The ANDing short-circuits just like && does, stopping the sequence of comparisons as soon as one yields false. โก
In a chained comparison, each argument expression is evaluated at most once, even if it takes part in two comparisons, but the result of the evaluation is fetched for each comparison. (It is not evaluated at all if the short-circuiting means that it's not required for any comparisons.) This matters if the computation of an interior argument is expensive or non-deterministic. For example,
if ($x < expensive_sub() <= $z) { ...is not entirely like
if ($x < expensive_sub() && expensive_sub() <= $z) { ...but instead closer to
my $tmp = expensive_sub();
if ($x < $tmp && $tmp <= $z) { ...in that the subroutine is only called once. However, it's not exactly like this latter code either, because the chained comparison doesn't actually involve any temporary variable (named or otherwise): there is no assignment. This doesn't make much difference where the expression is a call to an ordinary subroutine, but matters more with an lvalue subroutine, or if the argument expression yields some unusual kind of scalar by other means. For example, if the argument expression yields a tied scalar, then the expression is evaluated to produce that scalar at most once, but the value of that scalar may be fetched up to twice, once for each comparison in which it is actually used. ๐คฏ
In this example, the expression is evaluated only once, and the tied scalar (the result of the expression) is fetched for each comparison that uses it.
if ($x < $tied_scalar < $z) { ...In the next example, the expression is evaluated only once, and the tied scalar is fetched once as part of the operation within the expression. The result of that operation is fetched for each comparison, which normally doesn't matter unless that expression result is also magical due to operator overloading.
if ($x < $tied_scalar + 42 < $z) { ...Some operators are instead non-associative, meaning that it's a syntax error to use a sequence of those operators of the same precedence. For example, $x .. $y .. $z is an error. ๐
Perl operators have the following associativity and precedence, listed from highest precedence to lowest. Operators borrowed from C keep the same precedence relationship with each other, even where C's precedence is slightly screwy. (This makes learning Perl easier for C folks.) With very few exceptions, these all operate on scalar values only, not array values.
left terms and list operators (leftward)
left ->
nonassoc ++ --
right **
right ! ~ ~. \ and unary + and -
left =~ !~
left * / % x
left + - .
left << >>
nonassoc named unary operators
nonassoc isa
chained < > <= >= lt gt le ge
chain/na == != eq ne <=> cmp ~~
left & &.
left | |. ^ ^.
left &&
left || ^^ //
nonassoc .. ...
right ?:
right = += -= *= etc. goto last next redo dump
left , =>
nonassoc list operators (rightward)
right not
left and
left or xorThe following sections cover these operators in detail. Each section covers all the operators for a single precedence level. The sections are ordered highest precedence first, same as in the table above. ๐
Many operators can be overloaded for objects. See overload. ๐ฆ
๐ญ Terms and List Operators (Leftward) ๐ญ
A TERM has the highest precedence in Perl. They include variables, quote and quote-like operators, any expression in parentheses, and any function whose arguments are parenthesized. Actually, there aren't really functions in this sense, just list operators and unary operators behaving as functions because you put parentheses around the arguments. These are all documented in perlfunc. ๐
If any list operator (print(), etc.) or any unary operator (chdir(), etc.) is followed by a left parenthesis as the next token, the operator and arguments within parentheses are taken to be of highest precedence, just like a normal function call. โจ
In the absence of parentheses, the precedence of list operators such as print, sort, or chmod is either very high or very low depending on whether you're looking at the left side or the right side of the operator. For example, in
@ary = (1, 3, sort 4, 2);
print @ary; # prints 1324the commas on the right of the sort are evaluated before the sort, but the commas on the left are evaluated after. In other words, list operators tend to gobble up all arguments that follow, and then act like a simple TERM with regard to the preceding expression. Be careful with parentheses:
# These evaluate exit before doing the print:
print($foo, exit); # Obviously not what you want.
print $foo, exit; # Nor is this.
# These do the print before evaluating exit:
(print $foo), exit; # This is what you want.
print($foo), exit; # Or this.
print ($foo), exit; # Or even this.Also note that
print ($foo & 255) + 1, "\n";probably doesn't do what you expect at first glance. The parentheses enclose the argument list for print which is evaluated (printing the result of $foo & 255). Then one is added to the return value of print (usually 1). The result is something like this:
1 + 1, "\n"; # Obviously not what you meant.To do what you meant properly, you must write:
print(($foo & 255) + 1, "\n");See "Named Unary Operators" for more discussion of this. ๐
Also parsed as terms are the do {} and eval {} constructs, as well as subroutine and method calls, and the anonymous constructors [] and {}. ๐
See also "Quote and Quote-like Operators" below, as well as "I/O Operators". ๐
๐น The Arrow Operator ๐น
-> is an infix dereference operator, just as it is in C and C++. If the right side is one of a [...], {...}, or a (...) subscript, then the left side must be either a hard or symbolic reference to an array, a hash, or a subroutine respectively. (Or technically speaking, a location capable of holding a hard reference, if it's an array or hash reference being used for assignment.) See perlreftut and perlref. ๐
Otherwise, the right side is a method name or a simple scalar variable containing either the method name or a subroutine reference, and (if it's a method name) the left side must be either an object (a blessed reference) or a class name (that is, a package name). See perlobj. ๐
The right side may also be the name of a subroutine, prefixed with the & sigil. This creates what looks like a lexical method invocation, where the method subroutine is resolved lexically instead of by name by a search within the packages of the object's class. This resolution happens entirely at compile-time, and performs the same as a regular subroutine call at runtime. ๐ง
Okay so the dereferencing cases (as opposed to the method-calling ones, bestie, they are not the same) are kind of extended by the "postderef" feature โจ. For the whole rundown on that, go peek at "Postfix Dereference Syntax" in perlref ๐ซถ.
๐ฅ Auto-increment and Auto-decrement ๐ฅ
"++" and "--" work just like in C, no cap. So if you drop them before a variable, they increment or decrement it by one before handing the value back, and if you put them after, they do the incrementing or decrementing after returning the value ๐
.
$i = 0; $j = 0;
print $i++; # prints 0
print ++$j; # prints 1Now listen, and this is the important part ๐: just like in C, Perl does not define when the variable gets incremented or decremented. All you know is that it's gonna happen, like, sometime before or after the value comes back. Which also means if you modify a variable twice in the same statement, that's undefined behavior, periodt ๐. Avoid statements like:
$i = $i ++;
print ++ $i + $i ++;Perl will not guarantee what the result of the above statements is. Not even a little ๐.
The auto-increment operator has a lil extra builtin magic to it though โจ. If you increment a variable that's numeric, or that has ever been used in a numeric context, you get a normal increment. If, however, the variable has been used in only string contexts since it was set, and has a value that's not the empty string and matches the pattern /^[a-zA-Z]*[0-9]*\z/, then the increment is done as a string โ preserving each character within its range, with carry ๐:
print ++($foo = "99"); # prints "100"
print ++($foo = "a0"); # prints "a1"
print ++($foo = "Az"); # prints "Ba"
print ++($foo = "zz"); # prints "aaa""undef" is always treated as numeric, and in particular gets changed to 0 before incrementing (so a post-increment of an undef value will return 0 rather than "undef") ๐.
The auto-decrement operator is not magical. Sorry bestie, no string magic on that one ๐ญ.
๐ Exponentiation ๐
Binary "**" is the exponentiation operator, and she binds even more tightly than unary minus, so "-2**4" is "-(2**4)", not "(-2)**4" ๐. (This is implemented using C's pow(3) function, which actually works on doubles internally.)
Okay but heads up ๐จ: certain exponentiation expressions are ill-defined. These include "0**0", "1**Inf", and "Inf**0". Do not expect any particular results from these special cases โ the results are platform-dependent ๐.
๐ซ Symbolic Unary Operators ๐ซ
Unary "!" performs logical negation, that is, "not". See also "not" for a lower precedence version of this ๐.
Unary "-" performs arithmetic negation if the operand is numeric, including any string that looks like a number. If the operand is an identifier, a string consisting of a minus sign concatenated with the identifier is returned. Otherwise, if the string starts with a plus or minus, a string starting with the opposite sign is returned ๐. One effect of these rules is that "-bareword" is equivalent to the string "-bareword". If, however, the string begins with a non-alphabetic character (excluding "+" or "-"), Perl will attempt to convert the string to a numeric, and the arithmetic negation is performed. If the string cannot be cleanly converted to a numeric, Perl will give the warning Argument "the string" isn't numeric in negation (-) at .... ๐ญ
Unary "~" performs bitwise negation, that is, 1's complement. For example, "0666 & ~027" is 0640 ๐งฎ. (See also "Integer Arithmetic" and "Bitwise String Operators".) Note that the width of the result is platform-dependent โ "~0" is 32 bits wide on a 32-bit platform, but 64 bits wide on a 64-bit platform, so if you're expecting a certain bit width, remember to use the "&" operator to mask off the excess bits ๐
.
Starting in Perl 5.28, it is a fatal error to try to complement a string containing a character with an ordinal value above 255 ๐จ.
If the "bitwise" feature is enabled via use feature 'bitwise' or use v5.28, then unary "~" always treats its argument as a number, and an alternate form of the operator, "~.", always treats its argument as a string. So "~0" and "~"0"" will both give 2**32-1 on 32-bit platforms, whereas "~.0" and "~."0"" will both yield "\xff". Until Perl 5.28, this feature produced a warning in the "experimental::bitwise" category ๐ซ .
Unary "+" has no effect whatsoever, even on strings. It's useful syntactically for separating a function name from a parenthesized expression that would otherwise be interpreted as the complete list of function arguments ๐. (See examples above under "Terms and List Operators (Leftward)".)
Unary "\" creates references. If its operand is a single sigilled thing, it creates a reference to that object. If its operand is a parenthesised list, then it creates references to the things mentioned in the list. Otherwise it puts its operand in list context, and creates a list of references to the scalars in the list provided by the operand ๐ธ. See perlreftut and perlref. Do not confuse this behavior with the behavior of backslash within a string, although both forms do convey the notion of protecting the next thing from interpolation ๐.
๐ฆ Binding Operators ๐ฆ
Binary "=~" binds a scalar expression to a pattern match. Certain operations search or modify the string $_ by default, and this operator makes that kind of operation work on some other string ๐. The right argument is a search pattern, substitution, or transliteration. The left argument is what is supposed to be searched, substituted, or transliterated instead of the default $_. When used in scalar context, the return value generally indicates the success of the operation โจ. The exceptions are substitution ("s///") and transliteration ("y///") with the "/r" (non-destructive) option, which cause the return value to be the result of the substitution ๐
. Behavior in list context depends on the particular operator. See "Regexp Quote-Like Operators" for details and perlretut for examples using these operators.
If the right argument is an expression rather than a search pattern, substitution, or transliteration, it is interpreted as a search pattern at run time ๐. Note that this means its contents will be interpolated twice, so
'\\' =~ q'\\';is not ok, as the regex engine will end up trying to compile the pattern "\", which it will consider a syntax error ๐.
Binary "!~" is just like "=~" except the return value is negated in the logical sense ๐.
Binary "!~" with a non-destructive substitution ("s///r") or transliteration ("y///r") is a syntax error ๐จ.
๐ Multiplicative Operators ๐
Binary "*" multiplies two numbers โ๏ธ.
Binary "/" divides two numbers โ.
Binary "%" is the modulo operator, which computes the division remainder of its first argument with respect to its second argument ๐งฎ. Given integer operands $m and $n: If $n is positive, then "$m % $n" is $m minus the largest multiple of $n less than or equal to $m. If $n is negative, then "$m % $n" is $m minus the smallest multiple of $n that is not less than $m (that is, the result will be less than or equal to zero). If the operands $m and $n are floating point values and the absolute value of $n (that is abs($n)) is less than "(UV_MAX + 1)", only the integer portion of $m and $n will be used in the operation (Note: here "UV_MAX" means the maximum of the unsigned integer type). If the absolute value of the right operand (abs($n)) is greater than or equal to "(UV_MAX + 1)", "%" computes the floating-point remainder $r in the equation "($r = $m - $i*$n)" where $i is a certain integer that makes $r have the same sign as the right operand $n (not as the left operand $m like C function fmod()) and the absolute value less than that of $n. Note that when use integer is in scope, "%" gives you direct access to the modulo operator as implemented by your C compiler. This operator is not as well defined for negative operands, but it will execute faster ๐ฅ.
Binary "x" is the repetition operator ๐. In scalar context, or if the left operand is neither enclosed in parentheses nor a "qw//" list, it performs a string repetition. In that case it supplies scalar context to the left operand, and returns a string consisting of the left operand string repeated the number of times specified by the right operand. If the "x" is in list context, and the left operand is either enclosed in parentheses or a "qw//" list, it performs a list repetition. In that case it supplies list context to the left operand, and returns a list consisting of the left operand list repeated the number of times specified by the right operand. If the right operand is zero or negative (raising a warning on negative), it returns an empty string or an empty list, depending on the context ๐.
print '-' x 80; # print row of dashes
print "\t" x ($tab/8), ' ' x ($tab%8); # tab over
@ones = (1) x 80; # a list of 80 1's
@ones = (5) x @ones; # set all elements to 5๐ Additive Operators ๐
Binary "+" returns the sum of two numbers โ.
Binary "-" returns the difference of two numbers โ.
Binary "." concatenates two strings ๐.
โญ Shift Operators โญ
Binary "<<" returns the value of its left argument shifted left by the number of bits specified by the right argument โฌ
๏ธ. Arguments should be integers. (See also "Integer Arithmetic".)
Binary ">>" returns the value of its left argument shifted right by the number of bits specified by the right argument โก๏ธ. Arguments should be integers. (See also "Integer Arithmetic".)
If use integer (see "Integer Arithmetic") is in force then signed C integers are used (arithmetic shift), otherwise unsigned C integers are used (logical shift), even for negative shiftees ๐. In arithmetic right shift the sign bit is replicated on the left, in logical shift zero bits come in from the left.
Either way, the implementation isn't going to generate results larger than the size of the integer type Perl was built with (32 bits or 64 bits) ๐.
Shifting by a negative number of bits means the reverse shift: left shift becomes right shift, right shift becomes left shift ๐. This is unlike in C, where negative shift is undefined ๐จ.
Shifting by a value greater than or equal to integer size (in bits) results in zero (all bits fall off), except that under use integer right shifting a negative value by such an amount results in -1 ๐. This is unlike in C, where shifting by too many bits is undefined.
If you get tired of being subject to your platform's native integers, the use bigint pragma neatly sidesteps the issue altogether ๐:
print 20 << 20; # 20971520
print 20 << 32; # 0 with 32-bit integer,
# 85899345920 with 64-bit integer
use bigint;
print 20 << 100; # 25353012004564588029934064107520๐ธ Named Unary Operators ๐ธ
The various named unary operators are treated as functions with one argument, with optional parentheses ๐ซถ.
If any list operator (like print(), and friends) or any unary operator (hey chdir()) gets a left paren as the very next token? ๐
That whole operator-plus-parenthesized-args situation gets bumped to highest precedence, exactly like a normal function call. No cap.
So for example, because named unary operators outrank ||:
chdir $foo || die; # (chdir $foo) || die
chdir($foo) || die; # (chdir $foo) || die
chdir ($foo) || die; # (chdir $foo) || die
chdir +($foo) || die; # (chdir $foo) || diebut because * outranks named operators:
chdir $foo * 20; # chdir ($foo * 20)
chdir($foo) * 20; # (chdir $foo) * 20
chdir ($foo) * 20; # (chdir $foo) * 20
chdir +($foo) * 20; # chdir ($foo * 20)
rand 10 * 20; # rand (10 * 20)
rand(10) * 20; # (rand 10) * 20
rand (10) * 20; # (rand 10) * 20
rand +(10) * 20; # rand (10 * 20)Now about precedence and the filetest operators โ <pink>-f</pink>, <pink>-M</pink>, all of them โ they get treated like named unary operators, BUT they do not play by this functional parenthesis rule. ๐
โโ๏ธ So like, -f($file).".bak" is literally equivalent to -f "$file.bak". Iconic little gotcha, honestly.
See also the "Terms and List Operators (Leftward)" bit. โจ
๐ Class Instance Operator ๐
Binary <cyan>isa</cyan> hits true when the left arg is an object instance of the class (or a subclass derived from that class) given by the right arg. If the left arg is undefined, not a blessed object instance, and doesn't derive from the class on the right โ it evaluates false, bestie. The right argument can hand you the class as either a bareword or a scalar expression that yields a string class name:
if ( $obj isa Some::Class ) { ... }
if ( $obj isa "Different::Class" ) { ... }
if ( $obj isa $name_of_class ) { ... }This whole feature exists from Perl 5.31.6 onwards, and only when you turn it on with use feature 'isa'. It also gets enabled automatically by a use v5.36 (or higher) declaration in the current scope. ๐ช
๐ธ Relational Operators ๐ธ
Perl operators that return true or false generally return values that are safe to use as numbers. Like, the relational operators in this section and the equality operators in the next one return 1 for true and a special version of the defined empty string, "", which counts as a zero but is exempt from warnings about improper numeric conversions โ exactly like "0 but true" is. ๐ฏ
- Binary
<cyan><</cyan>โ true if the left arg is numerically less than the right arg. - Binary
<cyan>></cyan>โ true if the left arg is numerically greater than the right arg. - Binary
<cyan><=</cyan>โ true if the left arg is numerically less than or equal to the right arg. - Binary
<cyan>>=</cyan>โ true if the left arg is numerically greater than or equal to the right arg. - Binary
<cyan>lt</cyan>โ true if the left arg is stringwise less than the right arg. - Binary
<cyan>gt</cyan>โ true if the left arg is stringwise greater than the right arg. - Binary
<cyan>le</cyan>โ true if the left arg is stringwise less than or equal to the right arg. - Binary
<cyan>ge</cyan>โ true if the left arg is stringwise greater than or equal to the right arg.
A whole sequence of relational operators, like $x < $y <= $z, does chained comparisons in the manner already described above in the "Operator Precedence and Associativity" section. โ ๏ธ But beware, bestie โ they do not chain with equality operators, because those have lower precedence. It's giving trap.
lt, le, ge, gt, and cmp (that last one drops in the next section) all use the collation (sort) order specified by the current LC_COLLATE locale if a use locale form that includes collation is in effect. See perllocale. Depending on what the platform can do, these give reasonable results with Unicode, but the standard Unicode::Collate and Unicode::Collate::Locale modules offer much more powerful solutions to collation issues. ๐ฆ
For case-insensitive comparisons, go look at the fc case-folding function in perlfunc โ available in Perl v5.16 or later:
if ( fc($x) eq fc($y) ) { ... }๐ Equality Operators ๐
- Binary
<cyan>==</cyan>โ true if the left arg is numerically equal to the right arg. - Binary
<cyan>!=</cyan>โ true if the left arg is numerically not equal to the right arg. - Binary
<cyan>eq</cyan>โ true if the left arg is stringwise equal to the right arg. - Binary
<cyan>ne</cyan>โ true if the left arg is stringwise not equal to the right arg.
A sequence of the above equality operators, like $x == $y == $z, does chained comparisons in the manner described above in the "Operator Precedence and Associativity" section. โ ๏ธ But heads up โ they do not chain with relational operators, which have higher precedence.
Binary <cyan><=></cyan> returns -1, 0, or 1 depending on whether the left arg is numerically less than, equal to, or greater than the right arg. If your platform supports NaN's (those not-a-numbers), using them with <=> returns undef. And NaN is not <, ==, >, <= or >= anything (not even another NaN), so those 5 all return false. Meanwhile NaN != NaN returns true, and so does NaN != anything else. If your platform doesn't support NaN's, then NaN is just a string with numeric value 0. ๐
$ perl -le '$x = "NaN"; print "No NaN support here" if $x == $x'
$ perl -le '$x = "NaN"; print "NaN support here" if $x != $x'(Note that the bigint, bigrat, and bignum pragmas all support NaN.)
Binary <cyan>cmp</cyan> returns -1, 0, or 1 depending on whether the left arg is stringwise less than, equal to, or greater than the right arg.
Here's where you can literally see the difference between <=> and cmp:
print 10 <=> 2 #prints 1
print 10 cmp 2 #prints -1(likewise between the relational operators described in the previous section: gt and >, lt and <, etc.)
Binary <cyan>~~</cyan> does a smartmatch between its arguments. Smart matching is complicated enough to earn two whole subsections, starting right below. ๐
The two-sided ordering operators <=> and cmp, plus the smartmatch operator ~~, are non-associative with respect to each other and with respect to the equality operators of the same precedence.
โจ Smartmatch Operator โจ
The smartmatch feature is discouraged for new code and retained for backward compatibility.
The smartmatch operator was introduced in 5.10.0 and had significant changes in 5.10.1. It's enabled by default and in all feature bundles up to 5.40. To use smartmatch with a later feature bundle you'll need to enable it explicitly:
use v5.42;
use feature "smartmatch";Binary <cyan>~~</cyan> does a "smartmatch" between its arguments. This is mostly used implicitly in the when construct described in perlsyn, although not all when clauses actually call the smartmatch operator. And here's the wild part โ unique among all of Perl's operators, the smartmatch operator can recurse. ๐คฏ
It's also unique in that all other Perl operators impose a context (usually string or numeric context) on their operands, autoconverting them into that context. Smartmatch, by contrast, infers contexts from the actual types of its operands and uses that type info to pick a suitable comparison mechanism.
The ~~ operator compares its operands "polymorphically", figuring out how to compare them based on their actual types (numeric, string, array, hash, etc.). Like the equality operators it shares precedence with, ~~ returns 1 for true and "" for false. It's often best read aloud as "in", "inside of", or "is contained in", because the left operand is usually being looked for inside the right operand. Which means the operand order to smartmatch is often the opposite of the regular match operator. In other words: the "smaller" thing usually goes in the left operand, and the larger one on the right. ๐ซถ
What a smartmatch actually does depends on what type of things its arguments are, as determined by the following table. The first row whose types apply determines the smartmatch behavior. And because what actually happens is mostly determined by the type of the second operand, the table is sorted on the right operand instead of on the left:
Left Right Description and pseudocode
===============================================================
Any undef check whether Any is undefined
like: !defined Any
Any Object invoke ~~ overloading on Object, or dieRight operand is an ARRAY:
Left Right Description and pseudocode
===============================================================
ARRAY1 ARRAY2 recurse on paired elements of ARRAY1 and ARRAY2[2]
like: (ARRAY1[0] ~~ ARRAY2[0])
&& (ARRAY1[1] ~~ ARRAY2[1]) && ...
HASH ARRAY any ARRAY elements exist as HASH keys
like: grep { exists HASH->{$_} } ARRAY
Regexp ARRAY any ARRAY elements pattern match Regexp
like: grep { /Regexp/ } ARRAY
undef ARRAY undef in ARRAY
like: grep { !defined } ARRAY
Any ARRAY smartmatch each ARRAY element[3]
like: grep { Any ~~ $_ } ARRAYRight operand is a HASH:
Left Right Description and pseudocode
===============================================================
HASH1 HASH2 all same keys in both HASHes
like: keys HASH1 ==
grep { exists HASH2->{$_} } keys HASH1
ARRAY HASH any ARRAY elements exist as HASH keys
like: grep { exists HASH->{$_} } ARRAY
Regexp HASH any HASH keys pattern match Regexp
like: grep { /Regexp/ } keys HASH
undef HASH always false (undef cannot be a key)
like: 0 == 1
Any HASH HASH key existence
like: exists HASH->{Any}Right operand is CODE:
Left Right Description and pseudocode
===============================================================
ARRAY CODE sub returns true on all ARRAY elements[1]
like: !grep { !CODE->($_) } ARRAY
HASH CODE sub returns true on all HASH keys[1]
like: !grep { !CODE->($_) } keys HASH
Any CODE sub passed Any returns true
like: CODE->(Any)Right operand is a Regexp:
Because the smartmatch chart is LONG, bestie, so here's the rest of it ๐ธ same energy, same facts:
Left Right Description and pseudocode
===============================================================
ARRAY Regexp any ARRAY elements match Regexp
like: grep { /Regexp/ } ARRAY
HASH Regexp any HASH keys match Regexp
like: grep { /Regexp/ } keys HASH
Any Regexp pattern match
like: Any =~ /Regexp/And the other half of the chart, the sequel nobody asked for but we all needed:
Other:
Left Right Description and pseudocode
===============================================================
Object Any invoke ~~ overloading on Object,
or fall back to...
Any Num numeric equality
like: Any == Num
Num nummy[4] numeric equality
like: Num == nummy
undef Any check whether undefined
like: !defined(Any)
Any Any string equality
like: Any eq AnyThe notes, aka the fine print that is not optional reading ๐
- Empty hashes or arrays match.
- That is, each element smartmatches the element of the same index in the other array.[3]
- If a circular reference is found, fall back to referential equality.
- Either an actual number, or a string that looks like one.
The smartmatch implicitly dereferences any non-blessed hash or array reference, so the HASH and ARRAY entries apply in those cases. For blessed references, the Object entries apply. Smartmatches involving hashes only consider hash keys, never hash values.
The like code entry is not always an exact rendition. For example, the smartmatch operator short-circuits whenever possible, but grep does not. Also, grep in scalar context returns the number of matches, but ~~ returns only true or false.
Unlike most operators, the smartmatch operator knows to treat undef specially:
use v5.10.1;
@array = (1, 2, 3, undef, 4, 5);
say "some elements undefined" if undef ~~ @array;Each operand is considered in a modified scalar context, the modification being that array and hash variables are passed by reference to the operator, which implicitly dereferences them. Both elements of each pair are the same, no cap:
use v5.10.1;
my %hash = (red => 1, blue => 2, green => 3,
orange => 4, yellow => 5, purple => 6,
black => 7, grey => 8, white => 9);
my @array = qw(red blue green);
say "some array elements in hash keys" if @array ~~ %hash;
say "some array elements in hash keys" if \@array ~~ \%hash;
say "red in array" if "red" ~~ @array;
say "red in array" if "red" ~~ \@array;
say "some keys end in e" if /e$/ ~~ %hash;
say "some keys end in e" if /e$/ ~~ \%hash;Two arrays smartmatch if each element in the first array smartmatches (that is, is "in") the corresponding element in the second array, recursively. Iconic behaviour honestly:
use v5.10.1;
my @little = qw(red blue green);
my @bigger = ("red", "blue", [ "orange", "green" ] );
if (@little ~~ @bigger) { # true!
say "little is contained in bigger";
}Because the smartmatch operator recurses on nested arrays, this will still report that red is in the array. The way that nesting just keeps going ๐ฆ
use v5.10.1;
my @array = qw(red blue green);
my $nested_array = [[[[[[[ @array ]]]]]]];
say "red in array" if "red" ~~ $nested_array;If two arrays smartmatch each other, then they are deep copies of each others' values, as this example reports โ the "it's giving twin flame mirror" moment โจ
use v5.12.0;
my @a = (0, 1, 2, [3, [4, 5], 6], 7);
my @b = (0, 1, 2, [3, [4, 5], 6], 7);
if (@a ~~ @b && @b ~~ @a) {
say "a and b are deep copies of each other";
}
elsif (@a ~~ @b) {
say "a smartmatches in b";
}
elsif (@b ~~ @a) {
say "b smartmatches in a";
}
else {
say "a and b don't smartmatch each other at all";
}If you were to set $b[3] = 4, then instead of reporting that a and b are deep copies of each other, it now reports that b smartmatches in a. That's because the corresponding position in @a contains an array that (eventually) has a 4 in it. Plot twist, lowkey ๐ญ
Smartmatching one hash against another reports whether both contain the same keys, no more and no less. This could be used to see whether two records have the same field names, without caring what values those fields might have. For example:
use v5.10.1;
sub make_dogtag {
state $REQUIRED_FIELDS = { name=>1, rank=>1, serial_num=>1 };
my ($class, $init_fields) = @_;
die "Must supply (only) name, rank, and serial number"
unless $init_fields ~~ $REQUIRED_FIELDS;
...
}However, this only does what you mean if $init_fields is indeed a hash reference. The condition "$init_fields ~~ $REQUIRED_FIELDS" also allows the strings name, rank, serial_num as well as any array reference that contains name or rank or serial_num anywhere to pass through. So like, careful bestie, that check is doing extra credit vibes.
The smartmatch operator is most often used as the implicit operator of a when clause. See the section on "Switch Statements" in perlsyn.
Smartmatching of Objects
To avoid relying on an object's underlying representation, if the smartmatch's right operand is an object that doesn't overload ~~, it raises the exception "Smartmatching a non-overloaded object breaks encapsulation". That's because one has no business digging around to see whether something is "in" an object. These are all illegal on objects without a ~~ overload โ periodt, do not try it ๐ซ
%hash ~~ $object
42 ~~ $object
"fred" ~~ $objectHowever, you can change the way an object is smartmatched by overloading the ~~ operator. This is allowed to extend the usual smartmatch semantics. For objects that do have an ~~ overload, see overload.
Using an object as the left operand is allowed, although not very useful. Smartmatching rules take precedence over overloading, so even if the object in the left operand has smartmatch overloading, this will be ignored. A left operand that is a non-overloaded object falls back on a string or numeric comparison of whatever the ref operator returns. That means that
$object ~~ Xdoes not invoke the overload method with X as an argument. Instead the above table is consulted as normal, and based on the type of X, overloading may or may not be invoked. For simple strings or numbers, in becomes equivalent to this:
$object ~~ $number ref($object) == $number
$object ~~ $string ref($object) eq $stringFor example, this reports that the handle smells IOish (but please don't really do this! ๐):
use IO::Handle;
my $fh = IO::Handle->new();
if ($fh ~~ /\bIO\b/) {
say "handle smells IOish";
}That's because it treats $fh as a string like IO::Handle=GLOB(0x8039e0), then pattern matches against that. Sneaky fr fr.
Bitwise And
Binary & returns its operands ANDed together bit by bit. Although no warning is currently raised, the result is not well defined when this operation is performed on operands that aren't either numbers (see "Integer Arithmetic") nor bitstrings (see "Bitwise String Operators"). So likeโฆ undefined behaviour, gorgeous, she's mysterious ๐
Note that & has lower priority than relational operators, so for example the parentheses are essential in a test like
print "Even\n" if ($x & 1) == 0;If the bitwise feature is enabled via use feature 'bitwise' or use v5.28, then this operator always treats its operands as numbers. Before Perl 5.28 this feature produced a warning in the experimental::bitwise category.
Bitwise Or and Exclusive Or
Binary | returns its operands ORed together bit by bit. If both corresponding bits are 0, the resulting bit is 0; if either is 1, the result is 1.
Binary ^ returns its operands XORed together bit by bit. If both corresponding bits are 0 or both are 1, the resulting bit is 0; if just one is 1, the result is 1. It's giving "exactly one of you, choose" ๐
Although no warning is currently raised, the results are not well defined when these operations are performed on operands that aren't either numbers (see "Integer Arithmetic") nor bitstrings (see "Bitwise String Operators").
Note that | and ^ have lower priority than relational operators, so for example the parentheses are essential in a test like
print "false\n" if (8 | 2) != 10;If the bitwise feature is enabled via use feature 'bitwise' or use v5.28, then this operator always treats its operands as numbers. Before Perl 5.28. this feature produced a warning in the experimental::bitwise category.
C-style Logical And
Binary && performs a short-circuit logical AND operation. That is, if the left operand is false, the right operand is not even evaluated. Scalar or list context propagates down to the right operand if it is evaluated.
&& returns the last value evaluated (unlike C's &&, which returns 0 or 1). Yes, really, she returns the value, not just a vibe check โ
As an alternative to && when used for control flow, Perl provides the and operator (see below). The short-circuit behavior is identical. The precedence of and is much lower, however, so that you can safely use it after a list operator without the need for parentheses.
C-style Logical Or, Xor, and Defined Or
Binary || performs a short-circuit logical OR operation. That is, if the left operand is true, the right operand is not even evaluated. Scalar or list context propagates down to the right operand if it does get evaluated.
As an alternative to || when used for control flow, Perl provides the or operator (see below). The short-circuit behavior is identical. The precedence of or is much lower, however, so that you can safely use it after a list operator without the need for parentheses:
unlink "alpha", "beta", "gamma"
or gripe(), next LINE;With the C-style operator that would have been written like this:
unlink("alpha", "beta", "gamma")
|| (gripe(), next LINE);It would be even more readable to write that this way โ honestly, main character formatting ๐
unless(unlink("alpha", "beta", "gamma")) {
gripe();
next LINE;
}Using or for assignment is unlikely to do what you want; see below. Careful with that one bestie, she bites.
Binary ^^ performs a logical XOR operation. Both operands are evaluated and the result is true only if exactly one of the operands is true. Scalar or list context propagates down to the right operand.
okay so C literally has nothing that does this, but Perl's // operator is cousins-adjacent to C's or. and fr fr, it's exactly the same as ||, except it checks whether the left side is defined instead of whether it's true. so EXPR1 // EXPR2 hands you back the value of EXPR1 if it's defined, and if it's not, you get EXPR2 instead. (EXPR1 gets evaluated in scalar context, and EXPR2 gets evaluated in the context of // itself, bestie ๐
).
usually that lands you the exact same thing as defined(EXPR1) ? EXPR1 : EXPR2 โ with one lil caveat: the ternary-operator form can be used as an lvalue, and EXPR1 // EXPR2 cannot. slay anyway. this is SO useful for giving variables default values. and if what you actually want is to test whether at least one of $x and $y is defined, use defined($x // $y).
the || and // operators return the last value evaluated (unlike C's ||, which just gives you 0 or 1). so a reasonably portable way to find out the home directory might look like:
$home = $ENV{HOME}
// $ENV{LOGDIR}
// (getpwuid($<))[7]
// die "You're homeless!\n";in particular, this means you should not use this for selecting between two aggregates for assignment:
@a = @b || @c; # This doesn't do the right thing
@a = scalar(@b) || @c; # because it really means this.
@a = @b ? @b : @c; # This works fine, though.โจ Range Operators โจ
binary .. is the range operator, and it's lowkey two different operators depending on the context, no cap.
in list context, it returns a list of values counting up by ones from the left value to the right value. if the left value is greater than the right value then you get the empty list back, sorry bestie. the range operator is iconic for writing foreach (1..10) loops and for doing slice operations on arrays. and here's the tea: no temporary array is created when the range operator is used as the expression in foreach loops.
the range operator also works on strings, using the magical auto-increment, see below ๐.
in scalar context, .. returns a boolean value. the operator is bistable, like a flip-flop, and it emulates the line-range (comma) operator of sed, awk, and various editors. each .. operator maintains its own boolean state, even across calls to a subroutine that contains it. it's false as long as its left operand is false. once the left operand is true, the range operator stays true until the right operand is true, AFTER which the range operator becomes false again. and it doesn't become false till the next time the range operator is evaluated. it can test the right operand and become false on the same evaluation it became true (as in awk), but it still returns true once. if you don't want it to test the right operand until the next evaluation, as in sed, just use three dots (...) instead of two. in all other regards, ... behaves just like .. does. periodt.
the right operand is not evaluated while the operator is in the "false" state, and the left operand is not evaluated while the operator is in the "true" state. the precedence is a little lower than || and &&. the value returned is either the empty string for false, or a sequence number (beginning with 1) for true. the sequence number is reset for each range encountered. the final sequence number in a range has the string "E0" appended to it, which doesn't affect its numeric value, but gives you something to search for if you want to exclude the endpoint. you can exclude the beginning point by waiting for the sequence number to be greater than 1.
if either operand of scalar .. is a constant expression, that operand is considered true if it is equal (==) to the current input line number (the $. variable).
okay and to be pedantic about it ๐: the comparison is actually int(EXPR) == int(EXPR), but that's only an issue if you use a floating point expression; when implicitly using $. as described in the previous paragraph, the comparison is int(EXPR) == int($.), which is only an issue when $. is set to a floating point value and you are not reading from a file. furthermore, "span" .. "spat" or 2.18 .. 3.14 will not do what you want in scalar context, because each of the operands are evaluated using their integer representation.
examples, besties:
as a scalar operator:
if (101 .. 200) { print; } # print 2nd hundred lines, short for
# if ($. == 101 .. $. == 200) { print; }
next LINE if 1 .. /^$/; # skip header lines, short for
# next LINE if $. == 1 .. /^$/;
# (typically in a loop labeled LINE)
s/^/> / if /^$/ .. eof(); # quote body
# parse mail messages
while (<>) {
$in_header = 1 .. /^$/;
$in_body = /^$/ .. eof;
if ($in_header) {
# do something
} else { # in body
# do something else
}
} continue {
close ARGV if eof; # reset $. each file
}here's a simple example to illustrate the difference between the two range operators:
@lines = (" - Foo",
"01 - Bar",
"1 - Baz",
" - Quux");
foreach (@lines) {
if (/0/ .. /1/) {
print "$_\n";
}
}this program will print only the line containing "Bar". if the range operator is changed to ..., it will also print the "Baz" line. cute!
and now some examples as a list operator:
for (101 .. 200) { print } # print $_ 100 times
@foo = @foo[0 .. $#foo]; # an expensive no-op
@foo = @foo[$#foo-4 .. $#foo]; # slice last 5 itemsbecause each operand is evaluated in integer form, 2.18 .. 3.14 will return two elements in list context.
@list = (2.18 .. 3.14); # same as @list = (2 .. 3);the range operator in list context can make use of the magical auto-increment algorithm if both operands are strings, subject to the following rules:
- with one exception (below), if both strings look like numbers to Perl, the magic increment will not be applied, and the strings will be treated as numbers (more specifically, integers) instead.
for example, "-2".."2" is the same as -2..2, and "2.18".."3.14" produces "2, 3".
- the exception to the above rule is when the left-hand string begins with
0and is longer than one character, in this case the magic increment will be applied, even though strings like"01"would normally look like a number to Perl.
for example, "01".."04" produces "01", "02", "03", "04", and "00".."-1" produces "00" through "99" โ this may seem surprising, but see the following rules for why it works this way. to get dates with leading zeros, you can say:
@z2 = ("01" .. "31");
print $z2[$mday];if you want to force strings to be interpreted as numbers, you could say
@numbers = ( 0+$first .. 0+$last );note: in Perl versions 5.30 and below, any string on the left-hand side beginning with"0", including the string"0"itself, would cause the magic string increment behavior. this means that on these Perl versions,"0".."-1"would produce"0"through"99", which was inconsistent with"0..-1", which produces the empty list. this also means that"0".."9"now produces a list of integers instead of a list of strings.
- if the initial value specified isn't part of a magical increment sequence (that is, a non-empty string matching
/^[a-zA-Z]*[0-9]*\z/), only the initial value will be returned.
for example, "ax".."az" produces "ax", "ay", "az", but "*x".."az" produces only "*x".
- for other initial values that are strings that do follow the rules of the magical increment, the corresponding sequence will be returned.
for example, you can say
@alphabet = ("A" .. "Z");to get all normal letters of the English alphabet, or
$hexdigit = (0 .. 9, "a" .. "f")[$num & 15];to get a hexadecimal digit.
- if the final value specified is not in the sequence that the magical increment would produce, the sequence goes until the next value would be longer than the final value specified. if the length of the final string is shorter than the first, the empty list is returned.
for example, "a".."--" is the same as "a".."zz", "0".."xx" produces "0" through "99", and "aaa".."--" returns the empty list.
as of Perl 5.26, the list-context range operator on strings works as expected in the scope of use feature 'unicode_strings'. in previous versions, and outside the scope of that feature, it exhibits The "Unicode Bug" in perlunicode: its behavior depends on the internal encoding of the range endpoint.
because the magical increment only works on non-empty strings matching /^[a-zA-Z]*[0-9]*\z/, the following will only return an alpha:
use charnames "greek";
my @greek_small = ("\N{alpha}" .. "\N{omega}");to get the 25 traditional lowercase Greek letters, including both sigmas, you could use this instead:
use charnames "greek";
my @greek_small = map { chr } ( ord("\N{alpha}")
..
ord("\N{omega}")
);however, because there are many other lowercase Greek characters than just those, to match lowercase Greek characters in a regular expression, you could use the pattern /(?:(?=\p{Greek})\p{Lower})+/ (or the experimental feature /(?[ \p{Greek} & \p{Lower} ])+/).
๐ฆ Conditional Operator ๐ฆ
ternary ?: is the conditional operator, just like in C. it works pretty much like an if-then-else. if the argument before the ? is true, the argument before the : is returned, otherwise the argument after the : is returned. for example:
printf "I have %d dog%s.\n", $n,
($n == 1) ? "" : "s";scalar or list context propagates downward into the 2nd or 3rd argument, whichever is selected.
$x = $ok ? $y : $z; # get a scalar
@x = $ok ? @y : @z; # get an array
$x = $ok ? @y : @z; # oops, that's just a count!the operator may be assigned to if both the 2nd and 3rd arguments are legal lvalues (meaning that you can assign to them):
($x_or_y ? $x : $y) = $z;because this operator produces an assignable result, using assignments without parentheses will get you in trouble. for example, this:
$x % 2 ? $x += 10 : $x += 2really means this:
(($x % 2) ? ($x += 10) : $x) += 2rather than this:
($x % 2) ? ($x += 10) : ($x += 2)that should probably be written more simply as:
$x += ($x % 2) ? 10 : 2;๐ธ Assignment Operators ๐ธ
= is the ordinary assignment operator.
okay bestie, assignment operators ๐ they work exactly like in C, so
$x += 2;is literally the same thing as
$x = $x + 2;with one tiny glow-up: it does not duplicate any side effects that dereferencing the lvalue might trigger, like the ones from tie(). Every other assignment operator works the same way. Here's the full squad we recognize:
**= += *= &= &.= <<= &&=
-= /= |= |.= >>= ||=
.= %= ^= ^.= //=
x= ^^=and yes, even though they're all grouped up by family like that, they all have the precedence of assignment. important!! The combined assignment operators can only operate on scalars, whereas the ordinary assignment operator can assign to arrays, hashes, lists and even references. (go peek at "Context" and "List value constructors" in perldata, and "Assigning to References" in perlref if you want the lore ๐ซถ)
The scalar assignment operator returns its left operand, i.e. the scalar assigned to. And unlike in C, it produces a valid lvalue. Modifying an assignment is equivalent to doing the assignment and then modifying the variable that was assigned to. Which is lowkey so useful for modifying a copy of something, like this:
($tmp = $global) =~ tr/13579/24680/;Although as of 5.14, that can be also be accomplished this way:
use v5.14;
$tmp = ($global =~ tr/13579/24680/r);Likewise,
($x += 2) *= 3;is equivalent to
$x += 2;
$x *= 3;Similarly, a list assignment in list context produces the list of lvalues assigned to, and a list assignment in scalar context returns the number of elements produced by the expression on the right hand side of the assignment. cute, right? โจ
The three dotted bitwise assignment operators (&.=, |.=, ^.=) are new in Perl 5.22. See "Bitwise String Operators".
๐ Comma Operator ๐
Binary , is the comma operator. In scalar context it evaluates its left argument, throws that value away, then evaluates its right argument and returns that value. It's just like C's comma operator, no notes ๐
In list context, it's just the list argument separator, and inserts both its arguments into the list. These arguments are also evaluated from left to right.
The => operator (sometimes pronounced "fat comma") is a synonym for the comma except that it causes a word on its left to be interpreted as a string if it begins with a letter or underscore and is composed only of letters, digits and underscores. This includes operands that might otherwise be interpreted as operators, constants, single number v-strings or function calls. If in doubt about this behavior, the left operand can be quoted explicitly.
Otherwise, the => operator behaves exactly as the comma operator or list argument separator, according to context.
For example:
use constant FOO => "something";
my %h = ( FOO => 23 );is equivalent to:
my %h = ("FOO", 23);It is NOT:
my %h = ("something", 23);The => operator is helpful in documenting the correspondence between keys and values in hashes, and other paired elements in lists. it's giving documentation energy fr fr:
%hash = ( $key => $value );
login( $username => $password );The special quoting behavior ignores precedence, and hence may apply to part of the left operand:
print time.shift => "bbb";That example prints something like "1314363215shiftbbb", because the => implicitly quotes the shift immediately on its left, ignoring the fact that time.shift is the entire left operand. yeah, it does that ๐
๐ธ List Operators (Rightward) ๐ธ
On the right side of a list operator, the comma has very low precedence, such that it controls all comma-separated expressions found there. The only operators with lower precedence are the logical operators and, or, and not, which may be used to evaluate calls to list operators without the need for parentheses:
open HANDLE, "< :encoding(UTF-8)", "filename"
or die "Can't open: $!\n";However, some people find that code harder to read than writing it with parentheses:
open(HANDLE, "< :encoding(UTF-8)", "filename")
or die "Can't open: $!\n";in which case you might as well just use the more customary || operator:
open(HANDLE, "< :encoding(UTF-8)", "filename")
|| die "Can't open: $!\n";See also discussion of list operators in "Terms and List Operators (Leftward)".
โจ Logical Not โจ
Unary not returns the logical negation of the expression to its right. It's the equivalent of ! except for the very low precedence. that's the whole vibe check ๐
โจ Logical And โจ
Binary and returns the logical conjunction of the two surrounding expressions. It's equivalent to && except for the very low precedence. This means that it short-circuits: the right expression is evaluated only if the left expression is true.
โจ Logical or and Exclusive Or โจ
There is no low precedence operator for defined-OR. noting it, bestie ๐
Binary or returns the logical inclusive disjunction of the two surrounding expressions. It's equivalent to || except for it having very low precedence. This makes it useful for control flow:
print FH $data or die "Can't write to FH: $!";This means that it short-circuits: the right expression is evaluated only if the left expression is false. Due to its precedence, you must be careful to avoid using it as replacement for the || operator. It usually works out better for flow control than in assignments:
$x = $y or $z; # bug: this is wrong
($x = $y) or $z; # really means this
$x = $y || $z; # better written this waybestie that first line is marked as a bug in the source, ok? it is wrong. do not do it. ๐
However, when it's a list-context assignment and you're trying to use || for control flow, you probably need or so that the assignment takes higher precedence.
@info = stat($file) || die; # oops, scalar sense of stat!
@info = stat($file) or die; # better, now @info gets its dueThen again, you could always use parentheses. iconic behaviour honestly.
Binary xor returns the logical exclusive disjunction of the two surrounding expressions. That means it returns "true" if either, but not both, are true. It's equivalent to ^^ except for it having very low precedence. It cannot short-circuit (of course). It tends to be used to verify that two mutually-exclusive conditions are actually mutually exclusive. For example, in Perl's test suite, we might want to test that a regular expression pattern can't both match and not match, for otherwise it would be a bug in our pattern matching code.
($x =~ qr/$pat/ xor $x !~ qr/$pat/) or die;๐ C Operators Missing From Perl ๐
Here is what C has that Perl doesn't:
- unary
&โ Address-of operator. (But see the\operator for taking a reference.) - unary
*โ Dereference-address operator. (Perl's prefix dereferencing operators are typed:$,@,%, and&.) (TYPE)โ Type-casting operator.
๐ Quote and Quote-like Operators ๐
While we usually think of quotes as literal values, in Perl they function as operators, providing various kinds of interpolating and pattern matching capabilities. Perl provides customary quote characters for these behaviors, but also provides a way for you to choose your quote character for any of them. In the following table, a {} represents any pair of delimiters you choose.
Customary Generic Meaning Interpolates
'' q{} Literal no
"" qq{} Literal yes
`` qx{} Command yes*
qw{} Word list no
// m{} Pattern match yes*
qr{} Pattern yes*
s{}{} Substitution yes*
tr{}{} Transliteration no (but see below)
y{}{} Transliteration no (but see below)
<<EOF here-doc yes*
* unless the delimiter is ''.Non-bracketing delimiters use the same character fore and aft, but the four sorts of ASCII brackets (round, angle, square, curly) all nest, which means that
q{foo{bar}baz}is the same as
'foo{bar}baz'Note, however, that this does not always work for quoting Perl code:
$s = q{ if ($x eq "}") ... }; # WRONGis a syntax error. The Text::Balanced module (standard as of v5.8, and from CPAN before then) is able to do this properly.
If the extra_paired_delimiters feature is enabled, then Perl will additionally recognise a variety of Unicode characters as being paired. For a full list, see the "List of Extra Paired Delimiters" at the end of this document. ๐ฆ
There can (and in some cases, must) be whitespace between the operator and the quoting characters, except when # is being used as the quoting character. q#foo# is parsed as the string foo, while q #foo# is the operator q followed by a comment. Its argument will be taken from the next line. This allows you to write:
s {foo} # Replace foo
{bar} # with bar.The cases where whitespace must be used are when the quoting character is a word character (meaning it matches /\w/):
q XfooX # Works: means the string 'foo'
qXfooX # WRONG!The following escape sequences are available in constructs that interpolate, and in transliterations whose delimiters aren't single quotes ('). In all the ones with braces, any number of blanks and/or tabs adjoining and within the braces are allowed (and ignored).
Sequence Note Description
\t tab (HT, TAB)
\n newline (NL)
\r return (CR)
\f form feed (FF)
\b backspace (BS)
\a alert (bell) (BEL)
\e escape (ESC)
\x{263A} [1,8] hex char (example shown: SMILEY)
\x{ 263A } Same, but shows optional blanks inside and
adjoining the braces
\x1b [2,8] restricted range hex char (example: ESC)
\N{name} [3] named Unicode character or character sequence
\N{U+263D} [4,8] Unicode character (example: FIRST QUARTER MOON)
\c[ [5] control char (example: chr(27))
\o{23072} [6,8] octal char (example: SMILEY)
\033 [7,8] restricted range octal char (example: ESC)Note that any escape sequence using braces inside interpolated constructs may have optional blanks (tab or space characters) adjoining with and inside of the braces, as illustrated above by the second \x{ } example.
[1] The result is the character specified by the hexadecimal number between the braces. See "[8]" below for details on which character.
okay bestie we're back in escape-sequence town and it's LOWKEY a whole saga ๐ buckle up.
Blanks (tab or space characters, bestie, not like, the concept of blankness) can sit between the number and either or both of the braces. Cozy.
Otherwise, only hexadecimal digits are valid between the braces. If a hater character shows up in there, a warning gets issued and that invalid character โ plus literally everything after it inside the braces, valid or not โ gets discarded. The way it just tosses the whole rest of the party out ๐ญ
If there are no valid digits between the braces at all, the generated character is the NULL character ("\x{00}"). BUT โ plot twist โ an explicit empty brace ("\x{}") will not cause a warning (currently). she's an exception, she's special, periodt.
[2] The result is the character specified by the hexadecimal number in the range 0x00 to 0xFF. See "[8]" below for the deets on which character you actually get.
Only hexadecimal digits are valid following \x. When \x is followed by fewer than two valid digits, any valid digits get zero-padded. So "\x7" is read as "\x07", and a lone "\x" is read as "\x00". โจ
EXCEPT โ at the end of a string, having fewer than two valid digits will result in a warning. And heads up: even though the warning says the illegal character is ignored, it's only ignored as part of the escape. It still gets used as the subsequent character in the string. Sneaky. For example:
Original Result Warns?
"\x7" "\x07" no
"\x" "\x00" no
"\x7q" "\x07q" yes
"\xq" "\x00q" yes[3] The result is the Unicode character or character sequence given by name. See charnames.
[4] "\N{U+hexadecimal number}" means the Unicode character whose Unicode code point is hexadecimal number. simple as.
[5] The character following \c is mapped to some other character, like so:
Sequence Value
\c@ chr(0)
\cA chr(1)
\ca chr(1)
\cB chr(2)
\cb chr(2)
...
\cZ chr(26)
\cz chr(26)
\c[ chr(27)
# See below for chr(28)
\c] chr(29)
\c^ chr(30)
\c_ chr(31)
\c? chr(127) # (on ASCII platforms; see below for link to
# EBCDIC discussion)In other words โ iykyk โ it's the character whose code point has had 64 xor'd with its uppercase. "\c?" is DELETE on ASCII platforms because ord("?") ^ 64 is 127, and "\c@" is NULL because the ord of "@" is 64, so xor'ing 64 itself produces 0. math is mathing ๐ฅ
Also, "\c\X" yields chr(28) . "X" for any X โ but it cannot come at the end of a string, because that backslash would get parsed as escaping the end quote. Tragic.
On ASCII platforms, the resulting characters from the list above are the complete set of ASCII controls. That is NOT the case on EBCDIC platforms โ see "OPERATOR DIFFERENCES" in perlebcdic for the full deep-dive on how these differ between ASCII and EBCDIC. ๐ฆ
Using any other character after the c besides the ones listed above is discouraged, and as of Perl v5.20, the only characters actually allowed are the printable ASCII ones, minus the left brace {. For any of the allowed other characters, the value is derived by xor'ing with the seventh bit, which is 64, and a warning gets raised if enabled. Using non-allowed characters generates a fatal error. no cap.
To get platform independent controls, you can use \N{...}. ๐ซถ
[6] The result is the character specified by the octal number between the braces. See "[8]" below for details on which character.
Blanks (tab or space characters) may separate the number from either or both of the braces.
Otherwise, if a character that isn't an octal digit shows up, a warning is raised, and the value is based on the octal digits before it โ discarding it and all following characters up to the closing brace. And it is a fatal error if there are no octal digits at all. zero digits, zero mercy ๐
[7] The result is the character specified by the three-digit octal number in the range 000 to 777 (but bestie, best to not use above 077, see next paragraph). See "[8]" below for details on which character.
Some contexts allow 2 or even 1 digit, but any usage without exactly three digits, the first being a zero, may give unintended results. (For example, in a regular expression it may be confused with a backreference; see "Octal escapes" in perlrebackslash.) Starting in Perl 5.14, you may use \o{} instead, which avoids all these problems. Otherwise, it's best to use this construct only for ordinals \077 and below, remembering to pad to the left with zeros to make three digits. For larger ordinals, either use \o{}, or convert to something else โ like, convert to hex and use \N{U+} (which is portable between platforms with different character sets) or \x{} instead. ๐
[8] Several constructs above specify a character by a number. That number gives the character's position in the character set encoding (indexed from 0). This is called synonymously its ordinal, code position, or code point. Perl works on platforms that have a native encoding currently of either ASCII/Latin1 or EBCDIC, each of which allow specification of 256 characters. In general, if the number is 255 (0xFF, 0377) or below, Perl interprets this in the platform's native encoding. If the number is 256 (0x100, 0400) or above, Perl interprets it as a Unicode code point and the result is the corresponding Unicode character. For example \x{50} and \o{120} are both the number 80 in decimal, which is less than 256, so the number gets interpreted in the native character set encoding. In ASCII the character in the 80th position (indexed from 0) is the letter "P", and in EBCDIC it is the ampersand symbol "&". \x{100} and \o{400} are both 256 in decimal, so the number is interpreted as a Unicode code point no matter what the native encoding is. The name of the character in the 256th position (indexed by 0) in Unicode is "LATIN CAPITAL LETTER A WITH MACRON". slay. ๐
An exception to the above rule: \N{U+hex number} is always interpreted as a Unicode code point, so that \N{U+0050} is "P" even on EBCDIC platforms. she refuses to be normal about it.
NOTE: Unlike C and other languages, Perl has no\vescape sequence for the vertical tab (VT, which is 11 in both ASCII and EBCDIC), but you may use\N{VT},\ck,\N{U+0b}, or\x0b. (\vdoes have meaning in regular expression patterns in Perl, seeperlre.)
The following escape sequences are available in constructs that interpolate, but not in transliterations.
\l lowercase next character only
\u titlecase (not uppercase!) next character only
\L lowercase all characters till \E or end of string
\U uppercase all characters till \E or end of string
\F foldcase all characters till \E or end of string
\Q quote (disable) pattern metacharacters till \E or
end of string
\E end either case modification or quoted section
(whichever was last seen)See "quotemeta" in perlfunc for the exact definition of characters that are quoted by \Q. โจ
\L, \U, \F, and \Q can stack, and in that case you need one \E for each. For example:
say "This \Qquoting \ubusiness \Uhere isn't\E done yet,\E is it?";
This quoting Business HERE ISN'T done yet, is it?If a use locale form that includes LC_CTYPE is in effect (see perllocale), the case map used by \l, \L, \u, and \U is taken from the current locale. If Unicode (for example, \N{} or code points of 0x100 or beyond) is being used, the case map used by \l, \L, \u, and \U is as defined by Unicode. That means case-mapping a single character can sometimes produce a sequence of several characters โ one in, many out, iconic behavior tbh. Under use locale, \F produces the same results as \L for all locales but a UTF-8 one, where it instead uses the Unicode definition.
All systems use the virtual \n to represent a line terminator, called a "newline". There is no such thing as an unvarying, physical newline character. It is only an illusion that the operating system, device drivers, C libraries, and Perl all conspire to preserve. ๐ญ Not all systems read \r as ASCII CR and \n as ASCII LF. For example, on the ancient Macs (pre-MacOS X) of yesteryear, these used to be reversed, and on systems without a line terminator, printing \n might emit no actual data. In general, use \n when you mean a "newline" for your system, but use the literal ASCII when you need an exact character. For example, most networking protocols expect and prefer a CR+LF (\015\012 or \cM\cJ) for line terminators, and although they often accept just \012, they seldom tolerate just \015. If you get in the habit of using \n for networking, you may be burned some day. consider this your warning bestie ๐ฅ
For constructs that do interpolate, variables beginning with "$" or "@" are interpolated. Subscripted variables such as $a[3] or "$href->{key}[0]" are also interpolated, as are array and hash slices. But method calls such as "$obj->meth" are not. sorry to that method call.
Interpolating an array or slice interpolates the elements in order, separated by the value of $", so it's equivalent to interpolating "join $", @array". "Punctuation" arrays such as @* are usually interpolated only if the name is enclosed in braces @{*}, but the arrays @_, "@+", and @- are interpolated even without braces. special privileges, honestly ๐
For double-quoted strings, the quoting from \Q is applied after interpolation and escapes are processed.
"abc\Qfoo\tbar$s\Exyz"is equivalent to
"abc" . quotemeta("foo\tbar$s") . "xyz"For the pattern of regex operators (qr//, m// and s///), the quoting from \Q is applied after interpolation is processed, but before escapes are processed. This allows the pattern to match literally (except for $ and @). For example, the following matches:
'\s\t' =~ /\Q\s\t/Because $ or @ trigger interpolation, you'll need to use something like /\Quser\E\@\Qhost/ to match them literally. ๐
Patterns are subject to an additional level of interpretation as a regular expression. This is done as a second pass, after variables are interpolated, so that regular expressions may be incorporated into the pattern from the variables. If this is not what you want, use \Q to interpolate a variable literally. and that's the whole vibe check for this stretch, keep reading bestie, we're not done yet ๐
okay so real talk, bestie: apart from the behavior we already described above, Perl does not expand multiple levels of interpolation. and specifically? shell programmers stay expecting one thing and getting another: back-quotes do NOT interpolate within double quotes, and single quotes do not impede evaluation of variables when used within double quotes. it's giving unlearn your shell habits fr fr. ๐
โจ Simpler Quote-Like Operators โจ
q/STRING/ / 'STRING'
A single-quoted, literal string. A backslash represents a backslash unless followed by the delimiter or another backslash, in which case the delimiter or backslash is interpolated.
$foo = q!I said, "You said, 'She said it.'"!;
$bar = q('This is it.');
$baz = '\n'; # a two-character stringqq/STRING/ / "STRING"
A double-quoted, interpolated string.
$_ .= qq
(*** The previous line contains the naughty word "$1".\n)
if /\b(tcl|java|python)\b/i; # :-)
$baz = "\n"; # a one-character stringqx/STRING/ / `STRING`
A string which is (possibly) interpolated and then executed as a system command, via /bin/sh or its equivalent if required. Shell wildcards, pipes, and redirections will be honored. Similarly to "system", if the string contains no shell metacharacters then it will be executed directly. The collected standard output of the command is returned; standard error is unaffected. In scalar context, it comes back as a single (potentially multi-line) string, or "undef" if the shell (or command) could not be started. In list context, returns a list of lines (however you've defined lines with $/ or $INPUT_RECORD_SEPARATOR), or an empty list if the shell (or command) could not be started.
print qx/date/; # prints "Sun Jan 28 06:16:19 CST 2024"Because backticks do not affect standard error, use shell file descriptor syntax (assuming the shell supports this) if you care to address this. To capture a command's STDERR and STDOUT together:
$output = `cmd 2>&1`;To capture a command's STDOUT but discard its STDERR:
$output = `cmd 2>/dev/null`;To capture a command's STDERR but discard its STDOUT (ordering is important here):
$output = `cmd 2>&1 1>/dev/null`;To exchange a command's STDOUT and STDERR in order to capture the STDERR but leave its STDOUT to come out the old STDERR:
$output = `cmd 3>&1 1>&2 2>&3 3>&-`;To read both a command's STDOUT and its STDERR separately, it's easiest to redirect them separately to files, and then read from those files when the program is done:
system("program args 1>program.stdout 2>program.stderr");The STDIN filehandle used by the command is inherited from Perl's STDIN. For example:
open(SPLAT, "stuff") || die "can't open stuff: $!";
open(STDIN, "<&SPLAT") || die "can't dupe SPLAT: $!";
print STDOUT `sort`;will print the sorted contents of the file named "stuff".
Using single-quote as a delimiter protects the command from Perl's double-quote interpolation, passing it on to the shell instead:
$perl_info = qx(ps $$); # that's Perl's $$
$shell_info = qx'ps $$'; # that's the new shell's $$How that string gets evaluated is entirely subject to the command interpreter on your system. On most platforms, you will have to protect shell metacharacters if you want them treated literally. This is in practice difficult to do, as it's unclear how to escape which characters. See perlsec for a clean and safe example of a manual fork() and exec() to emulate backticks safely.
On some platforms (notably DOS-like ones), the shell may not be capable of dealing with multiline commands, so putting newlines in the string may not get you what you want. You may be able to evaluate multiple commands in a single line by separating them with the command separator character, if your shell supports that (for example, ";" on many Unix shells and "&" on the Windows NT "cmd" shell).
Perl will attempt to flush all files opened for output before starting the child process, but this may not be supported on some platforms (see perlport). To be safe, you may need to set $| ($AUTOFLUSH in "English") or call the autoflush() method of "IO::Handle" on any open handles.
Beware that some command shells may place restrictions on the length of the command line. You must ensure your strings don't exceed this limit after any necessary interpolations. See the platform-specific release notes for more details about your particular environment.
Using this operator can lead to programs that are difficult to port, because the shell commands called vary between systems, and may in fact not be present at all. As one example, the "type" command under the POSIX shell is very different from the "type" command under DOS. That doesn't mean you should go out of your way to avoid backticks when they're the right way to get something done. Perl was made to be a glue language, and one of the things it glues together is commands. Just understand what you're getting yourself into.
Like "system", backticks put the child process exit code in $?. If you'd like to manually inspect failure, you can check all possible failure modes by inspecting $? like this:
if ($? == -1) {
print "failed to execute: $!\n";
}
elsif ($? & 127) {
printf "child died with signal %d, %s coredump\n",
($? & 127), ($? & 128) ? 'with' : 'without';
}
else {
printf "child exited with value %d\n", $? >> 8;
}Use the open pragma to control the I/O layers used when reading the output of the command, for example:
use open IN => ":encoding(UTF-8)";
my $x = `cmd-producing-utf-8`;"qx//" can also be called like a function with "readpipe" in perlfunc.
See "I/O Operators" for more discussion.
qw/STRING/
Evaluates to a list of the words extracted out of STRING, using embedded whitespace as the word delimiters. It can be understood as being roughly equivalent to:
split(" ", q/STRING/);the differences being that it only splits on ASCII whitespace, generates a real list at compile time, and in scalar context it returns the last element in the list. So this expression:
qw(foo bar baz)is semantically equivalent to the list:
"foo", "bar", "baz"Some frequently seen examples:
use POSIX qw( setlocale localeconv )
@EXPORT = qw( foo bar baz );Common mistakes are trying to separate the words with commas, trying to put comments into a multi-line "qw"-string, or trying to "\"-escape the space between words. For this reason, the "use warnings" pragma and the -w switch (that is, the $^W variable) produce warnings if the STRING contains the ",", "#", or "\" characters.
โจ Regexp Quote-Like Operators โจ
Here are the quote-like operators that apply to pattern matching and related activities.
qr/STRING/msixpodualn
This operator quotes (and possibly compiles) its STRING as a regular expression. STRING is interpolated the same way as PATTERN in "m/PATTERN/". If "'" is used as the delimiter, no variable interpolation is done. Returns a Perl value which may be used instead of the corresponding "/STRING/msixpodualn" expression. The returned value is a normalized version of the original pattern. It magically differs from a string containing the same characters: ref(qr/x/) returns "Regexp"; however, dereferencing it is not well defined (you currently get the normalized version of the original pattern, but this may change).
For example,
$rex = qr/my.STRING/is;
print $rex; # prints (?si-xm:my.STRING)
s/$rex/foo/;is equivalent to
s/my.STRING/foo/is;The result may be used as a subpattern in a match:
$re = qr/$pattern/;
$string =~ /foo${re}bar/; # can be interpolated in other
# patterns
$string =~ $re; # or used standalone
$string =~ /$re/; # or this waySince Perl may compile the pattern at the moment of execution of the qr() operator, using qr() may have speed advantages in some situations, notably if the result of qr() is used standalone:
sub match {
my $patterns = shift;
my @compiled = map qr/$_/i, @$patterns;
grep {
my $success = 0;
foreach my $pat (@compiled) {
$success = 1, last if /$pat/;
}
$success;
} @_;
}Precompilation of the pattern into an internal representation at the moment of qr() avoids the need to recompile the pattern every time a match "/$pat/" is attempted. (Perl has many other internal optimizations, but none would be triggered in the above example if we did not use qr() operator.)
Options (specified by the following modifiers) are:
mโ treat the string as multiple lines. (^and$get to match at internal newlines too, bestie)sโ treat the string as single line โ aka make.match a newline. chaos dot, iconic behavior ๐iโ do case-insensitive pattern matching. capitals? never heard of her โจxโ use extended regular expressions; specify twox's and that means\tand the SPACE character get ignored within square-bracketed character classespโ when matching, preserve a copy of the matched string so that${^PREMATCH},${^MATCH},${^POSTMATCH}will be defined (ignored starting in v5.20, 'cause those are always defined from that release onwards)oโ compile the pattern only once.aโ ASCII-restrict: use ASCII for\d,\s,\wand[[:posix:]]character classes; specify twoa's and you add the further restriction that no ASCII character will match a non-ASCII one under/i.lโ use the current run-time locale's rules.uโ use Unicode rules.dโ use Unicode or native charset, as in 5.12 and earlier.nโ non-capture mode. don't let()fill in$1,$2, etc...
If a precompiled pattern is embedded in a larger pattern, then the effect of msixpluadn will be propagated appropriately. The effect that the /o modifier has is not propagated โ it stays restricted to those patterns explicitly using it.
The /a, /d, /l, and /u modifiers (added in Perl 5.14) control the character set rules, but ngl /a is the only one you're likely to want to specify explicitly โ the other three are selected automatically by various pragmas.
See perlre for additional information on valid syntax for STRING, and for a detailed look at the semantics of regular expressions. In particular, all modifiers except the largely obsolete /o are further explained in "Modifiers" in perlre. /o is described in the next section. ๐ซถ
"m/PATTERN/msixpodualngc" ๐ธ
"/PATTERN/msixpodualngc" ๐ธ
Searches a string for a pattern match, and in scalar context it returns true if it succeeds and false if it fails. If no string is specified via the =~ or !~ operator, the $_ string is searched. (the string specified with =~ need not be an lvalue โ it may be the result of an expression evaluation, but remember the =~ binds rather tightly.) See also perlre.
Options are as described in qr// above; in addition, these match process modifiers are available:
gโ match globally, i.e., find all occurrences.cโ do not reset search position on a failed match when/gis in effect.
If / is the delimiter then the initial m is optional. With the m you can use any pair of non-whitespace (ASCII) characters as delimiters. This is particularly useful for matching path names that contain /, 'cause it means you avoid LTS (leaning toothpick syndrome). If ? is the delimiter, then a match-only-once rule applies, described in "m?PATTERN?" below. If ' (single quote) is the delimiter, no variable interpolation is performed on the PATTERN. When using a delimiter character valid in an identifier, whitespace is required after the m.
PATTERN may contain variables, which will be interpolated every time the pattern search is evaluated, except for when the delimiter is a single quote. (heads up: $(, $), and $| are not interpolated because they look like end-of-string tests.) Perl will not recompile the pattern unless an interpolated variable that it contains changes. You can force Perl to skip the test and never recompile by adding a /o (which stands for "once") after the trailing delimiter. Once upon a time, Perl would recompile regular expressions unnecessarily, and this modifier was useful to tell it not to do so, in the interests of speed. But now, the only reasons to use /o are one of:
- The variables are thousands of characters long and you know that they don't change, and you need to wring out the last little bit of speed by having Perl skip testing for that. (There is a maintenance penalty for doing this, as mentioning
/oconstitutes a promise that you won't change the variables in the pattern. If you do change them, Perl won't even notice. ๐) - you want the pattern to use the initial values of the variables regardless of whether they change or not. (But there are saner ways of accomplishing this than using
/o.) - If the pattern contains embedded code, such as
use re 'eval';
$code = 'foo(?{ $x })';
/$code/then perl will recompile each time, even though the pattern string hasn't changed, to ensure that the current value of $x is seen each time. Use /o if you want to avoid this.
The bottom line is that using /o is almost never a good idea. periodt.
The empty pattern "//" ๐
(This subsection applies to //, m//, and s///, but not to qr//.)
If the PATTERN evaluates to the empty string, the last successfully matched regular expression in the current dynamic scope is used instead (see also "Scoping Rules of Regex Variables" in perlvar). In this case, only the g and c flags on the empty pattern are honored; the other flags are taken from the original pattern. If no match has previously succeeded, this will (silently) act instead as a genuine empty pattern (which will always match). Using a user supplied string as a pattern has the risk that if the string is empty that it triggers the "last successful match" behavior, which can be very confusing. In such cases you are recommended to replace m/$pattern/ with m/(?:$pattern)/ to avoid this behavior.
The last successful pattern may be accessed as a variable via ${^LAST_SUCCESSFUL_PATTERN}. Matching against it, or the empty pattern should have the same effect, with the exception that when there is no last successful pattern the empty pattern will silently match, whereas using the ${^LAST_SUCCESSFUL_PATTERN} variable will produce undefined warnings (if warnings are enabled). You can check defined(${^LAST_SUCCESSFUL_PATTERN}) to test if there is a "last successful match" in the current scope.
Note that it's possible to confuse Perl into thinking//(the empty regex) is really//(the defined-or operator). Perl is usually pretty good about this, but some pathological cases might trigger this, such as$x///(is that($x) / (//)or$x // /?) andprint $fh //(print $fh(//orprint($fh //?). In all of these examples, Perl will assume you meant defined-or. If you meant the empty regex, just use parentheses or spaces to disambiguate, or even prefix the empty regex with anm(so//becomesm//).
Matching in list context ๐ฆ
If the /g option is not used, m// in list context returns a list consisting of the subexpressions matched by the parentheses in the pattern, that is, ($1, $2, $3...) (Note that here $1 etc. are also set). When there are no parentheses in the pattern, the return value is the list (1) for success. With or without parentheses, an empty list is returned upon failure.
Examples:
open(TTY, "+</dev/tty")
|| die "can't access /dev/tty: $!";
<TTY> =~ /^y/i && foo(); # do foo if desired
if (/Version: *([0-9.]*)/) { $version = $1; }
next if m#^/usr/spool/uucp#;
# poor man's grep
$arg = shift;
while (<>) {
print if /$arg/;
}
if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))This last example splits $foo into the first two words and the remainder of the line, and assigns those three fields to $F1, $F2, and $Etc. The conditional is true if any variables were assigned; that is, if the pattern matched.
The /g modifier specifies global pattern matching โ that is, matching as many times as possible within the string. How it behaves depends on the context. In list context, it returns a list of the substrings matched by any capturing parentheses in the regular expression. If there are no parentheses, it returns a list of all the matched strings, as if there were parentheses around the whole pattern.
In scalar context, each execution of m//g finds the next match, returning true if it matches, and false if there is no further match. The position after the last match can be read or set using the pos() function; see "pos" in perlfunc. A failed match normally resets the search position to the beginning of the string, but you can avoid that by adding the /c modifier (for example, m//gc). Modifying the target string also resets the search position.
"\G assertion" โญ
You can intermix m//g matches with m/\G.../g, where \G is a zero-width assertion that matches the exact position where the previous m//g, if any, left off. Without the /g modifier, the \G assertion still anchors at pos() as it was at the start of the operation (see "pos" in perlfunc), but the match is of course only attempted once. Using \G without /g on a target string that has not previously had a /g match applied to it is the same as using the \A assertion to match the beginning of the string. Note also that, currently, \G is only properly supported when anchored at the very beginning of the pattern.
Examples:
# list context
($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);
# scalar context
local $/ = "";
while ($paragraph = <>) {
while ($paragraph =~ /\p{Ll}['")]*[.!?]+['")]*\s/g) {
$sentences++;
}
}
say $sentences;Here's another way to check for sentences in a paragraph:
okay bestie, here's the actual code for that sentence-splitter โ look at her, she's giving โจforensic linguisticsโจ:
my $sentence_rx = qr{
(?: (?<= ^ ) | (?<= \s ) ) # after start-of-string or
# whitespace
\p{Lu} # capital letter
.*? # a bunch of anything
(?<= \S ) # that ends in non-
# whitespace
(?<! \b [DMS]r ) # but isn't a common abbr.
(?<! \b Mrs )
(?<! \b Sra )
(?<! \b St )
[.?!] # followed by a sentence
# ender
(?= $ | \s ) # in front of end-of-string
# or whitespace
}sx;
local $/ = "";
while (my $paragraph = <>) {
say "NEW PARAGRAPH";
my $count = 0;
while ($paragraph =~ /($sentence_rx)/g) {
printf "\tgot sentence %d: <%s>\n", ++$count, $1;
}
}<h2 id="mgc">and now, using <code>m//gc</code> with <code>\G</code> ๐ </h2>
Real talk, here's the vibe:
$_ = "ppooqppqq";
while ($i++ < 2) {
print "1: '";
print $1 while /(o)/gc; print "', pos=", pos, "\n";
print "2: '";
print $1 if /\G(q)/gc; print "', pos=", pos, "\n";
print "3: '";
print $1 while /(p)/gc; print "', pos=", pos, "\n";
}
print "Final: '$1', pos=",pos,"\n" if /\G(.)/;That last example should print exactly this:
1: 'oo', pos=4
2: 'q', pos=5
3: 'pp', pos=7
1: '', pos=7
2: 'q', pos=8
3: '', pos=8
Final: 'q', pos=8So notice that the final match matched q instead of p โ which is what a match without the \G anchor would have done. Also note that the final match did not update pos. pos only gets updated on a /g match, that's the whole rule. And if the final match genuinely did match p? then ngl it's a pretty good bet you're running an ancient (pre-5.6.0) version of Perl. ๐
<h2 id="lexlike">the lex-like scanner idiom โจ</h2>
A genuinely useful idiom for "lex"-like scanners is / \G.../gc. The way that you can combine several regexps like this to process a string part-by-part, doing different actions depending on which regexp matched โ each regexp tries to match where the previous one leaves off. Chef's kiss. ๐
$_ = <<'EOL';
$url = URI::URL->new( "http://example.com/" );
die if $url eq "xXx";
EOL
LOOP: {
print(" digits"), redo LOOP if /\G\d+\b[,.;]?\s*/gc;
print(" lowercase"), redo LOOP
if /\G\p{Ll}+\b[,.;]?\s*/gc;
print(" UPPERCASE"), redo LOOP
if /\G\p{Lu}+\b[,.;]?\s*/gc;
print(" Capitalized"), redo LOOP
if /\G\p{Lu}\p{Ll}+\b[,.;]?\s*/gc;
print(" MiXeD"), redo LOOP
if /\G\pL+\b[,.;]?\s*/gc;
print(" alphanumeric"), redo LOOP
if /\G[\p{Alpha}\pN]+\b[,.;]?\s*/gc;
print(" line-noise"), redo LOOP if /\G\W+/gc;
print ". That's all!\n";
}And here's the output (split into several lines so it fits, bestie):
line-noise lowercase line-noise UPPERCASE line-noise UPPERCASE
line-noise lowercase line-noise lowercase line-noise lowercase
lowercase line-noise lowercase lowercase line-noise lowercase
lowercase line-noise MiXeD line-noise. That's all!๐ฆ "m?PATTERN?msixpodualngc" ๐ฆ
This one is literally just like the m/PATTERN/ search, except โ and this is the whole personality โ it matches only once between calls to the reset() operator. It's a genuinely useful optimization when you only want to see the first occurrence of something in each file of a set of files, for instance. And only m?? patterns local to the current package get reset. ๐
while (<>) {
if (m?^$?) {
# blank line between header and body
}
} continue {
reset if eof; # clear m?? status for next file
}Another example โ this one switched the first "latin1" encoding it finds to "utf8" in a pod file:
s//utf8/ if m? ^ =encoding \h+ \K latin1 ?x;The match-once behavior is controlled by the match delimiter being ? โ with any other delimiter this is just the normal m// operator, no special treatment, nothing. ๐
โ ๏ธ lore drop: in the past, the leadingminm?PATTERN?was optional, but omitting it would produce a deprecation warning. As of v5.22.0, omitting it produces a syntax error. If you encounter this construct in older code, you can just addm. fixed. ๐ซถ
๐ธ "s/PATTERN/REPLACEMENT/msixpodualngcer" ๐ธ
Okay so this is the substitution icon herself. She searches a string for a pattern, and if it's found, she replaces that pattern with the replacement text and returns the number of substitutions made. Otherwise she returns false โ and "false" here is a value that is both an empty string ("") and numeric zero (0), as described in "Relational Operators". Two for one, no cap. ๐
If the /r (non-destructive) option is used then it runs the substitution on a copy of the string, and instead of returning the number of substitutions, it returns the copy whether or not a substitution occurred. The original string is never changed when /r is used. And the copy will always be a plain string, even if the input is an object or a tied variable. Slay.
If no string is specified via the =~ or !~ operator, the $_ variable is searched and modified. Unless the /r option is used, the string specified must be a scalar variable, an array element, a hash element, or an assignment to one of those โ that is, some sort of scalar lvalue. Those are the rules, bestie. ๐
If the delimiter chosen is a single quote, no variable interpolation is done on either the PATTERN or the REPLACEMENT. Otherwise, if the PATTERN contains a $ that looks like a variable rather than an end-of-string test, the variable will be interpolated into the pattern at run-time. If you want the pattern compiled only once โ the first time the variable is interpolated โ use the /o option. If the pattern evaluates to the empty string, the last successfully executed regular expression is used instead. See perlre for further explanation on these. ๐
Options are as with m// with the addition of the following replacement-specific options:
eโ Evaluate the right side as a block of code.eeโ Evaluate the right side as a block of code, theneval()the resulting string.rโ Return substitution and leave the original string untouched.
Any non-whitespace delimiter may replace the slashes. Add space after the s when using a character allowed in identifiers. If single quotes are used, no interpretation is done on the replacement string (the /e modifier overrides this, however). Note that Perl treats backticks as normal delimiters; the replacement text is not evaluated as a command. If the PATTERN is delimited by bracketing quotes, the REPLACEMENT has its own pair of quotes, which may or may not be bracketing quotes, for example, s(foo)(bar) or s<foo>/bar/. A /e will cause the replacement portion to be treated as a full-fledged block of Perl code and evaluated right then and there. It is, however, syntax checked at compile-time. A second e modifier will cause the result of the block of code to be evaled. ๐
That is, s/FOO/BAR/e will compute the replacement string at match time as if it had been written as do { BAR } (see "do BLOCK" in perlfunc). Each additional e modifier wraps a call to eval around the result: s/FOO/BAR/ee will compute the replacement string like eval(do { BAR }), s/FOO/BAR/eee like eval(eval(do { BAR })), etc. It's giving recursion realness. ๐
Examples, and honestly this block is a whole mood board:
s/\bgreen\b/mauve/g; # don't change wintergreen
$path =~ s|/usr/bin|/usr/local/bin|;
s/Login: $foo/Login: $bar/; # run-time pattern
($foo = $bar) =~ s/this/that/; # copy first, then
# change
($foo = "$bar") =~ s/this/that/; # convert to string,
# copy, then change
$foo = $bar =~ s/this/that/r; # Same as above using /r
$foo = $bar =~ s/this/that/r
=~ s/that/the other/r; # Chained substitutes
# using /r
@foo = map { s/this/that/r } @bar # /r is very useful in
# maps
$count = ($paragraph =~ s/Mister\b/Mr./g); # get change-cnt
$_ = 'abc123xyz';
s/\d+/$&*2/e; # yields 'abc246xyz'
s/\d+/sprintf("%5d",$&)/e; # yields 'abc 246xyz'
s/\w/$& x 2/eg; # yields 'aabbcc 224466xxyyzz'
s/%(.)/$percent{$1}/g; # change percent escapes; no /e
s/%(.)/$percent{$1} || $&/ge; # expr now, so /e
s/^=(\w+)/pod($1)/ge; # use function call
$_ = 'abc123xyz';
$x = s/abc/def/r; # $x is 'def123xyz' and
# $_ remains 'abc123xyz'.
# expand variables in $_, but dynamics only, using
# symbolic dereferencing
s/\$(\w+)/${$1}/g;
# Add one to the value of any numbers in the string
s/(\d+)/1 + $1/eg;
# Titlecase words in the last 30 characters only (presuming
# that the substring doesn't start in the middle of a word)
substr($str, -30) =~ s/\b(\p{Alpha})(\p{Alpha}*)\b/\u$1\L$2/g;
# This will expand any embedded scalar variable
# (including lexicals) in $_ : First $1 is interpolated
# to the variable name, and then evaluated
s/(\$\w+)/$1/eeg;# Same as above, but perhaps clearer
s/(\$\w+)/eval($1)/eg;
# Delete (most) C comments.
$program =~ s {
/\* # Match the opening delimiter.
.*? # Match a minimal number of characters.
\*/ # Match the closing delimiter.
} []gsx;
s/^\s*(.*?)\s*$/$1/; # trim whitespace in $_,
# expensively
for ($variable) { # trim whitespace in $variable,
# cheap
s/^\s+//;
s/\s+$//;
}
s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields
$foo !~ s/A/a/g; # Lowercase all A's in $foo; return
# 0 if any were found and changed;
# otherwise return 1okay real talk, notice how in that last one we're using $ instead of \? that's a whole thing. Unlike sed, the \<digit> form only ever shows up on the left hand side. Everywhere else? It's $<digit>. write it down bestie, this trips people up. ๐
Sometimes a single /g just isn't gonna get you all the changes you want, and that's not a you problem, that's just how it is. Here are the two classic cases:
# put commas in the right places in an integer
1 while s/(\d)(\d\d\d)(?!\d)/$1,$2/g;
# expand tabs to 8-column spacing
1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;And one little caveat ๐ซถ: s/// does accept the /c flag, but it has no effect beyond producing a warning if warnings are enabled. It's giving "flag that's just there to vibe". ๐
โจ Transliteration Quote-Like Operators โจ
tr/SEARCHLIST/REPLACEMENTLIST/cdsr y/SEARCHLIST/REPLACEMENTLIST/cdsr
okay so these swap out all the characters found in the search list (or not found, if you threw in the /c modifier) for the character sitting in the positionally corresponding spot in the replacement list โ and they might delete some of them too, it depends on which modifiers you specified. Unless the /r flag is hanging around, they return the number of characters replaced or deleted. And if you didn't hand them a string via =~ or !~, then $_ is what gets transliterated. main character $_, honestly. ๐
For the sed devotees in the chat: y is provided as a synonym for tr. same energy, different letter.
If the /r (non-destructive) option is present, a new copy of the string is made and its characters transliterated, and this copy is what gets returned โ instead of a count โ no matter whether it was modified or not. The original string is always left unchanged, periodt. And that new copy is always a plain string, even if the input string is an object or a tied variable. โจ
Unless the /r option is used, the string specified with =~ must be a scalar variable, an array element, a hash element, or an assignment to one of those. In other words: an lvalue. No lvalue, no party. ๐ซ
So, the characters delimiting SEARCHLIST and REPLACEMENTLIST can be any printable character, not just forward slashes. But heads up: if they're single quotes (tr'SEARCHLIST'REPLACEMENTLIST'), the only interpolation that happens is removal of \ from pairs of \\ โ which means hyphens get read literally instead of specifying a character range. sneaky but important.
Otherwise, a character range can be specified with a hyphen, so tr/A-J/0-9/ does the exact same replacement as tr/ACEGIBDFHJ/0246813579/. ๐ฅ
If the SEARCHLIST is delimited by bracketing quotes, the REPLACEMENTLIST must have its own pair of quotes, which may or may not be bracketing quotes; for example, tr(aeiouy)(yuoiea) or tr[+\-*/]"ABCD". That final example shows a way to visually clarify what is going on for people who are more familiar with regular expression patterns than with tr, and who may think forward slash delimiters imply that tr is more like a regular expression pattern than it actually is. (Another option might be to use tr[...][...].)
ngl tr is not fully like bracketed character classes โ just (significantly) more like them than it is to full patterns. ๐
For example, characters appearing more than once in either list behave differently here than in patterns, and tr lists do not allow backslashed character classes such as \d or \pL, nor variable interpolation โ so $ and @ are always treated as literals. always always.
The allowed elements are literals plus \' (meaning a single quote). If the delimiters aren't single quotes, also allowed are any of the escape sequences accepted in double-quoted strings. (Escape sequence details are in the table near the beginning of this section. scroll up bestie ๐
)
A hyphen at the beginning or end, or preceded by a backslash, is also always considered a literal. And precede a delimiter character with a backslash to allow it.
Now for the part everyone gets wrong: the tr operator is not equivalent to the tr(1) utility. tr[a-z][A-Z] will uppercase the 26 letters a through z, but for case changing not confined to ASCII, use lc, uc, lcfirst, ucfirst (all documented in perlfunc), or the substitution operator s/PATTERN/REPLACEMENT/ (with \U, \u, \L, and \l string-interpolation escapes in the REPLACEMENT portion). there, I said it ๐ซถ
Most ranges are unportable between character sets, but certain ones signal Perl to do special handling to make them portable. There are two classes of portable ranges. The first are any subsets of the ranges A-Z, a-z, and 0-9, when expressed as literal characters.
tr/h-k/H-K/That one capitalizes the letters h, i, j, and k and nothing else, no matter what the platform's character set is. Iconic. โจ
In contrast, all of
tr/\x68-\x6B/\x48-\x4B/
tr/h-\x6B/H-\x4B/
tr/\x68-k/\x48-K/do the same capitalizations as the previous example when run on ASCII platforms, but something completely different on EBCDIC ones. ๐ completely completely different.
The second class of portable ranges is invoked when one or both of the range's end points are expressed as \N{...}
$string =~ tr/\N{U+20}-\N{U+7E}//d;removes from $string all the platform's characters which are equivalent to any of Unicode U+0020, U+0021, ... U+007D, U+007E. That's a portable range, and it has the same effect on every platform it is run on. In this example, these are the ASCII printable characters. So after this is run, $string has only controls and characters which have no ASCII equivalents. a glo up fr fr.
But, even for portable ranges, it is not generally obvious what is included without having to look things up in the manual. ๐ A sound principle is to use only ranges that both begin from, and end at, either ASCII alphabetics of equal case (b-e, B-E), or digits (1-4). Anything else is unclear (and unportable unless \N{...} is used). If in doubt, spell out the character sets in full. no guessing, bestie.
Options:
cโ Complement the SEARCHLIST. ๐ชdโ Delete found but unreplaced characters. ๐๏ธrโ Return the modified string instead of a count, and leave the original string untouched. ๐ซถsโ Squash duplicate replaced characters. ๐ฅ
If the /d modifier is specified, any characters specified by SEARCHLIST not found in REPLACEMENTLIST are deleted. (Note that this is slightly more flexible than the behavior of some tr programs, which delete anything they find in the SEARCHLIST, period.) period.
If the /s modifier is specified, sequences of characters, all in a row, that were transliterated to the same character are squashed down to a single instance of that character.
my $x = "aaabbbca";
$x =~ tr/ab/dd/s; # $x now is "dcd"okay so if the /d modifier is used, the REPLACEMENTLIST is always interpreted exactly as specified. Otherwise, if the REPLACEMENTLIST is shorter than the SEARCHLIST, the final character, if any, is replicated until it is long enough. ๐ There won't be a final character if and only if the REPLACEMENTLIST is empty, in which case REPLACEMENTLIST is copied from SEARCHLIST. An empty REPLACEMENTLIST is useful for counting characters in a class, or for squashing character sequences in a class. lowkey a hack, highkey a feature.
tr/abcd// tr/abcd/abcd/
tr/abcd/AB/ tr/abcd/ABBB/
tr/abcd//d s/[abcd]//g
tr/abcd/AB/d (tr/ab/AB/ + s/[cd]//g) - but run togetherIf the /c modifier is specified, the characters to be transliterated are the ones NOT in SEARCHLIST, that is, it is complemented. If /d and/or /s are also specified, they apply to the complemented SEARCHLIST. Recall, that if REPLACEMENTLIST is empty (except under /d) a copy of SEARCHLIST is used instead. That copy is made after complementing under /c. SEARCHLIST is sorted by code point order after complementing, and any REPLACEMENTLIST is applied to that sorted result. This means that under /c, the order of the characters specified in SEARCHLIST is irrelevant. ๐ This can lead to different results on EBCDIC systems if REPLACEMENTLIST contains more than one character, hence it is generally non-portable to use /c with such a REPLACEMENTLIST.
Another way of describing the operation is this: If /c is specified, the SEARCHLIST is sorted by code point order, then complemented. If REPLACEMENTLIST is empty and /d is not specified, REPLACEMENTLIST is replaced by a copy of SEARCHLIST (as modified under /c), and these potentially modified lists are used as the basis for what follows. Any character in the target string that isn't in SEARCHLIST is passed through unchanged. Every other character in the target string is replaced by the character in REPLACEMENTLIST that positionally corresponds to its mate in SEARCHLIST, except that under /s, the 2nd and following characters are squeezed out in a sequence of characters in a row that all translate to the same character. If SEARCHLIST is longer than REPLACEMENTLIST, characters in the target string that match a character in SEARCHLIST that doesn't have a correspondence in REPLACEMENTLIST are either deleted from the target string if /d is specified; or replaced by the final character in REPLACEMENTLIST if /d isn't specified. that's the whole mechanic, queen ๐
Some examples:
$ARGV[1] =~ tr/A-Z/a-z/; # canonicalize to lower case ASCII
$cnt = tr/*/*/; # count the stars in $_
$cnt = tr/*//; # same thing
$cnt = $sky =~ tr/*/*/; # count the stars in $sky
$cnt = $sky =~ tr/*//; # same thing$cnt = $sky =~ tr/*//c; # count all the non-stars in $sky
$cnt = $sky =~ tr/*/*/c; # same, but transliterate each non-star
# into a star, leaving the already-stars
# alone. Afterwards, everything in
# $sky is a star.
$cnt = tr/0-9//; # count the ASCII digits in $_
tr/a-zA-Z//s; # bookkeeper -> bokeper
tr/o/o/s; # bookkeeper -> bokkeeper
tr/oe/oe/s; # bookkeeper -> bokkeper
tr/oe//s; # bookkeeper -> bokkeper
tr/oe/o/s; # bookkeeper -> bokkopor
($HOST = $host) =~ tr/a-z/A-Z/;
$HOST = $host =~ tr/a-z/A-Z/r; # same thing
$HOST = $host =~ tr/a-z/A-Z/r # chained with s///r
=~ s/:/ -p/r;
tr/a-zA-Z/ /cs; # change non-alphas to single space
@stripped = map tr/a-zA-Z/ /csr, @original;
# /r with map
tr [\200-\377]
[\000-\177]; # wickedly delete 8th bit
$foo !~ tr/A/a/ # transliterate all the A's in $foo to 'a',
# return 0 if any were found and changed.
# Otherwise return 1Okay bestie, this next bit is SO important and also a little mind-bendy: transliterated characters do not get rescanned for further transliteration. Even if a character you're subbing in (from REPLACEMENTLIST) also shows up somewhere in the SEARCHLIST, it does not get round two. Like:
tr/ox/xo/; # oxxo -> xooxAnd if you're messy enough to give multiple transliterations for one character, only the first one counts:
tr/AAA/XYZ/That will transliterate any A to X. Periodt. ๐
Also, because the transliteration table gets built way back at compile time, neither the SEARCHLIST nor the REPLACEMENTLIST gets run through double quote interpolation. Which means if you want variables in there, you gotta use eval():
eval "tr/$oldlist/$newlist/";
die $@ if $@;
eval "tr/$oldlist/$newlist/, 1" or die $@;๐ธ Here-docs ๐ธ
"<<EOT"
"<<~EOT"
So a here-doc is a line-oriented way of quoting, and it's literally borrowed from the shell's "here-document" syntax (iykyk). You write << and then a string to terminate the quoted material with, and every line after the current one โ all the way down to that terminating string โ is the value of the thing. It's giving "the text lives here."
An example, because of course:
my $endng = <<WHIMPER;
This is the way the text ends.
This is the way the text ends.
Not with a bang, but with a
WHIMPERSo in that case the terminator is an identifier, the word WHIMPER. Usually people capitalize the identifier just so it pops visually, but honestly that's pure convention and totally not required. โจ
The terminator can be wrapped in quotes (we get into that below), but if you don't quote it, the text of the here-doc behaves exactly like it was double-quoted.
my $person = 'John';
print uc <<EOT;
Hello, $person!
And the text goes on.
EOTWhich gives you:
HELLO, JOHN!
AND THE TEXT GOES ON.And bestie, the parentheses on that uc call are optional, you don't have to drop them:
print uc(<<EOT);
Hello, $person!
And the text goes on.
EOTHELLO, JOHN!
AND THE TEXT GOES ON.You can also mix a here-doc in with other stuff, no problem:
print <<EOT, "Followed by the next argument\n";
Hello, $person!
And the text goes on.
EOTHello, John!
And the text goes on.
Followed by the next argumentAnd you can stack multiple here-docs, because why not:
print <<EOT1, <<EOT2;
Hello, $person!
And the text goes on.
EOT1
Followed by the next argument
EOT2Hello, John!
And the text goes on.
Followed by the next argumentThe terminator doesn't have to be a single word either โ it can be some quoted text:
my $pagliaci = << "La Commedia e finita!";
A troupe comes to town to perform a play, a comedy. The lead actress
and lead actor are in an unhappy marriage. On stage, he stabs her
for real; then he stabs her lover who has rushed from the audience to
defend her. Both die.
La Commedia e finita!Heads up! There can be no space between the << and the identifier, unless the terminator is quoted, like in that example right above. โ๏ธ
And the quoting rules for the terminator? They're completely unrelated to Perl's normal quoting rules. Only "", '', and `` can quote it โ NOT q(), qq(), and friends. The one and only interpolation is backslashing the quoting character:
print << "abc\"def";
testing...
abc"defThe terminating string has to appear by itself โ unquoted, with no surrounding whitespace โ on the terminating line. It also can't span multiple lines. The general rule: the identifier must be a string literal. Stick with that and you're safe, bestie. ๐ซถ
Don't forget the semicolon at the end to finish the statement! Perl has no idea you're not about to do this:
print <<ABC
10
ABC
+ 20;which prints 30 and no line terminator. ๐ญ
If you want your here-doc to not have a line terminator on the final line, use chomp():
chomp($string = <<'END');
This is the first line.
This second line won't end in a \n.
ENDIf you use a here-doc inside a delimited construct โ like inside s///eg โ the quoted material still has to come on the line following the <<TERMINATOR marker, which means it might end up sitting inside the delimited construct:
s/this/<<E . 'that'
the other
E
. 'more '/eg;(It works this way as of Perl 5.18. Historically it was inconsistent, and you'd have to write
s/this/<<E . 'that'
. 'more '/eg;
the other
Eoutside of string evals.)
Okay so here's the glow-up: a problem with the here-doc syntax we just described is that it has to sit at the left margin of your program, which completely shreds your indentation. Rude. But starting in Perl v5.26, the tilde ~ modifier lets you indent your here-docs so your code stays cute and readable:
if ($some_var) {
print <<~EOF;
This is a here-doc
EOF
}This prints...
This is a here-doc...with no leading whitespace. Slay. ๐
The line containing the delimiter that marks the end of the here-doc is what sets the indentation template for the whole thing. And compilation will croak if any non-empty line inside the here-doc doesn't begin with the exact indentation of the terminating line. (An "empty line" is the single character "\n".) So like, say the terminating line starts with a tab followed by 4 spaces โ then every non-empty line in the here-doc has to start with a tab then 4 spaces. Those get stripped from each line, and whatever leading whitespace is left over counts as that line's indentation. Currently only TAB and SPACE characters count as whitespace for this. Tabs and spaces can be mixed, but they get matched exactly โ tabs stay tabs and are not expanded.
Extra whitespace at the start (beyond whatever came before the delimiter) is preserved:
print <<~EOF;
This text is not indented
This text is indented with two spaces
This line is indented with two tabs, though those may
have been converted to spaces by various filters by
the time you read this.
EOF๐ Quoting the delimiter ๐
As we said up top, the terminating string can be quoted. There are three types of quoting possible, and the type you pick decides how the text gets treated.
๐ Double Quotes
Double quotes around the terminating word or string behave exactly as if there were no quotes at all โ the text gets interpolated using precisely the same rules as normal double-quoted strings, like in every example above. So:
my $person = 'John';
print uc << "EOT";
Hello, $person!
And the text goes on.
EOTyields:
HELLO, JOHN!
AND THE TEXT GOES ON.Which is, obviously, the same result as without quotes. Same energy. ๐
๐ Single Quotes
If you use single quotes instead, the text is treated literally, with zero interpolation of its content:
my $person = 'John';
print uc <<'EOT';
Hello, $person!
And the text goes on.
EOTHELLO, $PERSON!
AND THE TEXT GOES ON.The difference between a single-quoted here-doc and a single-quoted string is that backslashes have no special meaning in a here-doc โ \\ is two backslashes, not one like it would be in literally every other quoting construct. Noted. ๐
And just like in the shell, a backslashed bareword after the << means the same thing as a single-quoted string:
$cost = <<'VISTA'; # hasta la ...
That'll be $10 please, ma'am.
VISTA
$cost = <<\VISTA; # Same thing!
That'll be $10 please, ma'am.
VISTAThese two forms are the only ways of quoting in Perl where you don't have to stress about escaping your content โ which is exactly why code generators can and do make good use of them. ๐
๐ง Backticks
Finally, if you use backticks to quote the terminating string, the content of the here-doc is treated just as if it were a string wrapped in backticks. So the content gets interpolated as though it were double quoted, then executed via the shell, with the results of the execution returned. Chef's kiss.
print << `EOC`; # execute command and get results
echo hi there
EOCโญ Gory details of parsing quoted constructs โญ
When Perl is staring down something that could have several different readings, it uses the DWIM principle โ that's "Do What I Mean" โ to pick the most probable interpretation. This strategy is so successful that Perl programmers often don't even suspect the ambiguity of what they write. But every now and then, Perl's notions differ substantially from what the author honestly meant. ๐
okay so this section is literally here to clear up how Perl handles quoted constructs ๐. the most common reason to learn this is to unravel labyrinthine regular expressions, but because the initial steps of parsing are the same for all quoting operators, they're all discussed together. no cap.
The most important Perl parsing rule is the first one discussed below: when processing a quoted construct, Perl first finds the end of that construct, then interprets its contents. If you understand this rule, you may skip the rest of this section on the first reading. The other rules are likely to contradict the user's expectations much less frequently than this first one. fr fr.
Some passes discussed below are performed concurrently, but because their results are the same, we consider them individually. For different quoting constructs, Perl performs different numbers of passes, from one to four, but these passes are always performed in the same order. slay.
Finding the end ๐ธ
The first pass is finding the end of the quoted construct. This results in saving to a safe location a copy of the text (between the starting and ending delimiters), normalized as necessary to avoid needing to know what the original delimiters were.
If the construct is a here-doc, the ending delimiter is a line that has a terminating string as the content. Therefore <<EOF is terminated by EOF immediately followed by \n and starting from the first column of the terminating line. When searching for the terminating line of a here-doc, nothing is skipped. In other words, lines after the here-doc syntax are compared with the terminating string line by line.
For the constructs except here-docs, single characters are used as starting and ending delimiters. If the starting delimiter is an opening punctuation (that is (, [, {, or <), the ending delimiter is the corresponding closing punctuation (that is ), ], }, or >). If the starting delimiter is an unpaired character like / or a closing punctuation, the ending delimiter is the same as the starting delimiter. Therefore a / terminates a qq// construct, while a ] terminates both qq[] and qq]] constructs. iconic.
When searching for single-character delimiters, escaped delimiters and \\ are skipped. For example, while searching for terminating /, combinations of \\ and \/ are skipped. If the delimiters are bracketing, nested pairs are also skipped. For example, while searching for a closing ] paired with the opening [, combinations of \\, \], and \[ are all skipped, and nested [ and ] are skipped as well. However, when backslashes are used as the delimiters (like qq\\ and tr\\\), nothing is skipped. During the search for the end, backslashes that escape delimiters or other backslashes are removed (exactly speaking, they are not copied to the safe location).
For constructs with three-part delimiters (s///, y///, and tr///), the search is repeated once more. If the first delimiter is not an opening punctuation, the three delimiters must be the same, such as s!!! and tr))), in which case the second delimiter terminates the left part and starts the right part at once. If the left part is delimited by bracketing punctuation (that is (), [], {}, or <>), the right part needs another pair of delimiters such as s(){} and tr[]//. In these cases, whitespace and comments are allowed between the two parts, although the comment must follow at least one whitespace character; otherwise a character expected as the start of the comment may be regarded as the starting delimiter of the right part. periodt.
During this search no attention is paid to the semantics of the construct. Thus:
"$hash{"$foo/$bar"}"or:
m/
bar # NOT a comment, this slash / terminated m//!
/xdo not form legal quoted expressions. The quoted part ends on the first " and /, and the rest happens to be a syntax error. Because the slash that terminated m// was followed by a SPACE, the example above is not m//x, but rather m// with no /x modifier. So the embedded # is interpreted as a literal #.
bestie, that m/ block is giving "I thought I was clever" energy and it is NOT valid. Perl does not read your mind here. ๐
Also no attention is paid to \c\ (multichar control char syntax) during this search. Thus the second \ in qq/\c\/ is interpreted as a part of \/, and the following / is not recognized as a delimiter. Instead, use \034 or \x1c at the end of quoted constructs.
Interpolation โจ
The next step is interpolation in the text obtained, which is now delimiter-independent. There are multiple cases.
<<'EOF'
No interpolation is performed. Note that the combination \\ is left intact, since escaped delimiters are not available for here-docs.
m'', the pattern of s'''
No interpolation is performed at this stage. Any backslashed sequences including \\ are treated at the stage of "Parsing regular expressions".
'', q//, tr''', y''', the replacement of s'''
The only interpolation is removal of \ from pairs of \\. Therefore - in tr''' and y''' is treated literally as a hyphen and no character range is available. \1 in the replacement of s''' does not work as $1.
tr///, y///
No variable interpolation occurs. String modifying combinations for case and quoting such as \Q, \U, and \E are not recognized. The other escape sequences such as \200 and \t and backslashed characters such as \\ and \- are converted to appropriate literals. The character - is treated specially and therefore \- is treated as a literal -.
"", ``, qq//, qx//, <file*glob>, <<"EOF"
\Q, \U, \u, \L, \l, \F (possibly paired with \E) are converted to corresponding Perl constructs. Thus, $foo\Qbaz$bar is converted to $foo . (quotemeta("baz" . $bar)) internally. The other escape sequences such as \200 and \t and backslashed characters such as \\ and \- are replaced with appropriate expansions.
Let it be stressed that whatever falls between \Q and \E is interpolated in the usual way. Something like \Q\\E has no \E inside. Instead, it has \Q, \\, and E, so the result is the same as for \\\\E. As a general rule, backslashes between \Q and \E may lead to counterintuitive results. So, \Q\t\E is converted to quotemeta("\t"), which is the same as \\\t (since TAB is not alphanumeric). Note also that:
$str = '\t';
return "\Q$str";may be closer to the conjectural intention of the writer of \Q\t\E.
Interpolated scalars and arrays are converted internally to the join and . catenation operations. Thus, $foo XXX '@arr' becomes:
$foo . " XXX '" . (join $", @arr) . "'";All operations above are performed simultaneously, left to right.
Because the result of \Q STRING \E has all metacharacters quoted, there is no way to insert a literal $ or @ inside a \Q\E pair. If protected by \, $ will be quoted to become \\\$; if not, it is interpreted as the start of an interpolated scalar.
Note also that the interpolation code needs to make a decision on where the interpolated scalar ends. For instance, whether a $x -> {c} really means:
"a " . $x . " -> {c}";or:
"a " . $x -> {c};Most of the time, the longest possible text that does not include spaces between components and which contains matching braces or brackets. because the outcome may be determined by voting based on heuristic estimators, the result is not strictly predictable. Fortunately, it's usually correct for ambiguous cases.
The replacement of s///
Processing of \Q, \U, \u, \L, \l, \F and interpolation happens as with qq// constructs.
It is at this step that \1 is begrudgingly converted to $1 in the replacement text of s///, in order to correct the incorrigible sed hackers who haven't picked up the saner idiom yet. A warning is emitted if the use warnings pragma or the -w command-line flag (that is, the $^W variable) was set.
RE in m?RE?, /RE/, m/RE/, s/RE/foo/
Processing of \Q, \U, \u, \L, \l, \F, \E, and interpolation happens (almost) as with qq// constructs.
Processing of \N{...} is also done here, and compiled into an intermediate form for the regex compiler. (This is because, as mentioned below, the regex compilation may be done at execution time, and \N{...} is a compile-time construct.)
However any other combinations of \ followed by a character are not substituted but only skipped, in order to parse them as regular expressions at the following step. As \c is skipped at this step, @ of \c@ in RE is possibly treated as an array symbol (for example @foo), even though the same text in qq// gives interpolation of \c@.
Code blocks such as (?{BLOCK}) are handled by temporarily passing control back to the perl parser, in a similar way that an interpolated array subscript expression such as foo$array[1+f("[xyz")]bar would be.
Moreover, inside (?{BLOCK}), (?# comment ), and a #-comment in a /x-regular expression, no processing is performed whatsoever. This is the first step at which the presence of the /x modifier is relevant.
Interpolation in patterns has several quirks: $|, $(, $), @+ and @- are not interpolated, and constructs $var[SOMETHING] are voted (by several different estimators) to be either an array element or $var followed by an RE alternative. This is where the notation ${arr[$bar]} comes handy: /${arr[0-9]}/ is interpreted as array element -9, not as a regular expression from the variable $arr followed by a digit, which would be the interpretation of /$arr[0-9]/. Since voting among different estimators may occur, the result is not predictable.
โฆ
And like, the way \\ gets no processing at all? That comes with receipts โ specific restrictions on what your post-processed text can even be. Say your delimiter is /. Bestie, you literally cannot get the combo \/ into the result of this step. Here's why: / will finish the regular expression, \/ gets stripped down to / on the previous step, and \\/ is just left as is. Since / is equivalent to \/ inside a regular expression, this genuinely does not matterโฆ unless your delimiter happens to be character special to the RE engine, like in s*foo*bar*, m[foo], or m?foo? โ or an alphanumeric char, as in:
m m ^ a \s* b mmx;So in that RE up there (yes it's intentionally obfuscated for illustration, it's giving chaos on purpose ๐), the delimiter is m, the modifier is mx, and after delimiter-removal the RE is exactly the same as for m/ ^ a \s* b /mx. There's more than one reason you're encouraged to restrict your delimiters to non-alphanumeric, non-whitespace choices. Fr fr, take the advice.
This step is the last one for all constructs except regular expressions, which get processed further. Those ones are not done yet, bestie, they have more โจjourneyโจ ahead.
โจ Parsing regular expressions โจ
Okay so the previous steps all happened during the compilation of Perl code, but this one? It happens at run time. Though lowkey it may be optimized to be calculated at compile time if appropriate. After preprocessing described above, and possibly after evaluation if concatenation, joining, casing translation, or metaquoting are involved, the resulting string gets handed straight to the RE engine for compilation.
Whatever goes down inside the RE engine might be better discussed in perlre, but for the sake of continuity, we shall do so here. ๐ซถ
This is another step where the presence of the /x modifier is relevant. The RE engine scans the string from left to right and converts it into a finite automaton. Iconic behavior honestly.
Backslashed characters are either replaced with corresponding literal strings (as with \{), or else they generate special nodes in the finite automaton (as with \b). Characters special to the RE engine (such as |) generate corresponding nodes or groups of nodes. (?#...) comments are ignored โ not me just skipping them ๐
. All the rest is either converted to literal strings to match, or else is ignored (as is whitespace and #-style comments if /x is present).
Parsing of the bracketed character class construct, [...], is rather different than the rule used for the rest of the pattern. The terminator of this construct is found using the same rules as for finding the terminator of a {}-delimited construct, the only exception being that ] immediately following [ is treated as though preceded by a backslash.
The terminator of runtime (?{...}) is found by temporarily switching control to the perl parser, which should stop at the point where the logically balancing terminating } is found.
It is possible to inspect both the string given to RE engine and the resulting finite automaton. See the arguments debug/debugcolor in the use re pragma, as well as Perl's -Dr command-line switch documented in "Command Switches" in perlrun. Go look, it's so fun ๐ฅ
โจ Optimization of regular expressions โจ
This step is listed for completeness only. Since it does not change semantics, details of this step are not documented and are subject to change without notice. So don't come for me, I literally can't tell you more than the manpage does ๐. This step is performed over the finite automaton that was generated during the previous pass.
It is at this stage that split() silently optimizes /^/ to mean /^/m. Sneaky little guy, isn't it.
โจ I/O Operators โจ
There are several I/O operators you should know about. Buckle up, this is the good part ๐
A string enclosed by backticks (grave accents) first undergoes double-quote interpolation. It is then interpreted as an external command, and the output of that command is the value of the backtick string, like in a shell. In scalar context, a single string consisting of all output is returned. In list context, a list of values is returned, one per line of output. (You can set $/ to use a different line terminator.) The command is executed each time the pseudo-literal is evaluated. The status value of the command is returned in $? (see perlvar for the interpretation of $?). Unlike in csh, no translation is done on the return data โ newlines remain newlines. Unlike in any of the shells, single quotes do not hide variable names in the command from interpretation. To pass a literal dollar-sign through to the shell you need to hide it with a backslash. The generalized form of backticks is qx//, or you can call the readpipe in perlfunc function. (Because backticks always undergo shell expansion as well, see perlsec for security concerns.)
โ ๏ธ Okay real talk for a sec: that last bit is a security thing. Backticks always undergo shell expansion. perlsec. Go read it. ๐
In scalar context, evaluating a filehandle in angle brackets yields the next line from that file (the newline, if any, included), or undef at end-of-file or on error. When $/ is set to undef (sometimes known as file-slurp mode) and the file is empty, it returns '' the first time, followed by undef subsequently.
Ordinarily you must assign the returned value to a variable, but there is one situation where an automatic assignment happens. If and only if the input symbol is the only thing inside the conditional of a while statement (even if disguised as a for(;;) loop), the value is automatically assigned to the global variable $_, destroying whatever was there previously. Yeah. It's a whole thing. (This may seem like an odd thing to you, but you'll use the construct in almost every Perl script you write.) The $_ variable is not implicitly localized. You'll have to put a local $_; before the loop if you want that to happen. Furthermore, if the input symbol or an explicit assignment of the input symbol to a scalar is used as a while/for condition, then the condition actually tests for definedness of the expression's value, not for its regular truth value.
Thus the following lines are equivalent:
while (defined($_ = <STDIN>)) { print; }
while ($_ = <STDIN>) { print; }
while (<STDIN>) { print; }
for (;<STDIN>;) { print; }
print while defined($_ = <STDIN>);
print while ($_ = <STDIN>);
print while <STDIN>;This also behaves similarly, but assigns to a lexical variable instead of to $_:
while (my $line = <STDIN>) { print $line }In these loop constructs, the assigned value (whether assignment is automatic or explicit) is then tested to see whether it is defined. The defined test avoids problems where the line has a string value that would be treated as false by Perl โ for example a "" or a "0" with no trailing newline. If you really mean for such values to terminate the loop, they should be tested for explicitly:
while (($_ = <STDIN>) ne '0') { ... }
while (<STDIN>) { last unless $_; ... }In other boolean contexts, <FILEHANDLE> without an explicit defined test or comparison elicits a warning if the use warnings pragma or the -w command-line switch (the $^W variable) is in effect. So likeโฆ in other contexts, pls be careful. ๐คจ
The filehandles STDIN, STDOUT, and STDERR are predefined. (The filehandles stdin, stdout, and stderr will also work except in packages, where they would be interpreted as local identifiers rather than global.) Additional filehandles may be created with the open() function, amongst others. See perlopentut and open in perlfunc for details on this.
If a <FILEHANDLE> is used in a context that is looking for a list, a list comprising all input lines is returned, one line per list element. It's easy to grow to a rather large data space this way, so use with care. ๐
<FILEHANDLE> may also be spelled readline(*FILEHANDLE). See readline in perlfunc.
The null filehandle <> (sometimes called the diamond operator) is special: it can be used to emulate the behavior of sed and awk, and any other Unix filter program that takes a list of filenames, doing the same to each line of input from all of them. Input from <> comes either from standard input, or from each file listed on the command line. Here's how it works: the first time <> is evaluated, the @ARGV array is checked, and if it is empty, $ARGV[0] is set to -, which when opened gives you standard input. The @ARGV array is then processed as a list of filenames. The loop
while (<>) {
... # code for each line
}is equivalent to the following Perl-like pseudo code:
unshift(@ARGV, '-') unless @ARGV;
while ($ARGV = shift) {
open(ARGV, $ARGV);
while (<ARGV>) {
... # code for each line
}
}except that it isn't so cumbersome to say, and will actually work. It really does shift the @ARGV array and put the current filename into the $ARGV variable. It also uses filehandle ARGV internally. <> is just a synonym for <ARGV>, which is magical. (The pseudo code above doesn't work because it treats <ARGV> as non-magical.) ๐ญ the fake version just can't do it, it's not built different.
Since the null filehandle uses the two argument form of open in perlfunc it interprets special characters, so if you have a script like this:
while (<>) {
print;
}and call it with perl dangerous.pl 'rm -rfv *|', it actually opens a pipe, executes the rm command and reads rm's output from that pipe. Yeah bestie, DANGEROUS. ๐ If you want all items in @ARGV to be interpreted as file names, you can use the module ARGV::readonly from CPAN, or use the double diamond operator:
while (<<>>) {
print;
}Using double angle brackets inside of a while causes the open to use the three argument form (with the second argument being <), so all arguments in ARGV are treated as literal filenames (including -). (Note that for convenience, if you use <<>> and if @ARGV is empty, it will still read from the standard input.)
You can modify @ARGV before the first <> as long as the array ends up containing the list of filenames you really want. Line numbers ($.) continue as though the input were one big happy file. See the example in eof in perlfunc for how to reset line numbers on each file.
If you want to set @ARGV to your own list of files, go right ahead. This sets @ARGV to all plain text files if no @ARGV was given:
@ARGV = grep { -f && -T } glob('*') unless @ARGV;You can even set them to pipe commands. For example, this automatically filters compressed arguments through gzip:
@ARGV = map { /\.(gz|Z)$/ ? "gzip -dc < $_ |" : $_ } @ARGV;If you want to pass switches into your script, you can use one of the Getopts modules or put a loop on the front like this:
while ($_ = $ARGV[0], /^-/) {
shift;
last if /^--$/;
if (/^-D(.*)/) { $debug = $1 }
if (/^-v/) { $verbose++ }
# ... # other switches
}
while (<>) {
# ... # code for each line
}okay so this is the classic "walk my own args then read everything else" pattern and it's iconic ๐
The <> symbol will return undef for end-of-file only once. If you call it again after this, it will assume you are processing another @ARGV list, and if you haven't set @ARGV, will read input from STDIN. (iykyk, that surprise-second-pass is a whole vibe check)
If what the angle brackets contain is a simple scalar variable (for example, $foo), then that variable contains the name of the filehandle to input from, or its typeglob, or a reference to the same. For example:
$fh = \*STDIN;
$line = <$fh>;If what's within the angle brackets is neither a filehandle nor a simple scalar variable containing a filehandle name, typeglob, or typeglob reference, it is interpreted as a filename pattern to be globbed, and either a list of filenames or the next filename in the list is returned, depending on context. This distinction is determined on syntactic grounds alone. That means <$x> is always a readline() from an indirect handle, but <$hash{key}> is always a glob(). That's because $x is a simple scalar variable, but $hash{key} is not โ it's a hash element. Even <$x > (note the extra space) is treated as glob("$x "), not readline($x).
One level of double-quote interpretation is done first, but you can't say <$foo> because that's an indirect filehandle as explained in the previous paragraph. (In older versions of Perl, programmers would insert curly brackets to force interpretation as a filename glob: <${foo}>. These days, it's considered cleaner to call the internal function directly as glob($foo), which is probably the right way to have done it in the first place.) For example:
while (<*.c>) {
chmod 0644, $_;
}is roughly equivalent to:
open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
while (<FOO>) {
chomp;
chmod 0644, $_;
}except that the globbing is actually done internally using the standard File::Glob extension. Of course, the shortest way to do the above is:
chmod 0644, <*.c>;A (file)glob evaluates its (embedded) argument only when it is starting a new list. All values must be read before it will start over. In list context, this isn't important because you automatically get them all anyway. However, in scalar context the operator returns the next value each time it's called, or undef when the list has run out. As with filehandle reads, an automatic defined is generated when the glob occurs in the test part of a while, because legal glob returns (for example, a file called 0) would otherwise terminate the loop. Again, undef is returned only once. So if you're expecting a single value from a glob, it is much better to say
($file) = <blurch*>;than
$file = <blurch*>;because the latter will alternate between returning a filename and returning false. bestie that alternating thing is giving chaos demon, do not do it ๐
If you're trying to do variable interpolation, it's definitely better to use the glob() function, because the older notation can cause people to become confused with the indirect filehandle notation.
@files = glob("$dir/*.[ch]");
@files = glob($files[$i]);If an angle-bracket-based globbing expression is used as the condition of a while or for loop, then it will be implicitly assigned to $_. If either a globbing expression or an explicit assignment of a globbing expression to a scalar is used as a while/for condition, then the condition actually tests for definedness of the expression's value, not for its regular truth value.
โจ Constant Folding โจ
Like C, Perl does a certain amount of expression evaluation at compile time whenever it determines that all arguments to an operator are static and have no side effects. In particular, string concatenation happens at compile time between literals that don't do variable substitution. Backslash interpolation also happens at compile time. You can say
'Now is the time for all'
. "\n"
. 'good men to come to.'and this all reduces to one string internally. Likewise, if you say
foreach $file (@filenames) {
if (-s $file > 5 + 100 * 2**16) { }
}the compiler precomputes the number which that expression represents so that the interpreter won't have to. glow-up via precomputation, we love to see it โจ
๐ No-ops ๐
Perl doesn't officially have a no-op operator, but the bare constants 0 and 1 are special-cased not to produce a warning in void context, so you can for example safely do
1 while foo();she's just out here vibing in a loop, no warnings, no notes ๐
๐ฅ Bitwise String Operators ๐ฅ
Bitstrings of any size may be manipulated by the bitwise operators (~ | & ^).
If the operands to a binary bitwise op are strings of different sizes, | and ^ ops act as though the shorter operand had additional zero bits on the right, while the & op acts as though the longer operand was truncated to the length of the shorter. The granularity for such extension or truncation is one or more bytes.
# ASCII-based examples
print "j p \n" ^ " a h"; # prints "JAPH\n"
print "JA" | " ph\n"; # prints "japh\n"
print "japh\nJunk" & '_____'; # prints "JAPH\n";
print 'p N$' ^ " E<H\n"; # prints "Perl\n";If you are intending to manipulate bitstrings, be certain that you're supplying bitstrings: If an operand is a number, that will imply a numeric bitwise operation. You may explicitly show which type of operation you intend by using "" or 0+, as in the examples below.
$foo = 150 | 105; # yields 255 (0x96 | 0x69 is 0xFF)
$foo = '150' | 105; # yields 255
$foo = 150 | '105'; # yields 255
$foo = '150' | '105'; # yields string '155' (under ASCII)
$baz = 0+$foo & 0+$bar; # both ops explicitly numeric
$biz = "$foo" ^ "$bar"; # both ops explicitly stringyThis somewhat unpredictable behavior can be avoided with the bitwise feature, new in Perl 5.22. You can enable it via use feature 'bitwise' or use v5.28. Before Perl 5.28, it used to emit a warning in the experimental::bitwise category. Under this feature, the four standard bitwise operators (~ | & ^) are always numeric. Adding a dot after each operator (~. |. &. ^.) forces it to treat its operands as strings:
use feature "bitwise";
$foo = 150 | 105; # yields 255 (0x96 | 0x69 is 0xFF)
$foo = '150' | 105; # yields 255
$foo = 150 | '105'; # yields 255
$foo = '150' | '105'; # yields 255
$foo = 150 |. 105; # yields string '155'
$foo = '150' |. 105; # yields string '155'
$foo = 150 |.'105'; # yields string '155'
$foo = '150' |.'105'; # yields string '155'
$baz = $foo & $bar; # both operands numeric
$biz = $foo ^. $bar; # both operands stringyThe assignment variants of these operators (&= |= ^= &.= |.= ^.=) behave likewise under the feature.
โ ๏ธ It is a fatal error if an operand contains a character whose ordinal value is above 0xFF, and hence not expressible except in UTF-8. The operation is performed on a non-UTF-8 copy for other operands encoded in UTF-8. See "Byte and Character Semantics" in perlunicode.
See vec in perlfunc for information on how to manipulate individual bits in a bit vector.
๐ Integer Arithmetic ๐
By default, Perl assumes that it must do most of its arithmetic in floating point. But by saying
use integer;you may tell the compiler to use integer operations (see integer for a detailed explanation) from here to the end of the enclosing BLOCK. An inner BLOCK may countermand this by saying
no integer;which lasts until the end of that BLOCK. Note that this doesn't mean everything is an integer, merely that Perl will use integer operations for arithmetic, comparison, and bitwise operators. For example, even under use integer, if you take the sqrt(2), you'll still get 1.4142135623731 or so.
Used on numbers, the bitwise operators (& | ^ ~ << >>) always produce integral results. (But see also "Bitwise String Operators".) However, use integer still has meaning for them. By default, their results are interpreted as unsigned integers, but if use integer is in effect, their results are interpreted as signed integers. For example, ~0 usually evaluates to a large integral value. However, use integer; ~0 is -1 on two's-complement machines.
๐ธ Floating-point Arithmetic ๐ธ
While use integer provides integer-only arithmetic, there is no analogous mechanism to provide automatic rounding or truncation to a certain number of decimal places. For rounding to a certain number of digits, sprintf() or printf() is usually the easiest route. See perlfaq4.
Floating-point numbers are only approximations to what a mathematician would call real numbers. There are infinitely more reals than floats, so some corners must be cut. For example:
printf "%.20g\n", 123456789123456789;
# produces 123456789123456784Testing for exact floating-point equality or inequality is not a good idea. Here's a (relatively expensive) work-around to compare whether two floating-point numbers are equal to a particular number of decimal places. See Knuth, volume II, for a more robust treatment of this topic.
sub fp_equal {
my ($X, $Y, $POINTS) = @_;
my ($tX, $tY);
$tX = sprintf("%.${POINTS}g", $X);
$tY = sprintf("%.${POINTS}g", $Y);
return $tX eq $tY;
}The POSIX module (part of the standard perl distribution) implements ceil(), floor(), and other mathematical and trigonometric functions. The Math::Complex module (part of the standard perl distribution) defines mathematical functions that work on both the reals and the imaginary numbers. Math::Complex is not as efficient as POSIX, but POSIX can't work with complex numbers.
๐ธ Rounding in financial applications can have serious implications, and the rounding method used should be specified precisely. In these cases, it probably pays not to trust whichever system rounding is being used by Perl, but to instead implement the rounding function you need yourself. bestie do NOT let the default rounding touch your money ๐
๐ Bigger Numbers ๐
The standard Math::BigInt, Math::BigRat, and Math::BigFloat modules, along with the bignum, bigint, and bigrat pragmas, provide variable-precision arithmetic and overloaded operators, although they're currently pretty slow. At the cost of some space and considerable speed, they avoid the normal pitfalls associated with limited-precision representations.
she's slow but she's precise, and honestly? main character energy ๐
use 5.010;
use bigint; # easy interface to Math::BigInt
$x = 123456789123456789;
say $x * $x;
+15241578780673678515622620750190521Orrr if you're a rationals girlie ๐:
use 5.010;
use bigrat;
$x = 3/22;
$y = 4/6;
say "x/y is ", $x/$y;
say "x*y is ", $x*$y;
x/y is 9/44
x*y is 1/11Several modules let you calculate with unlimited or fixed precision โ and like, the only limit is your memory and CPU time bestie, no cap. There are also some non-standard modules that serve you faster implementations through external C libraries. Fancy.
Here's a short, but incomplete summary, because it's literally giving "starter pack":
Math::Stringโ treat string sequences like numbersMath::FixedPrecisionโ calculate with a fixed precisionMath::Currencyโ for currency calculations ๐ธBit::Vectorโ manipulate bit vectors fast (uses C)Math::BigIntFastโ aBit::Vectorwrapper for big numbersMath::Pariโ provides access to the Pari C libraryMath::Cephesโ uses the external Cephes C library (no big numbers)Math::Cephes::Fractionโ fractions via the Cephes libraryMath::GMPโ another one using an external C libraryMath::GMPzโ an alternative interface to libgmp's big intsMath::GMPqโ an interface to libgmp's fraction numbersMath::GMPfโ an interface to libgmp's floating point numbers
Choose wisely. ๐
โจ C-style Logical Or โจ
This section has been superceded by "C-style Logical Or, Xor, and Defined Or". The heading is retained only to prevent breaking any pre-existing links to it from outside. iykyk โ we keep the old anchor around so nobody's bookmarks get ghosted ๐
โจ C-style Logical Xor โจ
This section has been superceded by "C-style Logical Or, Xor, and Defined Or". Again, the heading is retained only to prevent breaking any pre-existing links to it from outside. Same energy, same reason, no notes โจ
โจ Logical Defined-Or โจ
This section has been superceded by "C-style Logical Or, Xor, and Defined Or". And once more for the people in the back: the heading is retained only to prevent breaking any pre-existing links to it from outside. ๐ซถ
โจ Quote-Like Operators โจ
This section has been replaced by "Simpler Quote-Like Operators" โ go read that one bestie, it ate ๐
โจ Indented Here-docs โจ
This section has been merged into "Here-docs" โ it's all living together now, one happy household ๐
๐ฆ APPENDIX ๐ฆ
๐ List of Extra Paired Delimiters ๐
The complete list of accepted paired delimiters as of Unicode 16.0 is:
okay so we are deep in this list rn and it is showing zero signs of slowing down ๐ญ but honestly? the format is the blessing. every entry = two lil glyphs, two U+ codepoints, one ALL-CAPS Unicode name. wrap the long ones onto a second line, and keep it pushing. that's the whole recipe, no notes ๐
where we're at:
( ) U+0028, U+0029 LEFT/RIGHT PARENTHESIS
< > U+003C, U+003E LESS-THAN/GREATER-THAN SIGN
[ ] U+005B, U+005D LEFT/RIGHT SQUARE BRACKET
{ } U+007B, U+007D LEFT/RIGHT CURLY BRACKET
ยซ ยป U+00AB, U+00BB LEFT/RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
ยป ยซ U+00BB, U+00AB RIGHT/LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
เผบ เผป U+0F3A, U+0F3B TIBETAN MARK GUG RTAGS GYON, TIBETAN MARK GUG
RTAGS GYAS
เผผ เผฝ U+0F3C, U+0F3D TIBETAN MARK ANG KHANG GYON, TIBETAN MARK ANG
KHANG GYAS
แ แ U+169B, U+169C OGHAM FEATHER MARK, OGHAM REVERSED FEATHER MARK
โ โ U+2018, U+2019 LEFT/RIGHT SINGLE QUOTATION MARK
โ โ U+2019, U+2018 RIGHT/LEFT SINGLE QUOTATION MARK
โ โ U+201C, U+201D LEFT/RIGHT DOUBLE QUOTATION MARK
โ โ U+201D, U+201C RIGHT/LEFT DOUBLE QUOTATION MARK
โต โฒ U+2035, U+2032 REVERSED PRIME, PRIME
โถ โณ U+2036, U+2033 REVERSED DOUBLE PRIME, DOUBLE PRIME
โท โด U+2037, U+2034 REVERSED TRIPLE PRIME, TRIPLE PRIME
โน โบ U+2039, U+203A SINGLE LEFT/RIGHT-POINTING ANGLE QUOTATION MARK
โบ โน U+203A, U+2039 SINGLE RIGHT/LEFT-POINTING ANGLE QUOTATION MARK
โ
โ U+2045, U+2046 LEFT/RIGHT SQUARE BRACKET WITH QUILL
โ โ U+204D, U+204C BLACK RIGHT/LEFTWARDS BULLET
โฝ โพ U+207D, U+207E SUPERSCRIPT LEFT/RIGHT PARENTHESIS
โ โ U+208D, U+208E SUBSCRIPT LEFT/RIGHT PARENTHESISnot the primes and the quill bracket and the ogham feather marks ๐ธ like ok unicode really said "yes, and also twelve more" and we simply respect it. superscript parens AND subscript parens?? bestie the range ๐ญ๐
and now we enter the arrow era ๐น buckle up:
โ โ U+2192, U+2190 RIGHT/LEFTWARDS ARROW
โ โ U+219B, U+219A RIGHT/LEFTWARDS ARROW WITH STROKE
โ โ U+219D, U+219C RIGHT/LEFTWARDS WAVE ARROW
โ โ U+21A0, U+219E RIGHT/LEFTWARDS TWO HEADED ARROW
โฃ โข U+21A3, U+21A2 RIGHT/LEFTWARDS ARROW WITH TAIL
โฆ โค U+21A6, U+21A4 RIGHT/LEFTWARDS ARROW FROM BAR
โช โฉ U+21AA, U+21A9 RIGHT/LEFTWARDS ARROW WITH HOOK
โฌ โซ U+21AC, U+21AB RIGHT/LEFTWARDS ARROW WITH LOOP
โฑ โฐ U+21B1, U+21B0 UPWARDS ARROW WITH TIP RIGHT/LEFTWARDS
โณ โฒ U+21B3, U+21B2 DOWNWARDS ARROW WITH TIP RIGHT/LEFTWARDS
โ โผ U+21C0, U+21BC RIGHT/LEFTWARDS HARPOON WITH BARB UPWARDS
โ โฝ U+21C1, U+21BD RIGHT/LEFTWARDS HARPOON WITH BARB DOWNWARDS
โ โ U+21C9, U+21C7 RIGHT/LEFTWARDS PAIRED ARROWS
โ โ U+21CF, U+21CD RIGHT/LEFTWARDS DOUBLE ARROW WITH STROKE
โ โ U+21D2, U+21D0 RIGHT/LEFTWARDS DOUBLE ARROW
โ โ U+21DB, U+21DA RIGHT/LEFTWARDS TRIPLE ARROW
โ โ U+21DD, U+21DC RIGHT/LEFTWARDS SQUIGGLE ARROW
โข โ U+21E2, U+21E0 RIGHT/LEFTWARDS DASHED ARROW
โฅ โค U+21E5, U+21E4 RIGHT/LEFTWARDS ARROW TO BAR
โจ โฆ U+21E8, U+21E6 RIGHT/LEFTWARDS WHITE ARROW
โด โฌฐ U+21F4, U+2B30 RIGHT/LEFT ARROW WITH SMALL CIRCLE
โถ โฌฑ U+21F6, U+2B31 THREE RIGHT/LEFTWARDS ARROWSharpoons?? squiggle arrows?? dashed? looped? babes they really did all of this and gave every single one a whole government name. and the list said "keep going" ๐๐ฅ
still here, still locked in:
โธ โท U+21F8, U+21F7 RIGHT/LEFTWARDS ARROW WITH VERTICAL STROKE
โป โบ U+21FB, U+21FA RIGHT/LEFTWARDS ARROW WITH DOUBLE VERTICAL
STROKE
โพ โฝ U+21FE, U+21FD RIGHT/LEFTWARDS OPEN-HEADED ARROW
โ โ U+2208, U+220B ELEMENT OF, CONTAINS AS MEMBER
โ โ U+2209, U+220C NOT AN ELEMENT OF, DOES NOT CONTAIN AS MEMBER
โ โ U+220A, U+220D SMALL ELEMENT OF, SMALL CONTAINS AS MEMBER
โค โฅ U+2264, U+2265 LESS-THAN/GREATER-THAN OR EQUAL TO
โฆ โง U+2266, U+2267 LESS-THAN/GREATER-THAN OVER EQUAL TO
โจ โฉ U+2268, U+2269 LESS-THAN/GREATER-THAN BUT NOT EQUAL TO
โซ โช U+226A, U+226B MUCH LESS-THAN/GREATER-THAN
โฎ โฏ U+226E, U+226F NOT LESS-THAN/GREATER-THAN
โฐ โฑ U+2270, U+2271 NEITHER LESS-THAN/GREATER-THAN NOR EQUAL TO
โฒ โณ U+2272, U+2273 LESS-THAN/GREATER-THAN OR EQUIVALENT TO
โด โต U+2274, U+2275 NEITHER LESS-THAN/GREATER-THAN NOR EQUIVALENT TO
โบ โป U+227A, U+227B PRECEDES/SUCCEEDS
โผ โฝ U+227C, U+227D PRECEDES/SUCCEEDS OR EQUAL TO
โพ โฟ U+227E, U+227F PRECEDES/SUCCEEDS OR EQUIVALENT TO
โ โ U+2280, U+2281 DOES NOT PRECEDE/SUCCEED
โ โ U+2282, U+2283 SUBSET/SUPERSET OF
โ โ
U+2284, U+2285 NOT A SUBSET/SUPERSET OF
โ โ U+2286, U+2287 SUBSET/SUPERSET OF OR EQUAL TO
โ โ U+2288, U+2289 NEITHER A SUBSET/SUPERSET OF NOR EQUAL TO
โ โ U+228A, U+228B SUBSET/SUPERSET OF WITH NOT EQUAL TO
โฃ โข U+22A3, U+22A2 LEFT/RIGHT TACK
โฆ โซ U+22A6, U+2ADE ASSERTION, SHORT LEFT TACK
โจ โซค U+22A8, U+2AE4 TRUE, VERTICAL BAR DOUBLE LEFT TURNSTILE
โฉ โซฃ U+22A9, U+2AE3 FORCES, DOUBLE VERTICAL BAR LEFT TURNSTILE
โฐ โฑ U+22B0, U+22B1 PRECEDES/SUCCEEDS UNDER RELATION
โ โ U+22D0, U+22D1 DOUBLE SUBSET/SUPERSET
โ โ U+22D6, U+22D7 LESS-THAN/GREATER-THAN WITH DOT
โ โ U+22D8, U+22D9 VERY MUCH LESS-THAN/GREATER-THAN
โ โ U+22DC, U+22DD EQUAL TO OR LESS-THAN/GREATER-THAN
โ โ U+22DE, U+22DF EQUAL TO OR PRECEDES/SUCCEEDS
โ โก U+22E0, U+22E1 DOES NOT PRECEDE/SUCCEED OR EQUAL
โฆ โง U+22E6, U+22E7 LESS-THAN/GREATER-THAN BUT NOT EQUIVALENT TO
โจ โฉ U+22E8, U+22E9 PRECEDES/SUCCEEDS BUT NOT EQUIVALENT TO
โฒ โบ U+22F2, U+22FA ELEMENT OF/CONTAINS WITH LONG HORIZONTAL STROKE
โณ โป U+22F3, U+22FB ELEMENT OF/CONTAINS WITH VERTICAL BAR AT END OF
HORIZONTAL STROKE
โด โผ U+22F4, U+22FC SMALL ELEMENT OF/CONTAINS WITH VERTICAL BAR AT
END OF HORIZONTAL STROKE
โถ โฝ U+22F6, U+22FD ELEMENT OF/CONTAINS WITH OVERBAR
โท โพ U+22F7, U+22FE SMALL ELEMENT OF/CONTAINS WITH OVERBARtacks, turnstiles, assertion, forcesโฆ bestie this is giving math class but make it couture ๐ and yes DOUBLE VERTICAL BAR LEFT TURNSTILE is a real string of words that a real person typed on purpose. iconic. no further questions. ๐
final stretch (for now):
โ โ U+2308, U+2309 LEFT/RIGHT CEILING
โ โ U+230A, U+230B LEFT/RIGHT FLOOR
โฆ โซ U+2326, U+232B ERASE TO THE RIGHT/LEFT
ใ ใ U+2329, U+232A LEFT/RIGHT-POINTING ANGLE BRACKET
โ โ U+2348, U+2347 APL FUNCTIONAL SYMBOL QUAD RIGHT/LEFTWARDS ARROW
โฉ โช U+23E9, U+23EA BLACK RIGHT/LEFT-POINTING DOUBLE TRIANGLE
โญ โฎ U+23ED, U+23EE BLACK RIGHT/LEFT-POINTING DOUBLE TRIANGLE WITH
VERTICAL BAR
โ โ U+261B, U+261A BLACK RIGHT/LEFT POINTING INDEX
โ โ U+261E, U+261C WHITE RIGHT/LEFT POINTING INDEX
โ โ U+269E, U+269F THREE LINES CONVERGING RIGHT/LEFT
โจ โฉ U+2768, U+2769 MEDIUM LEFT/RIGHT PARENTHESIS ORNAMENT
โช โซ U+276A, U+276B MEDIUM FLATTENED LEFT/RIGHT PARENTHESIS ORNAMENT
โฌ โญ U+276C, U+276D MEDIUM LEFT/RIGHT-POINTING ANGLE BRACKET
ORNAMENT
โฎ โฏ U+276E, U+276F HEAVY LEFT/RIGHT-POINTING ANGLE QUOTATION MARK
ORNAMENT
โฐ โฑ U+2770, U+2771 HEAVY LEFT/RIGHT-POINTING ANGLE BRACKET ORNAMENT
โฒ โณ U+2772, U+2773 LIGHT LEFT/RIGHT TORTOISE SHELL BRACKET ORNAMENT
โด โต U+2774, U+2775 MEDIUM LEFT/RIGHT CURLY BRACKET ORNAMENT
โ โ U+27C3, U+27C4 OPEN SUBSET/SUPERSET
โ
โ U+27C5, U+27C6 LEFT/RIGHT S-SHAPED BAG DELIMITER
โ โ U+27C8, U+27C9 REVERSE SOLIDUS PRECEDING SUBSET, SUPERSET
PRECEDING SOLIDUS
โ โ U+27DE, U+27DD LONG LEFT/RIGHT TACK
โฆ โง U+27E6, U+27E7 MATHEMATICAL LEFT/RIGHT WHITE SQUARE BRACKET
โจ โฉ U+27E8, U+27E9 MATHEMATICAL LEFT/RIGHT ANGLE BRACKET
โช โซ U+27EA, U+27EB MATHEMATICAL LEFT/RIGHT DOUBLE ANGLE BRACKET
โฌ โญ U+27EC, U+27ED MATHEMATICAL LEFT/RIGHT WHITE TORTOISE SHELL
BRACKET
โฎ โฏ U+27EE, U+27EF MATHEMATICAL LEFT/RIGHT FLATTENED PARENTHESIS
โด โฌฒ U+27F4, U+2B32 RIGHT/LEFT ARROW WITH CIRCLED PLUS
โถ โต U+27F6, U+27F5 LONG RIGHT/LEFTWARDS ARROW
โน โธ U+27F9, U+27F8 LONG RIGHT/LEFTWARDS DOUBLE ARROW
โผ โป U+27FC, U+27FB LONG RIGHT/LEFTWARDS ARROW FROM BAR
โพ โฝ U+27FE, U+27FD LONG RIGHT/LEFTWARDS DOUBLE ARROW FROM BAR
โฟ โฌณ U+27FF, U+2B33 LONG RIGHT/LEFTWARDS SQUIGGLE ARROW
โค โฌด U+2900, U+2B34 RIGHT/LEFTWARDS TWO-HEADED ARROW WITH VERTICAL
STROKE
โค โฌต U+2901, U+2B35 RIGHT/LEFTWARDS TWO-HEADED ARROW WITH DOUBLE
VERTICAL STROKE
โค โค U+2903, U+2902 RIGHT/LEFTWARDS DOUBLE ARROW WITH VERTICAL
STROKE
โค
โฌถ U+2905, U+2B36 RIGHT/LEFTWARDS TWO-HEADED ARROW FROM BAR
โค โค U+2907, U+2906 RIGHT/LEFTWARDS DOUBLE ARROW FROM BAR
โค โค U+290D, U+290C RIGHT/LEFTWARDS DOUBLE DASH ARROW
โค โค U+290F, U+290E RIGHT/LEFTWARDS TRIPLE DASH ARROW
โค โฌท U+2910, U+2B37 RIGHT/LEFTWARDS TWO-HEADED TRIPLE DASH ARROW
โค โฌธ U+2911, U+2B38 RIGHT/LEFTWARDS ARROW WITH DOTTED STEM
โค โฌน U+2914, U+2B39 RIGHT/LEFTWARDS ARROW WITH TAIL WITH VERTICAL
STROKE
โค โฌบ U+2915, U+2B3A RIGHT/LEFTWARDS ARROW WITH TAIL WITH DOUBLE
VERTICAL STROKE
โค โฌป U+2916, U+2B3B RIGHT/LEFTWARDS TWO-HEADED ARROW WITH TAIL
โค โฌผ U+2917, U+2B3C RIGHT/LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH
VERTICAL STROKE
โค โฌฝ U+2918, U+2B3D RIGHT/LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH
DOUBLE VERTICAL STROKE
โค โค U+291A, U+2919 RIGHT/LEFTWARDS ARROW-TAIL
โค โค U+291C, U+291B RIGHT/LEFTWARDS DOUBLE ARROW-TAIL
โค โค U+291E, U+291D RIGHT/LEFTWARDS ARROW TO BLACK DIAMOND
โค โค U+2920, U+291F RIGHT/LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND
โคณ โฌฟ U+2933, U+2B3F WAVE ARROW POINTING DIRECTLY RIGHT/LEFT
โคท โคถ U+2937, U+2936 ARROW POINTING DOWNWARDS THEN CURVING RIGHT/
LEFTWARDS
โฅ
โฅ U+2945, U+2946 RIGHT/LEFTWARDS ARROW WITH PLUS BELOW
โฅ โฌพ U+2947, U+2B3E RIGHT/LEFTWARDS ARROW THROUGH X
โฅ โฅ U+2953, U+2952 RIGHT/LEFTWARDS HARPOON WITH BARB UP TO BAR
โฅ โฅ U+2957, U+2956 RIGHT/LEFTWARDS HARPOON WITH BARB DOWN TO BAR
โฅ โฅ U+295B, U+295A RIGHT/LEFTWARDS HARPOON WITH BARB UP FROM BAR
โฅ โฅ U+295F, U+295E RIGHT/LEFTWARDS HARPOON WITH BARB DOWN FROM BAR
โฅค โฅข U+2964, U+2962 RIGHT/LEFTWARDS HARPOON WITH BARB UP ABOVE
RIGHT/LEFTWARDS HARPOON WITH BARB DOWN
โฅฌ โฅช U+296C, U+296A RIGHT/LEFTWARDS HARPOON WITH BARB UP ABOVE LONG
DASH
โฅญ โฅซ U+296D, U+296B RIGHT/LEFTWARDS HARPOON WITH BARB DOWN BELOW
LONG DASH
โฅฑ โญ U+2971, U+2B40 EQUALS SIGN ABOVE RIGHT/LEFTWARDS ARROW
โฅฒ โญ U+2972, U+2B41 TILDE OPERATOR ABOVE RIGHTWARDS ARROW, REVERSE
TILDE OPERATOR ABOVE LEFTWARDS ARROWceiling and floor?? erase to the right/left?? tortoise shell bracket ornament</c>?? ๐ขโจ and then a whole second wave of long arrows with tails and dots and dashes and diamonds. the list simply does not miss. more incoming below ๐
okay so we're STILL in the pair list bestie and we are not skipping a single one ๐ซถ every glyph, every code point, exactly as written, no cap. continuing โจ
- โฅด โญ โ
U+2974,U+2B4Bโ RIGHTWARDS ARROW ABOVE TILDE OPERATOR, LEFTWARDS ARROW ABOVE REVERSE TILDE OPERATOR - โฅต โญ โ
U+2975,U+2B42โ RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO, LEFTWARDS ARROW ABOVE REVERSE ALMOST EQUAL TO - โฅน โฅป โ
U+2979,U+297Bโ SUBSET/SUPERSET ABOVE RIGHT/LEFTWARDS ARROW
the way these arrows are out here living their mirrored little lives ๐ฅ moving on
- โฆ โฆ โ
U+2983,U+2984โ LEFT/RIGHT WHITE CURLY BRACKET - โฆ
โฆ โ
U+2985,U+2986โ LEFT/RIGHT WHITE PARENTHESIS - โฆ โฆ โ
U+2987,U+2988โ Z NOTATION LEFT/RIGHT IMAGE BRACKET - โฆ โฆ โ
U+2989,U+298Aโ Z NOTATION LEFT/RIGHT BINDING BRACKET - โฆ โฆ โ
U+298B,U+298Cโ LEFT/RIGHT SQUARE BRACKET WITH UNDERBAR - โฆ โฆ โ
U+298D,U+2990โ LEFT/RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER - โฆ โฆ โ
U+298F,U+298Eโ LEFT/RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - โฆ โฆ โ
U+2991,U+2992โ LEFT/RIGHT ANGLE BRACKET WITH DOT - โฆ โฆ โ
U+2993,U+2994โ LEFT/RIGHT ARC LESS-THAN/GREATER-THAN BRACKET - โฆ โฆ โ
U+2995,U+2996โ DOUBLE LEFT/RIGHT ARC GREATER-THAN/LESS-THAN BRACKET - โฆ โฆ โ
U+2997,U+2998โ LEFT/RIGHT BLACK TORTOISE SHELL BRACKET
tortoise shell bracket?? a whole aesthetic ๐ข๐
- โฆจ โฆฉ โ
U+29A8,U+29A9โ MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT/LEFT - โฆช โฆซ โ
U+29AA,U+29ABโ MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT/LEFT - โฆณ โฆด โ
U+29B3,U+29B4โ EMPTY SET WITH RIGHT/LEFT ARROW ABOVE - โง โง โ
U+29C0,U+29C1โ CIRCLED LESS-THAN/GREATER-THAN - โง โง โ
U+29D8,U+29D9โ LEFT/RIGHT WIGGLY FENCE - โง โง โ
U+29DA,U+29DBโ LEFT/RIGHT DOUBLE WIGGLY FENCE - โงผ โงฝ โ
U+29FC,U+29FDโ LEFT/RIGHT-POINTING CURVED ANGLE BRACKET
wiggly fence has me in a chokehold ๐ญ iconic behaviour fr
- โฉน โฉบ โ
U+2A79,U+2A7Aโ LESS-THAN/GREATER-THAN WITH CIRCLE INSIDE - โฉป โฉผ โ
U+2A7B,U+2A7Cโ LESS-THAN/GREATER-THAN WITH QUESTION MARK ABOVE - โฉฝ โฉพ โ
U+2A7D,U+2A7Eโ LESS-THAN/GREATER-THAN OR SLANTED EQUAL TO - โฉฟ โช โ
U+2A7F,U+2A80โ LESS-THAN/GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE - โช โช โ
U+2A81,U+2A82โ LESS-THAN/GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE - โช โช โ
U+2A83,U+2A84โ LESS-THAN/GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT/LEFT - โช
โช โ
U+2A85,U+2A86โ LESS-THAN/GREATER-THAN OR APPROXIMATE - โช โช โ
U+2A87,U+2A88โ LESS-THAN/GREATER-THAN AND SINGLE-LINE NOT EQUAL TO - โช โช โ
U+2A89,U+2A8Aโ LESS-THAN/GREATER-THAN AND NOT APPROXIMATE - โช โช โ
U+2A8D,U+2A8Eโ LESS-THAN/GREATER-THAN ABOVE SIMILAR OR EQUAL - โช โช โ
U+2A95,U+2A96โ SLANTED EQUAL TO OR LESS-THAN/GREATER-THAN - โช โช โ
U+2A97,U+2A98โ SLANTED EQUAL TO OR LESS-THAN/GREATER-THAN WITH DOT INSIDE - โช โช โ
U+2A99,U+2A9Aโ DOUBLE-LINE EQUAL TO OR LESS-THAN/GREATER-THAN - โช โช โ
U+2A9B,U+2A9Cโ DOUBLE-LINE SLANTED EQUAL TO OR LESS-THAN/GREATER-THAN - โช โช โ
U+2A9D,U+2A9Eโ SIMILAR OR LESS-THAN/GREATER-THAN - โช โช โ
U+2A9F,U+2AA0โ SIMILAR ABOVE LESS-THAN/GREATER-THAN ABOVE EQUALS SIGN - โชก โชข โ
U+2AA1,U+2AA2โ DOUBLE NESTED LESS-THAN/GREATER-THAN - โชฆ โชง โ
U+2AA6,U+2AA7โ LESS-THAN/GREATER-THAN CLOSED BY CURVE - โชจ โชฉ โ
U+2AA8,U+2AA9โ LESS-THAN/GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL - โชช โชซ โ
U+2AAA,U+2AABโ SMALLER THAN/LARGER THAN - โชฌ โชญ โ
U+2AAC,U+2AADโ SMALLER THAN/LARGER THAN OR EQUAL TO - โชฏ โชฐ โ
U+2AAF,U+2AB0โ PRECEDES/SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN - โชฑ โชฒ โ
U+2AB1,U+2AB2โ PRECEDES/SUCCEEDS ABOVE SINGLE-LINE NOT EQUAL TO - โชณ โชด โ
U+2AB3,U+2AB4โ PRECEDES/SUCCEEDS ABOVE EQUALS SIGN - โชต โชถ โ
U+2AB5,U+2AB6โ PRECEDES/SUCCEEDS ABOVE NOT EQUAL TO - โชท โชธ โ
U+2AB7,U+2AB8โ PRECEDES/SUCCEEDS ABOVE ALMOST EQUAL TO - โชน โชบ โ
U+2AB9,U+2ABAโ PRECEDES/SUCCEEDS ABOVE NOT ALMOST EQUAL TO - โชป โชผ โ
U+2ABB,U+2ABCโ DOUBLE PRECEDES/SUCCEEDS
okay the math-nerd section ate and left no crumbs ๐งฎโจ keep going bestie we're barely halfway through this chunk
- โชฝ โชพ โ
U+2ABD,U+2ABEโ SUBSET/SUPERSET WITH DOT - โชฟ โซ โ
U+2ABF,U+2AC0โ SUBSET/SUPERSET WITH PLUS SIGN BELOW - โซ โซ โ
U+2AC1,U+2AC2โ SUBSET/SUPERSET WITH MULTIPLICATION SIGN BELOW - โซ โซ โ
U+2AC3,U+2AC4โ SUBSET/SUPERSET OF OR EQUAL TO WITH DOT ABOVE - โซ
โซ โ
U+2AC5,U+2AC6โ SUBSET/SUPERSET OF ABOVE EQUALS SIGN - โซ โซ โ
U+2AC7,U+2AC8โ SUBSET/SUPERSET OF ABOVE TILDE OPERATOR - โซ โซ โ
U+2AC9,U+2ACAโ SUBSET/SUPERSET OF ABOVE ALMOST EQUAL TO - โซ โซ โ
U+2ACB,U+2ACCโ SUBSET/SUPERSET OF ABOVE NOT EQUAL TO - โซ โซ โ
U+2ACF,U+2AD0โ CLOSED SUBSET/SUPERSET - โซ โซ โ
U+2AD1,U+2AD2โ CLOSED SUBSET/SUPERSET OR EQUAL TO - โซ โซ โ
U+2AD5,U+2AD6โ SUBSET/SUPERSET ABOVE SUBSET/SUPERSET - โซฅ โซ โ
U+2AE5,U+22ABโ DOUBLE VERTICAL BAR DOUBLE LEFT/RIGHT TURNSTILE - โซท โซธ โ
U+2AF7,U+2AF8โ TRIPLE NESTED LESS-THAN/GREATER-THAN - โซน โซบ โ
U+2AF9,U+2AFAโ DOUBLE-LINE SLANTED LESS-THAN/GREATER-THAN OR EQUAL TO
not the triple nested ones?? that's three layers of commitment ๐ obsessed
- โญ โญ
โ
U+2B46,U+2B45โ RIGHT/LEFTWARDS QUADRUPLE ARROW - โญ โญ โ
U+2B47,U+2B49โ REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW, TILDE OPERATOR ABOVE LEFTWARDS ARROW - โญ โญ โ
U+2B48,U+2B4Aโ RIGHTWARDS ARROW ABOVE REVERSE ALMOST EQUAL TO, LEFTWARDS ARROW ABOVE ALMOST EQUAL TO - โญ โฅณ โ
U+2B4C,U+2973โ RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR, LEFTWARDS ARROW ABOVE TILDE OPERATOR - โญข โญ โ
U+2B62,U+2B60โ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW - โญฌ โญช โ
U+2B6C,U+2B6Aโ RIGHT/LEFTWARDS TRIANGLE-HEADED DASHED ARROW - โญฒ โญฐ โ
U+2B72,U+2B70โ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW TO BAR - โญผ โญบ โ
U+2B7C,U+2B7Aโ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW WITH DOUBLE VERTICAL STROKE - โฎ โฎ โ
U+2B86,U+2B84โ RIGHT/LEFTWARDS TRIANGLE-HEADED PAIRED ARROWS - โฎ โฎ โ
U+2B8A,U+2B88โ RIGHT/LEFTWARDS BLACK CIRCLED WHITE ARROW - โฎ โฌ
โ
U+2B95,U+2B05โ RIGHT/LEFTWARDS BLACK ARROW - โฎ โฎ โ
U+2B9A,U+2B98โ THREE-D TOP-LIGHTED RIGHT/LEFTWARDS EQUILATERAL ARROWHEAD - โฎ โฎ โ
U+2B9E,U+2B9Cโ BLACK RIGHT/LEFTWARDS EQUILATERAL ARROWHEAD - โฎก โฎ โ
U+2BA1,U+2BA0โ DOWNWARDS TRIANGLE-HEADED ARROW WITH LONG TIP RIGHT/LEFTWARDS - โฎฃ โฎข โ
U+2BA3,U+2BA2โ UPWARDS TRIANGLE-HEADED ARROW WITH LONG TIP RIGHT/LEFTWARDS - โฎฉ โฎจ โ
U+2BA9,U+2BA8โ BLACK CURVED DOWNWARDS AND RIGHT/LEFTWARDS ARROW - โฎซ โฎช โ
U+2BAB,U+2BAAโ BLACK CURVED UPWARDS AND RIGHT/LEFTWARDS ARROW - โฎฑ โฎฐ โ
U+2BB1,U+2BB0โ RIBBON ARROW DOWN RIGHT/LEFT - โฎณ โฎฒ โ
U+2BB3,U+2BB2โ RIBBON ARROW UP RIGHT/LEFT - โฏฎ โฏฌ โ
U+2BEE,U+2BECโ RIGHT/LEFTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS
the arrows section is giving main character energy ๐น๐ pointing in every direction, living every lifestyle, we love that for them
- โธ โธ โ
U+2E02,U+2E03โ LEFT/RIGHT SUBSTITUTION BRACKET - โธ โธ โ
U+2E03,U+2E02โ RIGHT/LEFT SUBSTITUTION BRACKET - โธ โธ
โ
U+2E04,U+2E05โ LEFT/RIGHT DOTTED SUBSTITUTION BRACKET - โธ
โธ โ
U+2E05,U+2E04โ RIGHT/LEFT DOTTED SUBSTITUTION BRACKET - โธ โธ โ
U+2E09,U+2E0Aโ LEFT/RIGHT TRANSPOSITION BRACKET - โธ โธ โ
U+2E0A,U+2E09โ RIGHT/LEFT TRANSPOSITION BRACKET - โธ โธ โ
U+2E0C,U+2E0Dโ LEFT/RIGHT RAISED OMISSION BRACKET - โธ โธ โ
U+2E0D,U+2E0Cโ RIGHT/LEFT RAISED OMISSION BRACKET - โธ โธ โ
U+2E11,U+2E10โ REVERSED FORKED PARAGRAPHOS, FORKED PARAGRAPHOS - โธ โธ โ
U+2E1C,U+2E1Dโ LEFT/RIGHT LOW PARAPHRASE BRACKET - โธ โธ โ
U+2E1D,U+2E1Cโ RIGHT/LEFT LOW PARAPHRASE BRACKET - โธ โธก โ
U+2E20,U+2E21โ LEFT/RIGHT VERTICAL BAR WITH QUILL - โธก โธ โ
U+2E21,U+2E20โ RIGHT/LEFT VERTICAL BAR WITH QUILL - โธข โธฃ โ
U+2E22,U+2E23โ TOP LEFT/RIGHT HALF BRACKET - โธค โธฅ โ
U+2E24,U+2E25โ BOTTOM LEFT/RIGHT HALF BRACKET - โธฆ โธง โ
U+2E26,U+2E27โ LEFT/RIGHT SIDEWAYS U BRACKET - โธจ โธฉ โ
U+2E28,U+2E29โ LEFT/RIGHT DOUBLE PARENTHESIS - โธถ โธท โ
U+2E36,U+2E37โ DAGGER WITH LEFT/RIGHT GUARD
the way the substitution brackets show up twice, once forwards and once backwards, because of course they do ๐โจ periodt
- โน โ โ
U+2E42,U+201Eโ DOUBLE LOW-REVERSED-9 QUOTATION MARK, DOUBLE LOW-9 QUOTATION MARK - โน โน โ
U+2E55,U+2E56โ LEFT/RIGHT SQUARE BRACKET WITH STROKE - โน โน โ
U+2E57,U+2E58โ LEFT/RIGHT SQUARE BRACKET WITH DOUBLE STROKE - โน โน โ
U+2E59,U+2E5Aโ TOP HALF LEFT/RIGHT PARENTHESIS - โน โน โ
U+2E5B,U+2E5Cโ BOTTOM HALF LEFT/RIGHT PARENTHESIS - ใ ใ โ
U+3008,U+3009โ LEFT/RIGHT ANGLE BRACKET - ใ ใ โ
U+300A,U+300Bโ LEFT/RIGHT DOUBLE ANGLE BRACKET - ใ ใ โ
U+300C,U+300Dโ LEFT/RIGHT CORNER BRACKET - ใ ใ โ
U+300E,U+300Fโ LEFT/RIGHT WHITE CORNER BRACKET - ใ ใ โ
U+3010,U+3011โ LEFT/RIGHT BLACK LENTICULAR BRACKET - ใ ใ โ
U+3014,U+3015โ LEFT/RIGHT TORTOISE SHELL BRACKET - ใ ใ โ
U+3016,U+3017โ LEFT/RIGHT WHITE LENTICULAR BRACKET - ใ ใ โ
U+3018,U+3019โ LEFT/RIGHT WHITE TORTOISE SHELL BRACKET - ใ ใ โ
U+301A,U+301Bโ LEFT/RIGHT WHITE SQUARE BRACKET - ใ ใ โ
U+301D,U+301Eโ REVERSED DOUBLE PRIME QUOTATION MARK, DOUBLE PRIME QUOTATION MARK - ๊ง ๊ง โ
U+A9C1,U+A9C2โ JAVANESE LEFT/RIGHT RERENGGAN - ๏ดพ ๏ดฟ โ
U+FD3E,U+FD3Fโ ORNATE LEFT/RIGHT PARENTHESIS
the JAVANESE RERENGGAN ๊ง๊ง bestie that is a whole decoration, that is jewellery ๐ฅ๐
- ๏น ๏น โ
U+FE59,U+FE5Aโ SMALL LEFT/RIGHT PARENTHESIS - ๏น ๏น โ
U+FE5B,U+FE5Cโ SMALL LEFT/RIGHT CURLY BRACKET - ๏น ๏น โ
U+FE5D,U+FE5Eโ SMALL LEFT/RIGHT TORTOISE SHELL BRACKET - ๏นค ๏นฅ โ
U+FE64,U+FE65โ SMALL LESS-THAN/GREATER-THAN SIGN - ๏ผ ๏ผ โ
U+FF08,U+FF09โ FULLWIDTH LEFT/RIGHT PARENTHESIS - ๏ผ ๏ผ โ
U+FF1C,U+FF1Eโ FULLWIDTH LESS-THAN/GREATER-THAN SIGN - ๏ผป ๏ผฝ โ
U+FF3B,U+FF3Dโ FULLWIDTH LEFT/RIGHT SQUARE BRACKET - ๏ฝ ๏ฝ โ
U+FF5B,U+FF5Dโ FULLWIDTH LEFT/RIGHT CURLY BRACKET - ๏ฝ ๏ฝ โ
U+FF5F,U+FF60โ FULLWIDTH LEFT/RIGHT WHITE PARENTHESIS - ๏ฝข ๏ฝฃ โ
U+FF62,U+FF63โ HALFWIDTH LEFT/RIGHT CORNER BRACKET - ๏ฟซ ๏ฟฉ โ
U+FFEB,U+FFE9โ HALFWIDTH RIGHT/LEFTWARDS ARROW
small versions AND fullwidth versions, the range is ranging ๐ โจ
- ๐ ๐ โ
U+1D103,U+1D102โ MUSICAL SYMBOL REVERSE FINAL BARLINE, MUSICAL SYMBOL FINAL BARLINE - ๐ ๐ โ
U+1D106,U+1D107โ MUSICAL SYMBOL LEFT/RIGHT REPEAT SIGN - ๐ ๐ โ
U+1F449,U+1F448โ WHITE RIGHT/LEFT POINTING BACKHAND INDEX - ๐ ๐จ โ
U+1F508,U+1F568โ SPEAKER, RIGHT SPEAKER - ๐ ๐ฉ โ
U+1F509,U+1F569โ SPEAKER WITH ONE SOUND WAVE, RIGHT SPEAKER WITH ONE SOUND WAVE - ๐ ๐ช โ
U+1F50A,U+1F56Aโ SPEAKER WITH THREE SOUND WAVES, RIGHT SPEAKER WITH THREE SOUND WAVES - ๐ป ๐ฝ โ
U+1F57B,U+1F57Dโ LEFT/RIGHT HAND TELEPHONE RECEIVER - ๐ ๐ โ
U+1F599,U+1F598โ SIDEWAYS WHITE RIGHT/LEFT POINTING INDEX - ๐ ๐ โ
U+1F59B,U+1F59Aโ SIDEWAYS BLACK RIGHT/LEFT POINTING INDEX - ๐ ๐ โ
U+1F59D,U+1F59Cโ BLACK RIGHT/LEFT POINTING BACKHAND INDEX
๐๐ not the backhand index pair being the most relatable one in the entire list ๐ญ๐ the speaker emoji coming in one-wave, three-wave AND a plain one, with their right-speaker besties right next to them, obsessed fr fr ๐ง๐ซถ
anyway we're literally still going, more pairs incoming ๐
and now, bestie, we're at the very tail of this whole thing โ the last stretch of the APPENDIX, and it is nothing but arrows. like, four hundred more arrows, all hanging out up in the Unicode Supplementary zone. we started with the polite little ASCII ones and now we're in U+1F8xx claiming territory. main character energy, honestly ๐
these are the heavyweights โ the triangle-heads, the barbs, the shaded whites, the tilted shadows. take your time, no rush, we go line by line because every single codepoint matters ๐
๐ฆ๐งโU+1F5E6,U+1F5E7โ THREE RAYS LEFT/RIGHT๐ ๐ โU+1F802,U+1F800โ RIGHT/LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD๐ ๐ โU+1F806,U+1F804โ RIGHT/LEFTWARDS ARROW WITH MEDIUM TRIANGLE ARROWHEAD๐ ๐ โU+1F80A,U+1F808โ RIGHT/LEFTWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD๐ ๐ โU+1F812,U+1F810โ RIGHT/LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD๐ ๐ โU+1F816,U+1F814โ RIGHT/LEFTWARDS ARROW WITH EQUILATERAL ARROWHEAD๐ ๐ โU+1F81A,U+1F818โ HEAVY RIGHT/LEFTWARDS ARROW WITH EQUILATERAL ARROWHEAD๐ ๐ โU+1F81E,U+1F81Cโ HEAVY RIGHT/LEFTWARDS ARROW WITH LARGE EQUILATERAL ARROWHEAD
okay see the glow-up? small triangle, medium triangle, large triangle, then boom โ equilateral, and then we go HEAVY, then HEAVY and LARGE. that's a character arc fr fr ๐ and every one of them has a matching rightwards and leftwards twin, so the set stays symmetrical. we love a duo.
๐ ข๐โU+1F822,U+1F820โ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW WITH NARROW SHAFT๐ ฆ๐ คโU+1F826,U+1F824โ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW WITH MEDIUM SHAFT๐ ช๐ จโU+1F82A,U+1F828โ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW WITH BOLD SHAFT๐ ฎ๐ ฌโU+1F82E,U+1F82Cโ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW WITH HEAVY SHAFT๐ ฒ๐ ฐโU+1F832,U+1F830โ RIGHT/LEFTWARDS TRIANGLE-HEADED ARROW WITH VERY HEAVY SHAFT๐ ถ๐ ดโU+1F836,U+1F834โ RIGHT/LEFTWARDS FINGER-POST ARROW
this little run is the shaft family โ narrow, medium, bold, heavy, very heavy, in that exact order, no skipping, no notes. and then out of nowhere: a FINGER-POST ARROW ๐ชง like a lil signpost. okay trail marker, we see you, we appreciate you.
๐ บ๐ ธโU+1F83A,U+1F838โ RIGHT/LEFTWARDS SQUARED ARROW๐ พ๐ ผโU+1F83E,U+1F83Cโ RIGHT/LEFTWARDS COMPRESSED ARROW๐ก๐กโU+1F842,U+1F840โ RIGHT/LEFTWARDS HEAVY COMPRESSED ARROW๐ก๐กโU+1F846,U+1F844โ RIGHT/LEFTWARDS HEAVY ARROW๐ก๐กโU+1F852,U+1F850โ RIGHT/LEFTWARDS SANS-SERIF ARROW
squared, compressed, heavy compressed, heavy, sans-serif โ the lowercase-to-uppercase of arrows, honestly. the compressed ones are lowkey the underrated faves, they're just doing so much with so little ๐ซถ
๐กข๐กโU+1F862,U+1F860โ WIDE-HEADED RIGHT/LEFTWARDS LIGHT BARB ARROW๐กช๐กจโU+1F86A,U+1F868โ WIDE-HEADED RIGHT/LEFTWARDS BARB ARROW๐กฒ๐กฐโU+1F872,U+1F870โ WIDE-HEADED RIGHT/LEFTWARDS MEDIUM BARB ARROW๐กบ๐กธโU+1F87A,U+1F878โ WIDE-HEADED RIGHT/LEFTWARDS HEAVY BARB ARROW๐ข๐ขโU+1F882,U+1F880โ WIDE-HEADED RIGHT/LEFTWARDS VERY HEAVY BARB ARROW
WIDE-HEADED BARB ARROWS ๐ light, then plain (no weight word, so iconic of it), then medium, heavy, very heavy. these are the ones with the swoopy wings, y'know? very "I'm a fancy arrow in a fantasy map" coded. obsessed.
๐ข๐ขโU+1F892,U+1F890โ RIGHT/LEFTWARDS TRIANGLE ARROWHEAD๐ข๐ขโU+1F896,U+1F894โ RIGHT/LEFTWARDS WHITE ARROW WITHIN TRIANGLE ARROWHEAD๐ข๐ขโU+1F89A,U+1F898โ RIGHT/LEFTWARDS ARROW WITH NOTCHED TAIL
notched tail?? notched?? okay miss thing, giving arrow-with-a-little-bite-out-of-it. we stan.
๐ขก๐ขโU+1F8A1,U+1F8A0โ RIGHTWARDS BOTTOM SHADED WHITE ARROW, LEFTWARDS BOTTOM-SHADED WHITE ARROW๐ขฃ๐ขขโU+1F8A3,U+1F8A2โ RIGHT/LEFTWARDS TOP SHADED WHITE ARROW๐ขฅ๐ขฆโU+1F8A5,U+1F8A6โ RIGHT/LEFTWARDS RIGHT-SHADED WHITE ARROW๐ขง๐ขคโU+1F8A7,U+1F8A4โ RIGHT/LEFTWARDS LEFT-SHADED WHITE ARROW๐ขฉ๐ขจโU+1F8A9,U+1F8A8โ RIGHT/LEFTWARDS BACK-TILTED SHADOWED WHITE ARROW๐ขซ๐ขชโU+1F8AB,U+1F8AAโ RIGHT/LEFTWARDS FRONT-TILTED SHADOWED WHITE ARROW๐ขถ๐ขดโU+1F8B6,U+1F8B4โ NEGATIVE SQUARED RIGHT/LEFTWARDS ARROW
the SHADED WHITE ARROW section โ bottom, top, right, left, back-tilted, front-tilted, and then the negative squared one riding in last like โจ the finale โจ. note that first pair is listed as two separate names with a comma between them (RIGHTWARDS BOTTOM SHADED WHITE ARROW and LEFTWARDS BOTTOM-SHADED WHITE ARROW) โ keep it exactly like that if you ever quote it, no tidying up, that's how the page says it.
and that's it. that's the whole appendix, that's the whole page, we did it ๐ genuinely a marathon and you read every single arrow like a champ. not everyone has the stamina for a full PERLOP(1perl), but you? you ATE. no crumbs ๐โจ
for the record, bestie: the source and version on this page areperl v5.44.0, and the date on it is2026-10-17โ that's where this wholePERLOP(1perl)adventure came from. go touch some grass (or, more on brand, go read another manpage) ๐ธ๐ฆ
๐ฆ where this page comes from
- arch rolling: perl 5.44.0-1 ยท Artistic-1.0-Perl AND GPL-1.0-or-later
- ๐ girlified by deepseek-ai/DeepSeek-V4.1-Flash on : a language model's rewrite of the original, under its terms