'How can I start an interactive console for Perl?

How can I start an interactive console for Perl, similar to the irb command for Ruby or python for Python?

Solution 1:^[1]

Not only did Matt Trout write an article about a REPL, he actually wrote one - Devel::REPL

I've used it a bit and it works fairly well, and it's under active development.

BTW, I have no idea why someone modded down the person who mentioned using "perl -e" from the console. This isn't really a REPL, true, but it's fantastically useful, and I use it all the time.

Solution 2:^[2]

I wrote a script I call "psh":

#! /usr/bin/perl

while (<>) {
  chomp;
  my $result = eval;
  print "$_ = $result\n";
}

Whatever you type in, it evaluates in Perl:

> gmtime(2**30)
gmtime(2**30) = Sat Jan 10 13:37:04 2004

> $x = 'foo'
$x = 'foo' = foo

> $x =~ s/o/a/g
$x =~ s/o/a/g = 2

> $x
$x = faa

Solution 3:^[3]

If you want history, use rlwrap. This could be your ~/bin/ips for example:

#!/bin/sh
echo 'This is Interactive Perl shell'
rlwrap -A -pgreen -S"perl> " perl -wnE'say eval()//$@'

And this is how it looks like:

$ ips
This is Interactive Perl shell
perl> 2**128
3.40282366920938e+38
perl>

Solution 4:^[4]

I think you're asking about a REPL (Read, Evaluate, Print, Loop) interface to perl. There are a few ways to do this:

Matt Trout has an article that describes how to write one
Adriano Ferreira has described some options
and finally, you can hop on IRC at irc.perl.org and try out one of the eval bots in many of the popular channels. They will evaluate chunks of perl that you pass to them.

Solution 5:^[5]

I use the command line as a console:

$ perl -e 'print "JAPH\n"'

Then I can use my bash history to get back old commands. This does not preserve state, however.

This form is most useful when you want to test "one little thing" (like when answering Perl questions). Often, I find these commands get scraped verbatim into a shell script or makefile.

Solution 6:^[6]

There isn't an interactive console for Perl built in like Python does. You can however use the Perl Debugger to do debugging related things. You turn it on with the -d option, but you might want to check out 'man perldebug' to learn about it.

After a bit of googling, there is a separate project that implements a Perl console which you can find at Perl Console - Perl code interactive evaluator with completion.

Hope this helps!

Solution 7:^[7]

There are two popular Perl REPLs.

Devel::REPL is great.
But IMO Reply is better.

Solution 8:^[8]

You can always just drop into the built-in debugger and run commands from there.

   perl -d -e 1

Solution 9:^[9]

I've created perli, a Perl REPL that runs on Linux, macOS, and Windows.

Its focus is automatic result printing, convenient documentation lookups, and easy inspection of regular-expression matches.
You can see screenshots here.

It works stand-alone (has no dependencies other than Perl itself), but installation of rlwrap is strongly recommended so as to support command-line editing, persistent command history, and tab-completion - read more here.

Installation

If you happen to have Node.js installed:
```
npm install -g perli
```
Otherwise:
- Unix-like platforms: Download this script as perli to a folder in your system's path and make it executable with chmod +x.
- Windows: Download the this script as perli.pl (note the .pl extension) to a folder in your system's path.
  If you don't mind invoking Perli as perli.pl, you're all set.
  Otherwise, create a batch file named perli.cmd in the same folder with the following content: @%~dpn.pl %*; this enables invocation as just perli.

Solution 10:^[10]

perl -d is your friend:

% perl -de 0

Solution 11:^[11]

re.pl from Devel::REPL

Solution 12:^[12]

I always did:

rlwrap perl -wlne'eval;print$@if$@'

With 5.10, I've switched to:

rlwrap perl -wnE'say eval()//$@'

(rlwrap is optional)

Solution 13:^[13]

You could look into psh here: http://gnp.github.io/psh/

It's a full on shell (you can use it in replacement of bash for example), but uses perl syntax.. so you can create methods on the fly etc.

Solution 14:^[14]

Read-eval-print loop:

$ perl -e'while(<>){print eval,"\n"}'

Solution 15:^[15]

Perl doesn't have a console but the debugger can be used as one. At a command prompt, type perl -de 1. (The value "1" doesn't matter, it's just a valid statement that does nothing.)

There are also a couple of options for a Perl shell:
Archived "perlfaq3" page which contain question "Is there Perl Shell?"

For more information read perlfaq3 (current version).

Solution 16:^[16]

