Shell one-liner: Difference between revisions

=={{header|ACL2}}==

=={{header|Ada}}==

'''under a unixoid shell''' (bash, sh, ...)

Note that this mercilessly overwrites and later deletes any files x.adb, x.ali, x,o and x in the current directory.

=={{header|Aikido}}==

=={{header|Aime}}==

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - Interpret straight off}}

Output:

<pre>Hello</pre>

{{works with|ELLA ALGOL 68|Any - tested with release 1.8.8d.fc9.i386 - translate to [[C]] and then compile and run}}

For an [[ELLA ALGOL 68]] one-liner, merge these lines of shell code:

a=/tmp/algol$$ s=/usr/share/algol68toc;

echo -e "PROGRAM algol$$ CONTEXT VOID\nUSE standard\nBEGIN\n$code\nEND\nFINISH\n" > $a.a68 &&

a68toc -lib $s -dir $s -uname TMP -tmp $a.a68 && rm $a.a68 &&

gcc $s/Afirst.o $a.c -l{a68s,a68,m,c} -o $a && rm $a.c &&

Output:

<pre>Hello</pre>

=={{header|AppleScript}}==

=={{header|Arturo}}==

You may run any arbitrary code string directly using the <code>-e</code> (or <code>--evaluate</code>) flag:

{{out}}

=={{header|AWK}}==

Maybe the most common way one can use awk is from the command line for one-liners, feeding the interpreter with an input.

A more "complex" and "real" example:

''Select'' field 2 and 4 of lines matching the regular expression <tt>/IN/</tt> (i.e. where IN appears)

=={{header|BASIC}}==

The name of the BASIC executable will vary (common ones are ''basic'', ''bas'', and ''bwbasic''), but in general, a short program can be piped to the interpreter like any other language:

Note that under Windows (and presumably DOS) the two apostrophes (a.k.a. single quotes) should be omitted, since Windows doesn't remove them from the piped text (and the apostrophe is the comment character in many modern BASICs):

