May the source be with you, but remember the KISS principle ;-)
Home Switchboard Unix Administration Red Hat TCP/IP Networks Neoliberalism Toxic Managers
(slightly skeptical) Educational society promoting "Back to basics" movement against IT overcomplexity and  bastardization of classic Unix

Switch statements

A BLOCK by Perl (labeled or not) is semantically equivalent to a loop that executes once. Thus you can use any of the loop control statements in it to leave or restart the block. (Note that this is NOT true in eval{}, sub{}, or contrary to popular belief do{} blocks, which do NOT count as loops.) The continue block is optional.

The BLOCK construct can be used to emulate case structures.

   if (/^abc/) { $abc = 1; last SWITCH; }
   if (/^def/) { $def = 1; last SWITCH; }
   if (/^xyz/) { $xyz = 1; last SWITCH; }
   $nothing = 1;

Alternatively you'll also emulate switch using the  foreach loop with scalar variable instead of array:

for ($var) {
  if (/^abc/) { $abc = 1; last SWITCH; }
  if (/^def/) { $def = 1; last SWITCH; }
  if (/^xyz/) { $xyz = 1; last SWITCH; }
  $nothing = 1;

Such constructs were sometimes  used because older versions of Perl had no official switch statement

Starting from Perl 5.10.1, Perl has special switch feature. You can get it is you use use v5.10.1 or later.  For example use v5.16.3; (default in RHEL7) 

NOTE  "switch" feature implements intellectual comparison (~~) in when. This "intellectual comparison" is considered highly experimental; it is subject to change with little notice. Due to this  when has tricky behaviors that are expected to change to become less tricky in the future. Do not rely upon its current (mis)implementation.

Before Perl 5.18, given also had tricky behaviour that you should still beware of if your code must run on older versions of Perl. It is better to avoid it.

Perl also allow to use the keyword  for word for the switch as when is now recognized within for body. Which is pretty elegant solution:
    use v5.10.1;
    for ($var) {
        when (/^abc/) { $abc = 1 }
        when (/^def/) { $def = 1 }
        when (/^xyz/) { $xyz = 1 }
        default       { $nothing = 1 }

The for loop with scalar assigns the $_ variable that can be reused in when.  You can also use keyword given, but it looks redundant and unnatural in this context. For is preferable.

As of 5.14, that can also be written this way:

use v5.14;
for ($var) {
   $abc = 1 when /^abc/;
   $def = 1 when /^def/;
   $xyz = 1 when /^xyz/;
default { $nothing = 1 }

This construct is can make code more clear. For example:

    use feature ":5.10";
    given($foo) {
        when (undef) {
            say '$foo is undefined';
        when ("foo") {
            say '$foo is the string "foo"';
        when ([1,3,5,7,9]) {
            say '$foo is an odd digit';
            continue; # Fall through
        when ($_ < 100) {
            say '$foo is numerically less than 100';
        when (\&complicated_check) {
            say 'complicated_check($foo) is true';
        default {
            die q(I don't know what to do with $foo);

given(EXPR)  will assign the value of EXPR to $_  within the lexical scope of the block, so it's similar to

        do { my $_ = EXPR; ... }

except that the block is automatically broken out of by a successful when  or an explicit break.

Most of the power comes from implicit smart matching:


is exactly equivalent to

        when($_ ~~ $foo)

In fact when(EXPR)  is treated as an implicit smart match most of the time. The exceptions are that when EXPR is:

a subroutine or method call
a regular expression match, i.e. /REGEX/  or $foo =~ /REGEX/, or a negated regular expression match $foo !~ /REGEX/.
a comparison such as $_ < 10  or $x eq "abc"  (or of course $_ ~~ $c)
defined(...), exists(...), or eof(...)
A negated expression !(...)  or not (...), or a logical exclusive-or (...) xor (...).

then the value of EXPR is used directly as a boolean. Furthermore:

If EXPR is ... && ...  or ... and ..., the test is applied recursively to both arguments. If both arguments pass the test, then the argument is treated as boolean.
If EXPR is ... || ...  or ... or ..., the test is applied recursively to the first argument.

These rules look complicated, but usually they will do what you want. For example you could write:

    when (/^\d+$/ && $_ < 75) { ... }

Another useful shortcut is that, if you use a literal array or hash as the argument to when, it is turned into a reference. So given(@foo)  is the same as given(\@foo), for example.

default  behaves exactly like when(1 == 1), which is to say that it always matches.

See "Smart matching in detail" for more information on smart matching.

Breaking out

You can use the break  keyword to break out of the enclosing given  block. Every when  block is implicitly ended with a break.


You can use the continue  keyword to fall through from one case to the next:

    given($foo) {
        when (/x/) { say '$foo contains an x'; continue }
        when (/y/) { say '$foo contains a y' }
        default    { say '$foo contains neither an x nor a y' }

Switching in a loop

Instead of using given(), you can use a foreach()  loop. For example, here's one way to count how many times a particular string occurs in an array:

    my $count = 0;
    for (@array) {
        when ("foo") { ++$count }
    print "\@array contains $count copies of 'foo'\n";

On exit from the when  block, there is an implicit next. You can override that with an explicit last  if you're only interested in the first match.

This doesn't work if you explicitly specify a loop variable, as in for $item (@array). You have to use the default variable $_. (You can use for my $_ (@array).)

Smart matching in detail

The behaviour of a smart match depends on what type of thing its arguments are. It is always commutative, i.e. $a ~~ $b  behaves the same as $b ~~ $a. The behaviour is determined by the following table: the first row that applies, in either order, determines the match behaviour.

    $a      $b        Type of Match Implied    Matching Code
    ======  =====     =====================    =============
    (overloading trumps everything)

    Code[+] Code[+]   referential equality     $a == $b
    Any     Code[+]   scalar sub truth         $b->($a)

    Hash    Hash      hash keys identical      [sort keys %$a]~~[sort keys %$b]
    Hash    Array     hash slice existence     grep {exists $a->{$_}} @$b
    Hash    Regex     hash key grep            grep /$b/, keys %$a
    Hash    Any       hash entry existence     exists $a->{$b}

    Array   Array     arrays are identical[*]
    Array   Regex     array grep               grep /$b/, @$a
    Array   Num       array contains number    grep $_ == $b, @$a
    Array   Any       array contains string    grep $_ eq $b, @$a

    Any     undef     undefined                !defined $a
    Any     Regex     pattern match            $a =~ /$b/
    Code()  Code()    results are equal        $a->() eq $b->()
    Any     Code()    simple closure truth     $b->() # ignoring $a
    Num     numish[!] numeric equality         $a == $b
    Any     Str       string equality          $a eq $b
    Any     Num       numeric equality         $a == $b

    Any     Any       string equality          $a eq $b

 + - this must be a code reference whose prototype (if present) is not ""
     (subs with a "" prototype are dealt with by the 'Code()' entry lower down)
 * - that is, each element matches the element of same index in the other
     array. If a circular reference is found, we fall back to referential
 ! - either a real number, or a string that looks like a number

The "matching code" doesn't represent the real matching code, of course: it's just there to explain the intended meaning. Unlike grep, the smart match operator will short-circuit whenever it can.

Top Visited
Past week
Past month


Old News ;-)

Recommended Links

Google matched content

Softpanorama Recommended

Top articles


perlsyn -



Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy


War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotesSomerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose BierceBernard Shaw : Mark Twain Quotes


Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law


Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOSProgramming Languages History : PL/1 : Simula 67 : C : History of GCC developmentScripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-MonthHow to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Haterís Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D

Copyright © 1996-2021 by Softpanorama Society. was initially created as a service to the (now defunct) UN Sustainable Development Networking Programme (SDNP) without any remuneration. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.

FAIR USE NOTICE This site contains copyrighted material the use of which has not always been specifically authorized by the copyright owner. We are making such material available to advance understanding of computer science, IT technology, economic, scientific, and social issues. We believe this constitutes a 'fair use' of any such copyrighted material as provided by section 107 of the US Copyright Law according to which such material can be distributed without profit exclusively for research and educational purposes.

This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

You can use PayPal to to buy a cup of coffee for authors of this site


The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the Softpanorama society. We do not warrant the correctness of the information provided or its fitness for any purpose. The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.

Last modified: September 07, 2020