^{Update: I've since created a downloadable REPL - see my other answer.}

With the benefit of hindsight:

The third-party solutions mentioned among the existing answers are either cumbersome to install and/or do not work without non-trivial, non-obvious additional steps - some solutions appear to be at least half-abandoned.
A usable REPL needs the readline library for command-line-editing keyboard support and history support - ensuring this is a trouble spot for many third-party solutions.
If you install CLI rlwrap, which provides readline support to any command, you can combine it with a simple Perl command to create a usable REPL, and thus make do without third-party REPL solutions.
- On OSX, you can install rlwrap via Homebrew with brew install rlwrap.
- Linux distros should offer rlwrap via their respective package managers; e.g., on Ubuntu, use sudo apt-get install rlwrap.
- See Ján Sáreník's answer for said combination of rlwrap and a Perl command.

What you do NOT get with Ján's answer:

auto-completion
ability to enter multi-line statements

The only third-party solution that offers these (with non-trivial installation + additional, non-obvious steps), is psh, but:

it hasn't seen activity in around 2.5 years
its focus is different in that it aims to be a full-fledged shell replacement, and thus works like a traditional shell, which means that it doesn't automatically evaluate a command as a Perl statement, and requires an explicit output command such as print to print the result of an expression.

Ján Sáreník's answer can be improved in one way:

By default, it prints arrays/lists/hashtables as scalars, i.e., only prints their element count, whereas it would be handy to enumerate their elements instead.

If you install the Data::Printer module with [sudo] cpan Data::Printer as a one-time operation, you can load it into the REPL for use of the p() function, to which you can pass lists/arrays/hashtables for enumeration.

Here's an alias named iperl with readline and Data::Printer support, which can you put in your POSIX-like shell's initialization file (e.g., ~/.bashrc):

alias iperl='rlwrap -A -S "iperl> " perl -MData::Printer -wnE '\''BEGIN { say "# Use `p @<arrayOrList>` or `p %<hashTable>` to print arrays/lists/hashtables; e.g.: `p %ENV`"; } say eval()//$@'\'

E.g., you can then do the following to print all environment variables via hashtable %ENV:

$ iperl        # start the REPL
iperl> p %ENV  # print key-value pairs in hashtable %ENV

As with Ján's answer, the scalar result of an expression is automatically printed; e.g.:

iperl> 22 / 7  # automatically print scalar result of expression: 3.14285714285714

Solution 17:^[17]

Under Debian/Ubuntu:

$ sudo apt-get install libdevel-repl-perl
$ re.pl

$ sudo apt-get install libapp-repl-perl
$ iperl

Solution 18:^[18]

Matt Trout's overview lists five choices, from perl -de 0 onwards, and he recommends Reply, if extensibility via plugins is important, or tinyrepl from Eval::WithLexicals, for a minimal, pure-perl solution that includes readline support and lexical persistence.

Solution 19:^[19]

Also look for ptkdb on CPAN: http://search.cpan.org/search?query=ptkdb&mode=all

Solution 20:^[20]

Sepia and PDE have also own REPLs (for GNU Emacs).

Solution 21:^[21]

Solution 22:^[22]

You can do it online (like many things in life) here:

https://www.tutorialspoint.com/execute_perl_online.php

Solution 23:^[23]

You can use org-babel in emacs; Open an org-mode file, i.e., tmp.org, and then you can do:

#+begin_src perl :results output
@a = (1,5,9);
print ((join ", ", @a) . "\n");
$b = scalar @a;
print "$#a, $b\n";
print "$#a, " . @a . "\n";
print join ", ", 1..$#a; print "\n";
print join ", ", @a[0..$#a]
#+end_src

Pressing CTRL-c CTRL-c evals the block:

#+RESULTS:
#+begin_example
1, 5, 9
2, 3
2, 3
1, 2
1, 5, 9
#+end_example

I am not sure what emacs config this needs to work, but I think you can just install https://github.com/hlissner/doom-emacs and enable its perl and org-mode modules.

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution	Source
Solution 1	Dave Rolsky
Solution 2	raldi
Solution 3	HÃ¥kon HÃ¦gland
Solution 4	Erman Kadir Kahraman
Solution 5
Solution 6	Erman Kadir Kahraman
Solution 7	phuclv
Solution 8	Clinton Pierce
Solution 9
Solution 10	Brian Phillips
Solution 11
Solution 12
Solution 13	mklement0
Solution 14	KIM Taegyoon
Solution 15	Ryan M
Solution 16	Community
Solution 17	gavenkoa
Solution 18	Davor Cubranic
Solution 19	runrig
Solution 20
Solution 21	Erman Kadir Kahraman
Solution 22	Ross Attrill
Solution 23	HappyFace

'How can I start an interactive console for Perl?

Solution 1:[1]

Solution 2:[2]

Solution 3:[3]

Solution 4:[4]

Solution 5:[5]

Solution 6:[6]

Solution 7:[7]

Solution 8:[8]

Solution 9:[9]

Solution 10:[10]

Solution 11:[11]

Solution 12:[12]

Solution 13:[13]

Solution 14:[14]

Solution 15:[15]

Solution 16:[16]

Solution 17:[17]

Solution 18:[18]

Solution 19:[19]

Solution 20:[20]

Solution 21:[21]

Solution 22:[22]

Solution 23:[23]