Also, some popular interpreters (including [http://www.moria.de/~michael/bas/ Michael Haardt's '''bas'''] and [[Chipmunk Basic]]) will include an extra prompt before exiting unless you include <code>exit</code> or <code>system</code> (depending on the specific interpreter's syntax). This sample output shows both with and without <code>system</code> in bas:

On the ZX Spectrum, the ROM basic allows direct commands to be entered from the system prompt:

==={{header|BaCon}}===

then compile a.bac using bacon then run ./a

echo "PRINT \"Hello World\" " > a.bac && bacon a && ./a

Converting 'a.bac'... done, 2 lines were processed in 0.003 seconds.

=={{header|Bc}}==

{{out}}

<pre>Hello 123</pre>

DOS:

Linux:

Output:

<pre> 1

=={{header|Burlesque}}==

Burlesque.exe --no-stdin "5 5 .+"

Using the official interpreter.

delete it to avoid to call another shell/system dependent command/program). The

''current directory'' is not specified by <tt>./</tt> in every system...

=={{header|C sharp|C#}}==

Requires PowerShell 2:

> [HelloWorld]::SayHi()

=={{header|Clojure}}==

clj-env-dir comes with clojure-contrib.

#'user/add2

=={{header|CMake}}==

This only works with [[Unix]] systems that have the device node <code>/dev/stdin</code>.

=={{header|COBOL}}==

Works with GnuCOBOL 2.0 or later

Longer, but avoids two relaxed syntax warnings:

=={{header|Common Lisp}}==

{{works with|SBCL}}

{{works with|CLISP}}

=={{header|D}}==

{{works with|D|2}}

requires [https://github.com/D-Programming-Language/tools/blob/master/rdmd.d rdmd]

<pre>Hello World!</pre>

=={{header|Dc}}==

=={{header|Delphi}}==

Run in cmd.exe.

The output has the default Delphi header, before the output of executable ("Hi").

=={{header|E}}==

The <code>--src</code> option ends with the the filename extension the provided type of program would have:

=={{header|Elixir}}==

=={{header|Emacs Lisp}}==

Or another example that does something useful: indent a [[C]] source file:

=={{header|Erlang}}==

Erlang always starts other applications that can run in parallel in the background, and as such will not die by itself. To kill erl, we sequentially run the 'halt' function from the 'erlang' module (the -S is there to guarantee 'halt' will be evaluated after the io function).

=={{header|F_Sharp|F#}}==

=={{header|Factor}}==

=={{header|Forth}}==

{{works with|GNU Forth}}

=={{header|Fortran}}==

This example, stolen from the [[Shell_one-liner#c|c]] example is subject to the same caveats. While contrived, FORTRAN as a one liner can easily handle some unique tasks. Let's plot a Bessel function:

$ gawk 'BEGIN{print"write(6,\"(2(g12.3,x))\")(i/10.0,besj1(i/10.0), i=0,1000)\nend";exit(0)}'|gfortran -ffree-form -x f95 - | gnuplot -p -e 'plot "<./a.out" t "Bessel function of 1st kind" w l'

Sorry, I don't know how to upload my jpeg file for the Image tag. Let's use the dumb display instead.

<pre>

=={{header|Free Pascal}}==

The FPC (Free Pascal compiler) comes with the utility <tt>instantfpc(1)</tt> or <tt>ifpc(1)</tt> for short (Debian or FreeBSD package <tt>fpc-utils</tt>):

=={{header|FreeBASIC}}==

Shell "echo For i As Integer = 1 To 10 : Print i : Next > zzz.bas && fbc zzz.bas && zzz"

{{out}}

The <CODE>-e</CODE> command-line option executes a command or commands and prints its value.

{{out}}

=={{header|FutureBasic}}==

This is forcing the issue. FB has much more elegant ways of interacting with the Unix Shell.

window 1,,(0,0,160,120):Str255 a:open "Unix",1,"cal 10 2018":do:line input #1,a:print a:until eof(1):close 1:HandleEvents

Output

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=4385adf6a841435779a7afff3dadb58b Click this link to run this code]'''

Shell "echo Hello World"

Output:

<pre>

=={{header|Gema}}==

=={{header|Go}}==

{{out}}

<pre>

=={{header|Groovy}}==

{{works with|UNIX Shell}}

{{works with|Windows Command Interpreter}}

=={{header|Haskell}}==

=={{header|Huginn}}==

Result of an expression is printed by default:

Output:

<pre>"Hello"</pre>

Even with an explicit `print` function was used:

Output:

<pre>Hello

none</pre>

Unless the last expression ended with a semicolon:

Output:

<pre>Hello</pre>

These examples work with posix shells.

=={{header|J}}==

That said, note that J interpreters can themselves be thought of as [[wp:Command_shell|command shells]].

These three lines work with Bourne Shell (or compatible) or C Shell (or compatible), or bash on Unix/Linux/MacOSX/Windows+cygwin

> 'System.out.println("Hello Java!");}}' >X.java

A user can also enter this as one (very long) line:

{{works with|MS-DOS}} Compatible Environments (such as [[wp:cmd.exe|cmd.exe]])

Works with cmd.exe on Windows (tested on Microsoft Windows XP [Version 5.1.2600])

=={{header|JavaScript}}==

{{works with|SpiderMonkey}}

=={{header|jq}}==

=={{header|Julia}}==

foo

=={{header|K}}==

{{works with|Kona}}

=={{header|Kotlin}}==

From stdin:

Or alternatively:

=={{header|Liberty BASIC}}==

echo print "hello">oneLiner.bas & liberty -r oneLiner.bas echo print "hello">oneLiner.bas & liberty -r oneLiner.bas

=={{header|Lua}}==

=={{header|Maple}}==

=={{header|Mathematica}}/{{header|Wolfram Language}}==

=={{header|min}}==

=={{header|Nanoquery}}==

=={{header|NetLogo}}==

=== Observer Mode ===

=== Turtle Mode ===

=={{header|NetRexx}}==

{{works with|UNIX Shell}}

Create a temporary file, execute the file via the NetRexx interpreter then delete the temporary file and any files generated via the translation. (i.e. Java class files etc.)

$ TNRX=`mktemp T_XXXXXXXXXXXX` && test ! -e $TNRX.* && (echo 'say "Goodbye, World!"' >$TNRX; nrc -exec $TNRX; rm $TNRX $TNRX.*; unset TNRX)

'''Output:'''

=={{header|NewLISP}}==

=={{header|Nim}}==

=={{header|Objeck}}==

{{works with|UNIX Shell}}

=={{header|OCaml}}==

{{works with|OCaml|4.00+}}

=={{header|Octave}}==

=={{header|Oforth}}==

{{out}}

=={{header|ooRexx}}==

rexx -e "say 'Goodbye, world.'"

=={{header|Oz}}==

This is difficult to do in Oz because the compiler/interpreter always wants the source code in a file and does not read from stdin. We can do somethings like this on Unix-like systems:

With <code>-l System</code> we make the System module available so that we can print something.

=={{header|PARI/GP}}==

=={{header|Pascal}}==

=={{header|Perl}}==

More information about the many ways of invoking perl can be found in [http://perldoc.perl.org/perlrun.html perlrun].

=={{header|PHP}}==

assuming you have the PHP CLI (command-line interface) installed, not just the web server plugin

=={{header|PicoLisp}}==

=={{header|Pike}}==

=={{header|PowerShell}}==

=={{header|Processing}}==

In bash:

{{out}}

=={{header|Prolog}}==

===Command-Line Options===

hello world

goodbye

=== <<< ===

swi

$ yap -q <<< "current_prolog_flag(dialect,D), writeln(D), halt."

=== Pipe ===

swi

$ echo "current_prolog_flag(dialect,D), writeln(D), halt." | yap -q

=={{header|PureBasic}}==

Runs on Linux with(thanks to) bash. Path variables must be set as decribed in INSTALL.

=={{header|Python}}==

===Prints "Hello"===

===Web server with CGI===

The python CGIHTTPServer module is also an [[Executable library|executable library]] that performs as a web server with CGI. to start enter:

It returns with:

<pre>Serving HTTP on 0.0.0.0 port 8000 ...</pre>

=={{header|Quackery}}==

===Via Python 3===

As Quackery is implemented as a Python 3 function, assuming that quackery.py is in the module search path:

=={{header|R}}==

Alternatively, using the Rscript front-end,

=={{header|Racket}}==

=={{header|Raku}}==

{{works with|Rakudo|#22 "Thousand Oaks"}}

=={{header|REBOL}}==

Output:

=={{header|Retro}}==

=={{header|REXX}}==

Note: &nbsp; Regina REXX is the only version of REXX that supports this type of behavior &nbsp; (taking it's input from a console stream).

╔══════════════════════════════════════════════╗

║ ║

'''output''' &nbsp; when entering the (above) from the (DOS) command line:

<pre>

=={{header|Ring}}==

see "Hello World!" + nl

Output:

<pre>

=={{header|Ruby}}==

From [[Unix]]:

{{works with|JRuby}}

{{works with|Rubinius}}

=={{header|Run BASIC}}==

=={{header|Rust}}==

delete it to avoid to call another shell/system dependent command/program). The

''current directory'' is not specified by <tt>./</tt> in every system...

=={{header|S-lang}}==

Or, in MSW cmd.exe:

Note that print() is included w/slsh, but is not part of S-Lang itself.

=={{header|Scala}}==

{{libheader|Scala}}

PS C:\> scala -e 'println(\"Hello\")'

The escaping of quotes is required by Windows.

=={{header|Scheme}}==

{{works with|Guile}}

=={{header|Shiny}}==

=={{header|Sidef}}==

=={{header|Slate}}==

=={{header|SNOBOL4}}==

Portable version

Bash version

=={{header|Tcl}}==

This is an area where Tcl is lacking, though when shell one-liners are required a construct like this is typically used:

=={{header|TXR}}==

a="123"

b="456"

c="7890"

Most useful txr queries consist of multiple lines, and the line structure is important. Multi-liners can be passed via <code>-c</code> easily, but there is no provision in the syntax that would allow multi-liners to be actually written as one physical line. There are opposite provisions for splitting long logical lines into multiple physical lines.

TXR Lisp:

$ ls -ld foo

=={{header|UNIX Shell}}==

Explicit call of the shell, passing the shell command via the <code>-c</code> option:

To invoke a specific shell like [[Bash]], [[Korn Shell]] or [[Z Shell]]:

$ ksh -c 'let i=3+4; print $i'

Shell scripts almost never use <code>sh -c</code>, because there are various implicit ways whereby the shell command language evaluates a command in a subshell:

$ VAR=$(echo hello) # modern POSIX notation

There are more details about <code>`echo hello`</code> and <code>$(echo hello)</code> at [[Execute a system command#UNIX Shell]].

Run a C shell command from any shell:

==={{header|es}}===

Run a command, in extensible shell, from any shell:

=={{header|Ursala}}==

The command to execute the Ursala compiler is fun. An expression supplied as a parameter to the --main option is compiled and evaluated. If the expression evaluates to a list of character strings, it can be displayed on standard output with --show. If it's some other type, it can be formatted for display by --cast <type expression>,

hello

$ fun --main="power/2 32" --cast %n

4294967296

$ fun --m="..mp2str mpfr..pi 120" --c %s

=={{header|Vedit macro language}}==

The following DOS command starts Vedit and displays a message.

When the user presses any key, Vedit exits.

=={{header|Wart}}==

=={{header|Wren}}==

{{out}}

=={{header|zkl}}==

With a unix like shell, just pipe the program into the REPL. Kinda greasy and noisy. To shut it up, send stdout to /dev/null

{{out}}

<pre>