Shell one-liner: Difference between revisions
(→{{header|Lasso}}: Added Lasso Example) |
imported>Tromp |
||
(94 intermediate revisions by 53 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Programming environment operations}} |
{{task|Programming environment operations}} |
||
;Task: |
|||
Show how to specify and execute a short program in the language from a command shell, where the input to the command shell is only one line in length. |
Show how to specify and execute a short program in the language from a command shell, where the input to the command shell is only one line in length. |
||
Avoid depending on the particular shell or operating system used as much as is reasonable; if the language has notable implementations which have different command argument syntax, or the systems those implementations run on have different styles of shells, it would be good to show multiple examples. |
Avoid depending on the particular shell or operating system used as much as is reasonable; if the language has notable implementations which have different command argument syntax, or the systems those implementations run on have different styles of shells, it would be good to show multiple examples. |
||
<br><br> |
|||
=={{header|11l}}== |
|||
{{trans|Nim}} |
|||
The following works on Windows. |
|||
<pre>...>echo L(i) 0..10 {print("Hello World"[0..i])} > oneliner.11l && 11l oneliner.11l && oneliner.exe |
|||
H |
|||
He |
|||
Hel |
|||
Hell |
|||
Hello |
|||
Hello |
|||
Hello W |
|||
Hello Wo |
|||
Hello Wor |
|||
Hello Worl |
|||
Hello World |
|||
</pre> |
|||
=={{header|ACL2}}== |
=={{header|ACL2}}== |
||
< |
<syntaxhighlight lang="bash">$ acl2 <<< '(cw "Hello.")'</syntaxhighlight> |
||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
Line 11: | Line 31: | ||
'''under a unixoid shell''' (bash, sh, ...) |
'''under a unixoid shell''' (bash, sh, ...) |
||
< |
<syntaxhighlight lang="bash">echo 'with Ada.text_IO; use Ada.text_IO; procedure X is begin Put("Hello!"); end X;' > x.adb; gnatmake x; ./x; rm x.adb x.ali x.o x</syntaxhighlight> |
||
Note that this mercilessly overwrites and later deletes any files x.adb, x.ali, x,o and x in the current directory. |
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|Aikido}}== |
||
< |
<syntaxhighlight lang="aikido">echo 'println ("Hello")' | aikido</syntaxhighlight> |
||
=={{header|Aime}}== |
=={{header|Aime}}== |
||
< |
<syntaxhighlight lang="sh">$ src/aime -c 'o_text("Hello, World!\n");'</syntaxhighlight> |
||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - Interpret straight off}} |
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - Interpret straight off}} |
||
< |
<syntaxhighlight lang="bash">$ a68g -e 'print(("Hello",new line))'</syntaxhighlight> |
||
Output: |
Output: |
||
<pre>Hello</pre> |
<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}} |
{{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: |
For an [[ELLA ALGOL 68]] one-liner, merge these lines of shell code: |
||
< |
<syntaxhighlight lang="bash">code='print(("Hello", new line))' |
||
a=/tmp/algol$$ s=/usr/share/algol68toc; |
a=/tmp/algol$$ s=/usr/share/algol68toc; |
||
echo -e "PROGRAM algol$$ CONTEXT VOID\nUSE standard\nBEGIN\n$code\nEND\nFINISH\n" > $a.a68 && |
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 && |
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 && |
gcc $s/Afirst.o $a.c -l{a68s,a68,m,c} -o $a && rm $a.c && |
||
$a; rm $a</ |
$a; rm $a</syntaxhighlight> |
||
Output: |
Output: |
||
<pre>Hello</pre> |
<pre>Hello</pre> |
||
=={{header|AppleScript}}== |
|||
<syntaxhighlight lang="applescript">osascript -e 'say "Hello, World!"'</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
You may run any arbitrary code string directly using the <code>-e</code> (or <code>--evaluate</code>) flag: |
|||
<syntaxhighlight lang="bash">$ arturo -e:"print {Hello World!}"</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Hello World!</pre> |
|||
=={{header|AWK}}== |
=={{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. |
Maybe the most common way one can use awk is from the command line for one-liners, feeding the interpreter with an input. |
||
< |
<syntaxhighlight lang="bash">$ awk 'BEGIN { print "Hello"; }'</syntaxhighlight> |
||
A more "complex" and "real" example: |
A more "complex" and "real" example: |
||
< |
<syntaxhighlight lang="bash">$ awk '/IN/ { print $2, $4; }' <input.txt</syntaxhighlight> |
||
''Select'' field 2 and 4 of lines matching the regular expression <tt>/IN/</tt> (i.e. where IN appears) |
''Select'' field 2 and 4 of lines matching the regular expression <tt>/IN/</tt> (i.e. where IN appears) |
||
Line 48: | Line 81: | ||
=={{header|BASIC}}== |
=={{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: |
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: |
||
< |
<syntaxhighlight lang="bash">echo 'print "foo"'|basic</syntaxhighlight> |
||
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): |
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): |
||
< |
<syntaxhighlight lang="dos">echo print "foo"|basic</syntaxhighlight> |
||
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: |
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: |
||
Line 68: | Line 101: | ||
Note that this is rather specific to [[Unix]]-like systems; most [[DOS]] and [[Windows]] interpreters are generally unable to handle programs in this manner, unless they were ported from a *nix system in the first place. |
Note that this is rather specific to [[Unix]]-like systems; most [[DOS]] and [[Windows]] interpreters are generally unable to handle programs in this manner, unless they were ported from a *nix system in the first place. |
||
==={{ |
==={{header|ZX Spectrum Basic}}=== |
||
On the ZX Spectrum, the ROM basic allows direct commands to be entered from the system prompt: |
On the ZX Spectrum, the ROM basic allows direct commands to be entered from the system prompt: |
||
< |
<syntaxhighlight lang="zxbasic">PRINT "Hello World!"</syntaxhighlight> |
||
==={{header|BaCon}}=== |
|||
BaCon is not an interpreter so we need to compile the code |
|||
a short explanation echo a command to file a.bac |
|||
then compile a.bac using bacon then run ./a |
|||
<syntaxhighlight lang="bash"> |
|||
echo "PRINT \"Hello World\" " > a.bac && bacon a && ./a |
|||
</syntaxhighlight> |
|||
Converting 'a.bac'... done, 2 lines were processed in 0.003 seconds. |
|||
Compiling 'a.bac'... cc -c a.bac.c |
|||
cc -o a a.bac.o -lm |
|||
Done, program 'a' ready. |
|||
Hello World |
|||
=={{header|Bc}}== |
|||
<syntaxhighlight lang="bash">$ echo 'print "Hello "; var=99; ++var + 20 + 3' | bc</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Hello 123</pre> |
|||
=={{header|Binary Lambda Calculus}}== |
|||
Several such one liners are shown on https://www.ioccc.org/2012/tromp/hint.html, such as |
|||
<syntaxhighlight lang="bash">echo "*Hello, world" | ./tromp</syntaxhighlight> |
|||
<syntaxhighlight lang="bash">echo "00010001100110010100011010000000010110000010010001010111110111101001000110100001110011010000000000101101110011100111111101111000000001111100110111000000101100000110110" | ./tromp -b | head -c 70</syntaxhighlight> |
|||
=={{header|Bracmat}}== |
=={{header|Bracmat}}== |
||
Line 77: | Line 135: | ||
DOS: |
DOS: |
||
< |
<syntaxhighlight lang="bracmat">bracmat "put$tay$(e^x,x,20)&"</syntaxhighlight> |
||
Linux: |
Linux: |
||
< |
<syntaxhighlight lang="bracmat">bracmat 'put$tay$(e^x,x,10)&'</syntaxhighlight> |
||
Output: |
Output: |
||
<pre> 1 |
<pre> 1 |
||
Line 105: | Line 163: | ||
=={{header|Burlesque}}== |
=={{header|Burlesque}}== |
||
<lang> |
<syntaxhighlight lang="text"> |
||
Burlesque.exe --no-stdin "5 5 .+" |
Burlesque.exe --no-stdin "5 5 .+" |
||
</syntaxhighlight> |
|||
</lang> |
|||
Using the official interpreter. |
Using the official interpreter. |
||
=={{header|C}}== |
=={{header|C}}== |
||
Line 116: | Line 174: | ||
delete it to avoid to call another shell/system dependent command/program). The |
delete it to avoid to call another shell/system dependent command/program). The |
||
''current directory'' is not specified by <tt>./</tt> in every system... |
''current directory'' is not specified by <tt>./</tt> in every system... |
||
< |
<syntaxhighlight lang="bash">$ echo 'main() {printf("Hello\n");}' | gcc -w -x c -; ./a.out</syntaxhighlight> |
||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
Line 122: | Line 180: | ||
Requires PowerShell 2: |
Requires PowerShell 2: |
||
< |
<syntaxhighlight lang="powershell">> Add-Type -TypeDefinition "public class HelloWorld { public static void SayHi() { System.Console.WriteLine(""Hi!""); } }" |
||
> [HelloWorld]::SayHi() |
> [HelloWorld]::SayHi() |
||
Hi!</ |
Hi!</syntaxhighlight> |
||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
Line 131: | Line 189: | ||
clj-env-dir comes with clojure-contrib. |
clj-env-dir comes with clojure-contrib. |
||
< |
<syntaxhighlight lang="bash">$ clj-env-dir -e "(defn add2 [x] (inc (inc x))) (add2 40)" |
||
#'user/add2 |
#'user/add2 |
||
42</ |
42</syntaxhighlight> |
||
=={{header|CMake}}== |
=={{header|CMake}}== |
||
This only works with [[Unix]] systems that have the device node <code>/dev/stdin</code>. |
This only works with [[Unix]] systems that have the device node <code>/dev/stdin</code>. |
||
< |
<syntaxhighlight lang="bash">echo 'message(STATUS "Goodbye, World!")' | cmake -P /dev/stdin</syntaxhighlight> |
||
=={{header|COBOL}}== |
|||
Works with GnuCOBOL 2.0 or later |
|||
<syntaxhighlight lang="bash">echo 'display "hello".' | cobc -xFj -frelax -</syntaxhighlight> |
|||
Longer, but avoids two relaxed syntax warnings: |
|||
<syntaxhighlight lang="bash">echo 'id division. program-id. hello. procedure division. display "hello".' | cobc -xFj -</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
Line 144: | Line 210: | ||
{{works with|SBCL}} |
{{works with|SBCL}} |
||
< |
<syntaxhighlight lang="bash">sbcl --noinform --eval '(progn (princ "Hello") (terpri) (quit))'</syntaxhighlight> |
||
{{works with|CLISP}} |
{{works with|CLISP}} |
||
< |
<syntaxhighlight lang="bash">clisp.exe -q -x "(progn (format t \"Hello from CLISP\") (quit))"</syntaxhighlight> |
||
=={{header|D}}== |
=={{header|D}}== |
||
{{works with|D|2}} |
{{works with|D|2}} |
||
requires [https://github.com/D-Programming-Language/tools/blob/master/rdmd.d rdmd] |
requires [https://github.com/D-Programming-Language/tools/blob/master/rdmd.d rdmd] |
||
< |
<syntaxhighlight lang="d">rdmd --eval="writeln(q{Hello World!})"</syntaxhighlight> |
||
<pre>Hello World!</pre> |
<pre>Hello World!</pre> |
||
=={{header|Dc}}== |
=={{header|Dc}}== |
||
< |
<syntaxhighlight lang="bash">dc -e '22 7/p'</syntaxhighlight> |
||
=={{header|Delphi}}== |
|||
Run in cmd.exe. |
|||
<syntaxhighlight lang="batch">echo program Prog;begin writeln('Hi');end. >> "./a.dpt" & dcc32 -Q -CC -W- "./a.dpt" & a.exe</syntaxhighlight> |
|||
The output has the default Delphi header, before the output of executable ("Hi"). |
|||
=={{header|E}}== |
=={{header|E}}== |
||
< |
<syntaxhighlight lang="bash">rune --src.e 'println("Hello")'</syntaxhighlight> |
||
The <code>--src</code> option ends with the the filename extension the provided type of program would have: |
The <code>--src</code> option ends with the the filename extension the provided type of program would have: |
||
<lang>rune --src.e-awt 'def f := <swing:makeJFrame>("Hello"); f.show(); f.addWindowListener(def _{to windowClosing(_) {interp.continueAtTop()} match _{}}); interp.blockAtTop()'</ |
<syntaxhighlight lang="text">rune --src.e-awt 'def f := <swing:makeJFrame>("Hello"); f.show(); f.addWindowListener(def _{to windowClosing(_) {interp.continueAtTop()} match _{}}); interp.blockAtTop()'</syntaxhighlight> |
||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">$ elixir -e "IO.puts 'Hello, World!'" |
|||
Hello, World!</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
< |
<syntaxhighlight lang="bash">emacs -batch -eval '(princ "Hello World!\n")' </syntaxhighlight> |
||
Or another example that does something useful: indent a [[C]] source file: |
Or another example that does something useful: indent a [[C]] source file: |
||
< |
<syntaxhighlight lang="bash">emacs -batch sample.c --eval '(indent-region (point-min) (point-max) nil)' -f save-buffer</syntaxhighlight> |
||
=={{header|Erlang}}== |
=={{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). |
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). |
||
< |
<syntaxhighlight lang="bash">$ erl -noshell -eval 'io:format("hello~n").' -s erlang halt |
||
hello</ |
hello</syntaxhighlight> |
||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="cmd">> echo printfn "Hello from F#" | fsi --quiet |
||
Hello from F#</ |
Hello from F#</syntaxhighlight> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="bash">$ factor -run=none -e="USE: io \"hi\" print"</syntaxhighlight> |
||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
{{works with|GNU Forth}} |
{{works with|GNU Forth}} |
||
< |
<syntaxhighlight lang="bash">$ gforth -e ".( Hello) cr bye" |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|Fortran}}== |
=={{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: |
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: |
||
< |
<syntaxhighlight lang="bash"> |
||
$ 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' |
$ 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' |
||
</syntaxhighlight> |
|||
</lang> |
|||
Sorry, I don't know how to upload my jpeg file for the Image tag. Let's use the dumb display instead. |
Sorry, I don't know how to upload my jpeg file for the Image tag. Let's use the dumb display instead. |
||
<pre> |
<pre> |
||
Line 215: | Line 289: | ||
0 20 40 60 80 100 |
0 20 40 60 80 100 |
||
</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>): |
|||
<syntaxhighlight lang="bash">echo "begin writeLn('Hi'); end." | ifpc /dev/stdin</syntaxhighlight> |
|||
=={{header|FreeBASIC}}== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
Shell "echo For i As Integer = 1 To 10 : Print i : Next > zzz.bas && fbc zzz.bas && zzz" |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 |
|||
2 |
|||
3 |
|||
4 |
|||
5 |
|||
6 |
|||
7 |
|||
8 |
|||
9 |
|||
10 |
|||
</pre> |
|||
=={{header|Frink}}== |
|||
Frink is distributed as a single <CODE>.jar</CODE> file that will run in a Java Virtual Machine. On many operating systems, just double-clicking this <CODE>.jar</CODE> file will run Frink with a graphical interface in an interactive mode. By specifying a different main-class (<CODE>frink.parser.Frink</CODE>) when starting Frink, it can be run in text-mode interactive mode as well. These options and sample starter scripts for various operating systems are provided in the [https://frinklang.org/#RunningFrink Running Frink] section of the documentation. |
|||
The <CODE>-e</CODE> command-line option executes a command or commands and prints its value. |
|||
<syntaxhighlight lang="frink">$ frink -e "factorFlat[2^67-1]"</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[193707721, 761838257287] |
|||
</pre> |
|||
=={{header|FutureBasic}}== |
|||
This is forcing the issue. FB has much more elegant ways of interacting with the Unix Shell. |
|||
<syntaxhighlight lang="futurebasic"> |
|||
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 |
|||
</syntaxhighlight> |
|||
Output |
|||
<pre> |
|||
October 2018 |
|||
Su Mo Tu We Th Fr Sa |
|||
1 2 3 4 5 6 |
|||
7 8 9 10 11 12 13 |
|||
14 15 16 17 18 19 20 |
|||
21 22 23 24 25 26 27 |
|||
28 29 30 31 |
|||
</pre> |
|||
=={{header|Gambas}}== |
|||
'''[https://gambas-playground.proko.eu/?gist=4385adf6a841435779a7afff3dadb58b Click this link to run this code]''' |
|||
<syntaxhighlight lang="gambas">Public Sub Main() |
|||
Shell "echo Hello World" |
|||
End</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
Hello World |
|||
</pre> |
</pre> |
||
=={{header|Gema}}== |
=={{header|Gema}}== |
||
< |
<syntaxhighlight lang="bash">$ gema -p '\B=Hello\n@end' |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|Go}}== |
=={{header|Go}}== |
||
<syntaxhighlight lang="bash">echo 'package main;func main(){println("hlowrld")}'>/tmp/h.go;go run /tmp/h.go</syntaxhighlight> |
|||
Go is first of all a compiled language and currently comes with no support for running as a script language. The compiler and linker can of course be run from a command line shell, as in, |
|||
{{out}} |
|||
<lang bash>echo 'package main;func main(){println("hllowrld")}'>8.go;8g 8.go;8l 8.8;8.out</lang> |
|||
This will overwrite existing files in the current directory 8.go, 8.8, and 8.out, assuming of course, that the the current directory is even writable, and will leave these files behind after executing. |
|||
Running Go as a script language is a popular request however, and one of the better solutions currently is [https://wiki.ubuntu.com/gorun gorun]. Gorun has solutions for the temporary file problem, writing to best-guess temporary directories by default and having an option to specify the location when this is needed or desired. Gorun still expects to read the source code from a file however, so you are on your own to deal with this before passing the file to gorun. Example, |
|||
<lang bash>echo 'package main;func main(){println("hllowrld")}'>/tmp/8.go;gorun /tmp/8.go</lang> |
|||
Output from either example: |
|||
<pre> |
<pre> |
||
hlowrld |
|||
hllowrld |
|||
</pre> |
</pre> |
||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
{{works with|UNIX Shell}} |
{{works with|UNIX Shell}} |
||
< |
<syntaxhighlight lang="bash">$ groovysh -q "println 'Hello'" |
||
Hello</ |
Hello</syntaxhighlight> |
||
{{works with|Windows Command Interpreter}} |
{{works with|Windows Command Interpreter}} |
||
< |
<syntaxhighlight lang="cmd">C:\Users\user> groovysh -q "println 'Hello'" |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="bash">$ ghc -e 'putStrLn "Hello"' |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|Huginn}}== |
|||
Result of an expression is printed by default: |
|||
<syntaxhighlight lang="bash">$ huginn -c '"Hello"'</syntaxhighlight> |
|||
Output: |
|||
<pre>"Hello"</pre> |
|||
Even with an explicit `print` function was used: |
|||
<syntaxhighlight lang="bash">$ huginn -c 'print("Hello\n")'</syntaxhighlight> |
|||
Output: |
|||
<pre>Hello |
|||
none</pre> |
|||
Unless the last expression ended with a semicolon: |
|||
<syntaxhighlight lang="bash">$ huginn -c 'print("Hello\n");'</syntaxhighlight> |
|||
Output: |
|||
<pre>Hello</pre> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
Line 250: | Line 399: | ||
These examples work with posix shells. |
These examples work with posix shells. |
||
< |
<syntaxhighlight lang="icon">echo "procedure main();write(\"hello\");end" | icont - -x</syntaxhighlight> |
||
< |
<syntaxhighlight lang="unicon">echo "procedure main();write(\"hello world\");end" >hello.icn; unicon hello.icn -x</syntaxhighlight> |
||
=={{Header|Insitux}}== |
|||
When Insitux has been already been installed system-wide (<code>npm i -g insitux</code>). |
|||
<pre> |
|||
$ npx ix -e "(+ 2 2)" |
|||
</pre> |
|||
{{out}} |
|||
<pre> |
|||
4 |
|||
</pre> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="bash">$ jconsole -js "exit echo 'Hello'" |
||
Hello |
Hello |
||
</syntaxhighlight> |
|||
Here, the (empty) result of <code>echo</code> is used as the exit code argument for <code>exit</code>. And, since it's empty, the the default exit code of 0 is what's actually used. The exit command here is used to prevent the default behavior of jconsole (which is to start the J [[wp:Command_shell|command shell]]) and to instead return to the OS command shell. |
|||
We could have instead used: |
|||
<syntaxhighlight lang="bash">$ :|jconsole -js "echo 'Hello'" |
|||
Hello |
|||
</syntaxhighlight> |
|||
for nearly identical behavior, but this issues J's command prompt before exiting. (But since J's command prompt is three space characters, this would be nearly invisible in many contexts, including here because the mediawiki implementation deletes those trailing spaces when rendering this page into html.) |
|||
That said, note that J interpreters can themselves be thought of as [[wp:Command_shell|command shells]]. |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
Line 264: | Line 436: | ||
These three lines work with Bourne Shell (or compatible) or C Shell (or compatible), or bash on Unix/Linux/MacOSX/Windows+cygwin |
These three lines work with Bourne Shell (or compatible) or C Shell (or compatible), or bash on Unix/Linux/MacOSX/Windows+cygwin |
||
< |
<syntaxhighlight lang="bash">$ echo 'public class X{public static void main(String[]args){' \ |
||
> 'System.out.println("Hello Java!");}}' >X.java |
> 'System.out.println("Hello Java!");}}' >X.java |
||
$ javac X.java && java X</ |
$ javac X.java && java X</syntaxhighlight> |
||
A user can also enter this as one (very long) line: |
A user can also enter this as one (very long) line: |
||
< |
<syntaxhighlight lang="bash">$ echo 'public class X{public static void main(String[]args){System.out.println("Hello Java!");}}'>X.java;javac X.java&&java X</syntaxhighlight> |
||
{{works with|cmd.exe |
{{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]) |
Works with cmd.exe on Windows (tested on Microsoft Windows XP [Version 5.1.2600]) |
||
< |
<syntaxhighlight lang="cmd">C:\>echo public class X{public static void main(String[] args){System.out.println("Hello Java!");}}>X.java&&javac X.java&&java X |
||
Hello Java!</ |
Hello Java!</syntaxhighlight> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
{{works with|SpiderMonkey}} |
{{works with|SpiderMonkey}} |
||
< |
<syntaxhighlight lang="bash">$ js -e 'print("hello")' |
||
hello</ |
hello</syntaxhighlight> |
||
=={{header|Lua}}== |
|||
<lang bash>lua -e 'print "Hello World!"'</lang> |
|||
=={{header| |
=={{header|jq}}== |
||
<syntaxhighlight lang="sh">$ jq -M -n 1+1 |
|||
{{works with|Kona}} |
|||
2</syntaxhighlight> |
|||
<lang bash>$ k -e "\`0: \"hello\\n\""</lang> |
|||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">$ julia -e 'for x in ARGS; println(x); end' foo bar |
||
foo |
foo |
||
bar</ |
bar</syntaxhighlight> |
||
=={{header|K}}== |
|||
{{works with|Kona}} |
|||
<syntaxhighlight lang="bash">$ k -e "\`0: \"hello\\n\""</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
The following one-liner works with GNOME Terminal on Ubuntu 14.04: |
|||
<pre> |
|||
echo 'fun main(args: Array<String>) = println("Hello Kotlin!")' >X.kt;kotlinc X.kt -include-runtime -d X.jar && java -jar X.jar |
|||
</pre> |
|||
{{out}} |
|||
<pre> |
|||
Hello Kotlin! |
|||
</pre> |
|||
=={{header|Lang}}== |
|||
This is an example for the Standard Lang implementation of Lang. |
|||
<syntaxhighlight lang="lang"> |
|||
$ lang -e "fn.println(Hello World)" |
|||
</syntaxhighlight> |
|||
=={{header|langur}}== |
|||
=== Linux === |
|||
<syntaxhighlight lang="langur">$ langur -e 'writeln "Are we reaching Fiji?"' |
|||
</syntaxhighlight> |
|||
=== Windows === |
|||
<syntaxhighlight lang="langur">C:\> langur /e 'writeln "Are we reaching Fiji?"' |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Are we reaching Fiji?</pre> |
|||
=={{header|Lasso}}== |
=={{header|Lasso}}== |
||
Line 297: | Line 499: | ||
From stdin: |
From stdin: |
||
< |
<syntaxhighlight lang="lasso">echo " 'The date and time is: ' + date " | lasso9 --</syntaxhighlight> |
||
Or alternatively: |
Or alternatively: |
||
< |
<syntaxhighlight lang="lasso">$ lasso9 -s " 'The date and time is: ' + date "</syntaxhighlight> |
||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
<syntaxhighlight lang="lb"> |
|||
<lang lb> |
|||
echo print "hello">oneLiner.bas & liberty -r oneLiner.bas echo print "hello">oneLiner.bas & liberty -r oneLiner.bas |
echo print "hello">oneLiner.bas & liberty -r oneLiner.bas echo print "hello">oneLiner.bas & liberty -r oneLiner.bas |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight lang="bash">lua -e 'print "Hello World!"'</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="bash">maple -c'print(HELLO);' -cquit</syntaxhighlight> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">echo Print[2+2] > file & math.exe -script file</syntaxhighlight> |
|||
=={{header|min}}== |
|||
<syntaxhighlight lang="min">min -e:"\"hi from min\" puts!"</syntaxhighlight> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="bash">nq -e "println \"Hello Nanoquery!\""</syntaxhighlight> |
|||
=={{header|NetLogo}}== |
|||
Commands can be entered into the NetLogo Command Center. NetLogo is white-space delimited. Variables can be defined with the LET command and used in the statement. The CC can be in various modes, such as Turtle mode, where entered commands are ran as if contained in an ASK TURTLES statement. |
|||
=== Observer Mode === |
|||
<syntaxhighlight lang="netlogo">let x 15 ask turtles [ set xcor x set x x + 1 ]</syntaxhighlight> |
|||
=== Turtle Mode === |
|||
=={{header|Mathematica}}== |
|||
<syntaxhighlight lang="netlogo">right random 90 forward 10</syntaxhighlight> |
|||
<lang Mathematica>echo Print[2+2] > file & math.exe -script file</lang> |
|||
=={{header|NetRexx}}== |
=={{header|NetRexx}}== |
||
{{works with|UNIX Shell}} |
{{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.) |
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.) |
||
< |
<syntaxhighlight lang="bash"> |
||
$ TNRX=`mktemp T_XXXXXXXXXXXX` && test ! -e $TNRX.* && (echo 'say "Goodbye, World!"' >$TNRX; nrc -exec $TNRX; rm $TNRX $TNRX.*; unset TNRX) |
$ TNRX=`mktemp T_XXXXXXXXXXXX` && test ! -e $TNRX.* && (echo 'say "Goodbye, World!"' >$TNRX; nrc -exec $TNRX; rm $TNRX $TNRX.*; unset TNRX) |
||
</syntaxhighlight> |
|||
</lang> |
|||
'''Output:''' |
'''Output:''' |
||
Line 330: | Line 553: | ||
=={{header|NewLISP}}== |
=={{header|NewLISP}}== |
||
< |
<syntaxhighlight lang="newlisp">newlisp -e "\"Hello\" |
||
->"Hello"</ |
->"Hello"</syntaxhighlight> |
||
=={{header|Nim}}== |
|||
The following works on any Linux system. With some minor changes, it should work on other systems too. |
|||
<pre>$ echo 'for i in 0..10: echo "Hello World"[0..i]' >/tmp/oneliner.nim; nim r oneliner |
|||
H |
|||
He |
|||
Hel |
|||
Hell |
|||
Hello |
|||
Hello |
|||
Hello W |
|||
Hello Wo |
|||
Hello Wor |
|||
Hello Worl |
|||
Hello World</pre> |
|||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
{{works with|UNIX Shell}} |
{{works with|UNIX Shell}} |
||
< |
<syntaxhighlight lang="bash">./obc -run '"Hello"->PrintLine();' -dest hello.obe ; ./obr hello.obe</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="bash">$ ocaml <(echo 'print_endline "Hello"') |
||
Hello</ |
Hello</syntaxhighlight> |
||
{{works with|OCaml|4.00+}} |
|||
<syntaxhighlight lang="bash">$ echo 'print_endline "Hello"' | ocaml -stdin |
|||
Hello</syntaxhighlight> |
|||
=={{header|Octave}}== |
=={{header|Octave}}== |
||
< |
<syntaxhighlight lang="matlab">$ octave --eval 'printf("Hello World, it is %s!\n",datestr(now));' |
||
Hello World, it is 28-Aug-2013 17:53:47!</ |
Hello World, it is 28-Aug-2013 17:53:47!</syntaxhighlight> |
||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">oforth --P"1000 seq map(#sqrt) sum print"</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
21097.4558874807 |
|||
</pre> |
|||
=={{header|ooRexx}}== |
=={{header|ooRexx}}== |
||
< |
<syntaxhighlight lang="bash"> |
||
rexx -e "say 'Goodbye, world.'" |
rexx -e "say 'Goodbye, world.'" |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Oz}}== |
=={{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: |
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: |
||
< |
<syntaxhighlight lang="bash">echo >tmp.oz "{System.show hello}"; ozc -l System -e tmp.oz |
||
hello</ |
hello</syntaxhighlight> |
||
With <code>-l System</code> we make the System module available so that we can print something. |
With <code>-l System</code> we make the System module available so that we can print something. |
||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
< |
<syntaxhighlight lang="bash">echo "print(Pi)" | gp -q</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
''See [[#Free Pascal|Free Pascal]]'' |
|||
<lang bash>$ echo "begin writeln('Hello World') end." >OneLiner.pas; fpc -Fe/dev/null OneLiner.pas; ./OneLiner |
|||
Hello World</lang> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="bash">$ perl -e 'print "Hello\n"' |
||
Hello</ |
Hello</syntaxhighlight> |
||
More information about the many ways of invoking perl can be found in [http://perldoc.perl.org/perlrun.html perlrun]. |
More information about the many ways of invoking perl can be found in [http://perldoc.perl.org/perlrun.html perlrun]. |
||
=={{header| |
=={{header|Phix}}== |
||
<!--(notonline)--> |
|||
{{works with|Rakudo|#22 "Thousand Oaks"}} |
|||
Command line option -e added for 0.8.1. Outer quotes only rqd if snippet contains spaces, otherwise ignored. <br> |
|||
Most one-liners will probably start with '?' since eg "1+2" gives a compilation error. |
|||
<lang bash>$ perl6 -e 'say "Hello, world!"' |
|||
<pre> |
|||
Hello, world!</lang> |
|||
C:\Program Files (x86)\Phix>p -e ?357+452 |
|||
809 |
|||
C:\Program Files (x86)\Phix>p -e "?357+452" |
|||
809 |
|||
</pre> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
assuming you have the PHP CLI (command-line interface) installed, not just the web server plugin |
assuming you have the PHP CLI (command-line interface) installed, not just the web server plugin |
||
< |
<syntaxhighlight lang="bash">$ php -r 'echo "Hello\n";' |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">$ picolisp -'prinl "Hello world!"' -bye |
||
Hello world!</ |
Hello world!</syntaxhighlight> |
||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
< |
<syntaxhighlight lang="bash">$ pike -e 'write("Hello\n");' |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
< |
<syntaxhighlight lang="cmd">> powershell -Command "Write-Host 'Hello'" |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|Processing}}== |
|||
The command-line tool processing-java takes a sketch directory (not a file) and so a simple program cannot be piped in from the shell using process substitution. However, a long shell one-liner may write a sketch file to disk, then run it, so long as the folder name and the PDE file name match, e.g. /Tmp/Tmp.pde |
|||
In bash: |
|||
<syntaxhighlight lang="processing">mkdir -p Tmp; echo "println(\"hello world\");" > Tmp/Tmp.pde; processing-java --sketch="`pwd`/Tmp" --run</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
hello world |
|||
</pre> |
|||
=={{header|Prolog}}== |
|||
===Command-Line Options=== |
|||
<syntaxhighlight lang="prolog">$ swipl -g "writeln('hello world')." -t 'halt.' |
|||
hello world |
|||
$</syntaxhighlight> |
|||
<syntaxhighlight lang="prolog">$ gprolog --init-goal "write('goodbye'),nl,halt" |
|||
goodbye |
|||
$</syntaxhighlight> |
|||
<syntaxhighlight lang="prolog">$ yap -q -g "current_prolog_flag(dialect, D), writeln(D), halt" |
|||
yap</syntaxhighlight> |
|||
=== <<< === |
|||
<syntaxhighlight lang="prolog">$ swipl -q <<< "current_prolog_flag(dialect,D), writeln(D), halt." |
|||
swi |
|||
$ yap -q <<< "current_prolog_flag(dialect,D), writeln(D), halt." |
|||
yap</syntaxhighlight> |
|||
=== Pipe === |
|||
<syntaxhighlight lang="prolog">$ echo "current_prolog_flag(dialect,D), writeln(D), halt." | swipl -q |
|||
swi |
|||
$ echo "current_prolog_flag(dialect,D), writeln(D), halt." | yap -q |
|||
yap</syntaxhighlight> |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
Runs on Linux with(thanks to) bash. Path variables must be set as decribed in INSTALL. |
Runs on Linux with(thanks to) bash. Path variables must be set as decribed in INSTALL. |
||
< |
<syntaxhighlight lang="bash">$ echo 'messagerequester("Greetings","hello")' > "dib.pb" && ./pbcompiler dib.pb -e "dib" && ./dib</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Prints "Hello"=== |
===Prints "Hello"=== |
||
< |
<syntaxhighlight lang="bash">$ python -c 'print "Hello"' |
||
Hello</ |
Hello</syntaxhighlight> |
||
===Web server with CGI=== |
===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: |
The python CGIHTTPServer module is also an [[Executable library|executable library]] that performs as a web server with CGI. to start enter: |
||
<lang |
<syntaxhighlight lang="bash">python -m CGIHTTPServer</syntaxhighlight> |
||
It returns with: |
It returns with: |
||
<pre>Serving HTTP on 0.0.0.0 port 8000 ...</pre> |
<pre>Serving HTTP on 0.0.0.0 port 8000 ...</pre> |
||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="bash">$ QUACK=$(mktemp); echo "say 'hello'" > $QUACK; quackery $QUACK; rm $QUACK |
|||
hello</syntaxhighlight> |
|||
===Via Python 3=== |
|||
As Quackery is implemented as a Python 3 function, assuming that quackery.py is in the module search path: |
|||
<syntaxhighlight lang="bash">$ python3 -c 'import quackery ; quackery.quackery(r""" say '\''hello'\'' cr """)' |
|||
hello</syntaxhighlight> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
< |
<syntaxhighlight lang="bash">$ echo 'cat("Hello\n")' | R --slave |
||
Hello</ |
Hello</syntaxhighlight> |
||
Alternatively, using the Rscript front-end, |
Alternatively, using the Rscript front-end, |
||
< |
<syntaxhighlight lang="bash">$ Rscript -e 'cat("Hello\n")' |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
< |
<syntaxhighlight lang="bash">$ racket -e "(displayln \"Hello World\")" |
||
Hello World</ |
Hello World</syntaxhighlight> |
||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
{{works with|Rakudo|#22 "Thousand Oaks"}} |
|||
<syntaxhighlight lang="bash">$ raku -e 'say "Hello, world!"' |
|||
Hello, world!</syntaxhighlight> |
|||
=={{header|REBOL}}== |
=={{header|REBOL}}== |
||
< |
<syntaxhighlight lang="bash">rebview -vswq --do "print {Hello!} quit" </syntaxhighlight> |
||
Output: |
Output: |
||
Line 427: | Line 734: | ||
=={{header|Retro}}== |
=={{header|Retro}}== |
||
< |
<syntaxhighlight lang="retro">echo '\'hello s:put nl bye' | retro</syntaxhighlight> |
||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
Note: |
Note: Regina REXX is the only version of REXX that supports this type of behavior (taking it's input from a console stream). |
||
<syntaxhighlight lang="rexx"> |
|||
<lang rexx> ┌────────────────────────────────────────────────┐ |
|||
╔══════════════════════════════════════════════╗ |
|||
│ from the MS Windows® command line (cmd.exe) │ |
|||
║ ║ |
|||
└────────────────────────────────────────────────┘ |
|||
║ from the MS Window command line (cmd.exe) ║ |
|||
║ ║ |
|||
╚══════════════════════════════════════════════╝ |
|||
echo do j=10 by 20 for 4;say right('hello',j);end | regina</lang> |
|||
echo do j=10 by 20 for 4; say right('hello',j); end | regina</syntaxhighlight> |
|||
'''output''' when using the (above) from the command line: |
|||
'''output''' when entering the (above) from the (DOS) command line: |
|||
<pre style="overflow:scroll"> |
|||
<pre> |
|||
hello |
hello |
||
hello |
hello |
||
hello |
hello |
||
hello |
hello |
||
</pre> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
see "Hello World!" + nl |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
Hello World! |
|||
</pre> |
|||
=={{header|RPL}}== |
|||
RPL command-line interpreter allows to pass several instructions and values in one line, provided there is no program branch instruction among them. It is nevertheless possible to have a program structure in the line by bracketing it with <code>≪ ≫</code>, which means "this is an unnamed program". Adding the word <code>EVAL</code> at the end will execute the code, otherwise it would stay at level 1 of the stack. |
|||
" World" "Hello" SWAP + |
|||
≪ " World" "Hello" SWAP + ≫ EVAL |
|||
This less trivial one-liner example calculates S(5), where S(n) is a Machin-like formula : |
|||
≪ 0 0 5 '''FOR''' k 2 k * 1 + → n ≪ -1 k ^ n / 4 5 n ^ / 239 n ^ INV - * + ≫ '''NEXT''' 4 * ≫ EVAL |
|||
{{out}} |
|||
<pre> |
|||
3: "Hello world" |
|||
2: "Hello world" |
|||
1: 3.14159265262 |
|||
</pre> |
</pre> |
||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
From [[Unix]]: |
From [[Unix]]: |
||
< |
<syntaxhighlight lang="bash">$ ruby -e 'puts "Hello"' |
||
Hello</ |
Hello</syntaxhighlight> |
||
{{works with|JRuby}} |
{{works with|JRuby}} |
||
< |
<syntaxhighlight lang="bash">$ jruby -e 'puts "Hello from JRuby"' |
||
Hello from JRuby</ |
Hello from JRuby</syntaxhighlight> |
||
{{works with|Rubinius}} |
{{works with|Rubinius}} |
||
< |
<syntaxhighlight lang="bash">$ rbx -e 'puts "Hello from Rubinius"' |
||
Hello from Rubinius</ |
Hello from Rubinius</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
< |
<syntaxhighlight lang="bash">print shell$("echo hello world")</syntaxhighlight> |
||
=={{header|Rust}}== |
|||
The following code leaves the file <tt>rust_out</tt> in the current directory (it does not |
|||
delete it to avoid to call another shell/system dependent command/program). The |
|||
''current directory'' is not specified by <tt>./</tt> in every system... |
|||
<syntaxhighlight lang="bash">$ echo 'fn main(){println!("Hello!")}' | rustc -;./rust_out</syntaxhighlight> |
|||
=={{header|S-lang}}== |
|||
<syntaxhighlight lang="s-lang">slsh -e 'print("Hello, World")'</syntaxhighlight> |
|||
Or, in MSW cmd.exe: |
|||
<syntaxhighlight lang="s-lang">slsh -e "print(\"Hello, World\")"</syntaxhighlight> |
|||
Note that print() is included w/slsh, but is not part of S-Lang itself. |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
[[Category:Scala Implementations]] |
|||
{{libheader|Scala}} |
{{libheader|Scala}} |
||
< |
<syntaxhighlight lang="cmd">C:\>scala -e "println(\"Hello\")" |
||
Hello</ |
Hello</syntaxhighlight> |
||
<syntaxhighlight lang="cmd"> |
|||
PS C:\> scala -e 'println(\"Hello\")' |
PS C:\> scala -e 'println(\"Hello\")' |
||
Hello</ |
Hello</syntaxhighlight> |
||
The escaping of quotes is required by Windows. On Unix and shown in the example on [[PowerShell|Windows PowerShell]], one could just use single quotes around the code. |
|||
The escaping of quotes is required by Windows. |
|||
On Unix and shown in the example on [[PowerShell|Windows PowerShell]], |
|||
one could just use single quotes around the code. |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
{{works with|Guile}} |
{{works with|Guile}} |
||
< |
<syntaxhighlight lang="scheme">guile -c '(display "Hello, world!\n")'</syntaxhighlight> |
||
=={{header|sed}}== |
|||
The first non-option argument is interpreted as the script. |
|||
<syntaxhighlight lang="sh">$ sed q /proc/meminfo</syntaxhighlight> |
|||
Alternatively, scripts can be passed via the <code>-e</code> option. |
|||
<syntaxhighlight lang="sh">$ sed -e 's/[[:space:]]*$//' -e '/./!d' file.txt</syntaxhighlight> |
|||
=={{header|Shiny}}== |
=={{header|Shiny}}== |
||
< |
<syntaxhighlight lang="shiny">shiny -e "say 'hi'" </syntaxhighlight> |
||
=={{header|Sidef}}== |
|||
<syntaxhighlight lang="ruby">% sidef -E "say 'hello'"</syntaxhighlight> |
|||
=={{header|Slate}}== |
=={{header|Slate}}== |
||
< |
<syntaxhighlight lang="slate">./slate --eval "[inform: 'hello'] ensure: [exit: 0].".</syntaxhighlight> |
||
=={{header|SNOBOL4}}== |
=={{header|SNOBOL4}}== |
||
Portable version |
Portable version |
||
< |
<syntaxhighlight lang="snobol">echo 'a output = "Hello, World!";end' | snobol4 -b</syntaxhighlight> |
||
Bash version |
Bash version |
||
< |
<syntaxhighlight lang="snobol">snobol4 -b <<<'a output = "Hello, World!";end'</syntaxhighlight> |
||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
This is an area where Tcl is lacking, though when shell one-liners are required a construct like this is typically used: |
This is an area where Tcl is lacking, though when shell one-liners are required a construct like this is typically used: |
||
< |
<syntaxhighlight lang="bash">$ echo 'puts Hello' | tclsh |
||
Hello</ |
Hello</syntaxhighlight> |
||
=={{header|TXR}}== |
=={{header|TXR}}== |
||
< |
<syntaxhighlight lang="bash">$ echo 123-456-7890 | txr -c '@a-@b-@c' - |
||
a="123" |
a="123" |
||
b="456" |
b="456" |
||
c="7890" |
c="7890" |
||
</syntaxhighlight> |
|||
</lang> |
|||
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. |
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. |
||
The <code>-e</code> (evaluate) and <code>-p</code> (evaluate and print) options provide shell one-liner access to |
|||
TXR Lisp: |
|||
<syntaxhighlight lang="bash">$ txr -p '(+ 2 2)' |
|||
4</syntaxhighlight> |
|||
<syntaxhighlight lang="bash">$ txr -e '(mkdir "foo" #o777)' |
|||
$ ls -ld foo |
|||
drwxrwxr-x 2 kaz kaz 4096 Mar 4 23:36 foo</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
Explicit call of the shell, passing the shell command via the <code>-c</code> option: |
Explicit call of the shell, passing the shell command via the <code>-c</code> option: |
||
<lang |
<syntaxhighlight lang="bash">$ sh -c ls</syntaxhighlight> |
||
< |
<syntaxhighlight lang="bash">$ sh -c "echo hello"</syntaxhighlight> |
||
To invoke a specific shell like [[Bash]], [[Korn Shell]] or [[Z Shell]]: |
To invoke a specific shell like [[Bash]], [[Korn Shell]] or [[Z Shell]]: |
||
< |
<syntaxhighlight lang="bash">$ bash -c 'paste <(echo 1) <(echo 2)' |
||
$ ksh -c 'let i=3+4; print $i' |
$ ksh -c 'let i=3+4; print $i' |
||
$ zsh -c 'if [[ 5 -lt 6 ]] { echo ok };'</ |
$ zsh -c 'if [[ 5 -lt 6 ]] { echo ok };'</syntaxhighlight> |
||
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: |
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: |
||
< |
<syntaxhighlight lang="bash">$ VAR=`echo hello` # obsolescent backtick notation |
||
$ VAR=$(echo hello) # modern POSIX notation |
$ VAR=$(echo hello) # modern POSIX notation |
||
$ (echo hello) # execute in another shell process, not in this one</ |
$ (echo hello) # execute in another shell process, not in this one</syntaxhighlight> |
||
There are more details about <code>`echo hello`</code> and <code>$(echo hello)</code> at [[Execute a system command#UNIX Shell]]. |
There are more details about <code>`echo hello`</code> and <code>$(echo hello)</code> at [[Execute a system command#UNIX Shell]]. |
||
Line 523: | Line 894: | ||
Run a C shell command from any shell: |
Run a C shell command from any shell: |
||
< |
<syntaxhighlight lang="bash">$ csh -fc 'if (5 < 6) echo ok'</syntaxhighlight> |
||
==={{header|es}}=== |
==={{header|es}}=== |
||
Run a command, in extensible shell, from any shell: |
Run a command, in extensible shell, from any shell: |
||
< |
<syntaxhighlight lang="bash">$ es -c 'if {test 5 -lt 6} {echo ok}'</syntaxhighlight> |
||
=={{header|Ursala}}== |
=={{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>, |
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>, |
||
< |
<syntaxhighlight lang="bash">$ fun --main=-[hello]- --show |
||
hello |
hello |
||
$ fun --main="power/2 32" --cast %n |
$ fun --main="power/2 32" --cast %n |
||
4294967296 |
4294967296 |
||
$ fun --m="..mp2str mpfr..pi 120" --c %s |
$ fun --m="..mp2str mpfr..pi 120" --c %s |
||
'3.1415926535897932384626433832795028847E+00'</ |
'3.1415926535897932384626433832795028847E+00'</syntaxhighlight> |
||
=={{header|Vedit macro language}}== |
=={{header|Vedit macro language}}== |
||
The following DOS command starts Vedit and displays a message. |
The following DOS command starts Vedit and displays a message. |
||
When the user presses any key, Vedit exits. |
When the user presses any key, Vedit exits. |
||
< |
<syntaxhighlight lang="cmd">vpw -c'Get_Key("Hello!") exit'</syntaxhighlight> |
||
=={{header|Wart}}== |
=={{header|Wart}}== |
||
< |
<syntaxhighlight lang="bash">echo "prn 34" |wart</syntaxhighlight> |
||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="bash">echo 'System.print("Hello from Wren!")' > tmp.wren; wren tmp.wren</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Hello from Wren! |
|||
</pre> |
|||
=={{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 |
|||
<syntaxhighlight lang="bash">echo 'println("Hello World ",5+6)' | zkl</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
zkl 1.12.9, released 2014-05-01 |
|||
Hello World 11 |
|||
Hello World 11 |
|||
</pre> |
|||
{{omit from|6502 Assembly|Anything can be a one-liner if you JSR to it.}} |
|||
{{omit from|68000 Assembly}} |
|||
{{omit from|Z80 Assembly}} |
|||
{{omit from|8086 Assembly}} |
|||
{{omit from|x86 Assembly}} |
|||
{{omit from|ARM Assembly}} |
|||
{{omit from|AutoHotkey|No interactive shell}} |
{{omit from|AutoHotkey|No interactive shell}} |
||
{{ |
{{omit from|C++}} |
||
{{omit from|Java}} |
|||
{{omit from|Maxima}} |
{{omit from|Maxima}} |
||
{{omit from|Modula-3}} |
{{omit from|Modula-3}} |
||
{{omit from|SAS}} |
|||
{{omit from|Stata}} |
|||
{{omit from|TI-83 BASIC}} |
{{omit from|TI-83 BASIC}} |
||
{{omit from|TI-89 BASIC}} <!-- Does not have an external OS/command processor. --> |
{{omit from|TI-89 BASIC}} <!-- Does not have an external OS/command processor. --> |
Latest revision as of 19:59, 22 February 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Show how to specify and execute a short program in the language from a command shell, where the input to the command shell is only one line in length.
Avoid depending on the particular shell or operating system used as much as is reasonable; if the language has notable implementations which have different command argument syntax, or the systems those implementations run on have different styles of shells, it would be good to show multiple examples.
11l
The following works on Windows.
...>echo L(i) 0..10 {print("Hello World"[0..i])} > oneliner.11l && 11l oneliner.11l && oneliner.exe H He Hel Hell Hello Hello Hello W Hello Wo Hello Wor Hello Worl Hello World
ACL2
$ acl2 <<< '(cw "Hello.")'
Ada
under a unixoid shell (bash, sh, ...)
echo 'with Ada.text_IO; use Ada.text_IO; procedure X is begin Put("Hello!"); end X;' > x.adb; gnatmake x; ./x; rm x.adb x.ali x.o x
Note that this mercilessly overwrites and later deletes any files x.adb, x.ali, x,o and x in the current directory.
Aikido
echo 'println ("Hello")' | aikido
Aime
$ src/aime -c 'o_text("Hello, World!\n");'
ALGOL 68
$ a68g -e 'print(("Hello",new line))'
Output:
Hello
For an ELLA ALGOL 68 one-liner, merge these lines of shell code:
code='print(("Hello", new line))'
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 &&
$a; rm $a
Output:
Hello
AppleScript
osascript -e 'say "Hello, World!"'
Arturo
You may run any arbitrary code string directly using the -e
(or --evaluate
) flag:
$ arturo -e:"print {Hello World!}"
- Output:
Hello World!
AWK
Maybe the most common way one can use awk is from the command line for one-liners, feeding the interpreter with an input.
$ awk 'BEGIN { print "Hello"; }'
A more "complex" and "real" example:
$ awk '/IN/ { print $2, $4; }' <input.txt
Select field 2 and 4 of lines matching the regular expression /IN/ (i.e. where IN appears)
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:
echo 'print "foo"'|basic
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):
echo print "foo"|basic
Also, some popular interpreters (including Michael Haardt's bas and Chipmunk Basic) will include an extra prompt before exiting unless you include exit
or system
(depending on the specific interpreter's syntax). This sample output shows both with and without system
in bas:
erik@satan:~$ echo 'print "foo"'|bas bas 2.2 Copyright 1999-2009 Michael Haardt. This is free software with ABSOLUTELY NO WARRANTY. > foo > erik@satan:~$ echo 'print "foo":system'|bas bas 2.2 Copyright 1999-2009 Michael Haardt. This is free software with ABSOLUTELY NO WARRANTY. > foo erik@satan:~$
Note that this is rather specific to Unix-like systems; most DOS and Windows interpreters are generally unable to handle programs in this manner, unless they were ported from a *nix system in the first place.
ZX Spectrum Basic
On the ZX Spectrum, the ROM basic allows direct commands to be entered from the system prompt:
PRINT "Hello World!"
BaCon
BaCon is not an interpreter so we need to compile the code a short explanation echo a command to file a.bac 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. Compiling 'a.bac'... cc -c a.bac.c cc -o a a.bac.o -lm Done, program 'a' ready. Hello World
Bc
$ echo 'print "Hello "; var=99; ++var + 20 + 3' | bc
- Output:
Hello 123
Binary Lambda Calculus
Several such one liners are shown on https://www.ioccc.org/2012/tromp/hint.html, such as
echo "*Hello, world" | ./tromp
echo "00010001100110010100011010000000010110000010010001010111110111101001000110100001110011010000000000101101110011100111111101111000000001111100110111000000101100000110110" | ./tromp -b | head -c 70
Bracmat
This example uses the predefined function tay
to make a taylor expansion of e^x
.
DOS:
bracmat "put$tay$(e^x,x,20)&"
Linux:
bracmat 'put$tay$(e^x,x,10)&'
Output:
1 + x + 1/2*x^2 + 1/6*x^3 + 1/24*x^4 + 1/120*x^5 + 1/720*x^6 + 1/5040*x^7 + 1/40320*x^8 + 1/362880*x^9 + 1/3628800*x^10 + 1/39916800*x^11 + 1/479001600*x^12 + 1/6227020800*x^13 + 1/87178291200*x^14 + 1/1307674368000*x^15 + 1/20922789888000*x^16 + 1/355687428096000*x^17 + 1/6402373705728000*x^18 + 1/121645100408832000*x^19 + 1/2432902008176640000*x^20
Burlesque
Burlesque.exe --no-stdin "5 5 .+"
Using the official interpreter.
C
The following code leaves the file a.out in the current directory (it does not delete it to avoid to call another shell/system dependent command/program). The current directory is not specified by ./ in every system...
$ echo 'main() {printf("Hello\n");}' | gcc -w -x c -; ./a.out
C#
Note: whilst small, this is more than one line.
Requires PowerShell 2:
> Add-Type -TypeDefinition "public class HelloWorld { public static void SayHi() { System.Console.WriteLine(""Hi!""); } }"
> [HelloWorld]::SayHi()
Hi!
Clojure
Note: whilst small, this is more than one line.
clj-env-dir comes with clojure-contrib.
$ clj-env-dir -e "(defn add2 [x] (inc (inc x))) (add2 40)"
#'user/add2
42
CMake
This only works with Unix systems that have the device node /dev/stdin
.
echo 'message(STATUS "Goodbye, World!")' | cmake -P /dev/stdin
COBOL
Works with GnuCOBOL 2.0 or later
echo 'display "hello".' | cobc -xFj -frelax -
Longer, but avoids two relaxed syntax warnings:
echo 'id division. program-id. hello. procedure division. display "hello".' | cobc -xFj -
Common Lisp
Varies by implementation
sbcl --noinform --eval '(progn (princ "Hello") (terpri) (quit))'
clisp.exe -q -x "(progn (format t \"Hello from CLISP\") (quit))"
D
requires rdmd
rdmd --eval="writeln(q{Hello World!})"
Hello World!
Dc
dc -e '22 7/p'
Delphi
Run in cmd.exe.
echo program Prog;begin writeln('Hi');end. >> "./a.dpt" & dcc32 -Q -CC -W- "./a.dpt" & a.exe
The output has the default Delphi header, before the output of executable ("Hi").
E
rune --src.e 'println("Hello")'
The --src
option ends with the the filename extension the provided type of program would have:
rune --src.e-awt 'def f := <swing:makeJFrame>("Hello"); f.show(); f.addWindowListener(def _{to windowClosing(_) {interp.continueAtTop()} match _{}}); interp.blockAtTop()'
Elixir
$ elixir -e "IO.puts 'Hello, World!'"
Hello, World!
Emacs Lisp
emacs -batch -eval '(princ "Hello World!\n")'
Or another example that does something useful: indent a C source file:
emacs -batch sample.c --eval '(indent-region (point-min) (point-max) nil)' -f save-buffer
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).
$ erl -noshell -eval 'io:format("hello~n").' -s erlang halt
hello
F#
> echo printfn "Hello from F#" | fsi --quiet
Hello from F#
Factor
$ factor -run=none -e="USE: io \"hi\" print"
Forth
$ gforth -e ".( Hello) cr bye"
Hello
Fortran
This example, stolen from the 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.
0.6 +*------------+-------------+------------+-------------+------------++ +** + + Bessel function of 1st kind ****** + 0.5 +** ++ |** | 0.4 +** ++ * * | 0.3 *+* * ++ * * ** * | 0.2 *+* *** ** ** ++ 0.1 *+* * * ** ** *** ** ** * ** * ++ * ** * * *** ** * * *** ** *** ** ** *** ** ** *** ** ** | 0 *+ * * * * * * * * * * * *** * * * * *** * * *** *** * * *** ***+ | * * * * *** * * * * *** * * * * *** *** * * **** *** *** *** *| -0.1 ++ * * * * ** *** *** ** ** *** ** ** ** ** ** ** ** ** | *** *** ** ** ** ** * * | -0.2 ++ ** ** ** ++ | ** * | -0.3 ++ ** ++ + ** + + + + + -0.4 ++------------+-------------+------------+-------------+------------++ 0 20 40 60 80 100
Free Pascal
The FPC (Free Pascal compiler) comes with the utility instantfpc(1) or ifpc(1) for short (Debian or FreeBSD package fpc-utils):
echo "begin writeLn('Hi'); end." | ifpc /dev/stdin
FreeBASIC
' FB 1.05.0 Win64
Shell "echo For i As Integer = 1 To 10 : Print i : Next > zzz.bas && fbc zzz.bas && zzz"
Sleep
- Output:
1 2 3 4 5 6 7 8 9 10
Frink
Frink is distributed as a single .jar
file that will run in a Java Virtual Machine. On many operating systems, just double-clicking this .jar
file will run Frink with a graphical interface in an interactive mode. By specifying a different main-class (frink.parser.Frink
) when starting Frink, it can be run in text-mode interactive mode as well. These options and sample starter scripts for various operating systems are provided in the Running Frink section of the documentation.
The -e
command-line option executes a command or commands and prints its value.
$ frink -e "factorFlat[2^67-1]"
- Output:
[193707721, 761838257287]
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
October 2018 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Gambas
Click this link to run this code
Public Sub Main()
Shell "echo Hello World"
End
Output:
Hello World
Gema
$ gema -p '\B=Hello\n@end'
Hello
Go
echo 'package main;func main(){println("hlowrld")}'>/tmp/h.go;go run /tmp/h.go
- Output:
hlowrld
Groovy
$ groovysh -q "println 'Hello'"
Hello
C:\Users\user> groovysh -q "println 'Hello'"
Hello
Haskell
$ ghc -e 'putStrLn "Hello"'
Hello
Huginn
Result of an expression is printed by default:
$ huginn -c '"Hello"'
Output:
"Hello"
Even with an explicit `print` function was used:
$ huginn -c 'print("Hello\n")'
Output:
Hello none
Unless the last expression ended with a semicolon:
$ huginn -c 'print("Hello\n");'
Output:
Hello
Icon and Unicon
These examples work with posix shells.
echo "procedure main();write(\"hello world\");end" >hello.icn; unicon hello.icn -x
Insitux
When Insitux has been already been installed system-wide (npm i -g insitux
).
$ npx ix -e "(+ 2 2)"
- Output:
4
J
$ jconsole -js "exit echo 'Hello'"
Hello
Here, the (empty) result of echo
is used as the exit code argument for exit
. And, since it's empty, the the default exit code of 0 is what's actually used. The exit command here is used to prevent the default behavior of jconsole (which is to start the J command shell) and to instead return to the OS command shell.
We could have instead used:
$ :|jconsole -js "echo 'Hello'"
Hello
for nearly identical behavior, but this issues J's command prompt before exiting. (But since J's command prompt is three space characters, this would be nearly invisible in many contexts, including here because the mediawiki implementation deletes those trailing spaces when rendering this page into html.)
Java
These three lines work with Bourne Shell (or compatible) or C Shell (or compatible), or bash on Unix/Linux/MacOSX/Windows+cygwin
$ echo 'public class X{public static void main(String[]args){' \
> 'System.out.println("Hello Java!");}}' >X.java
$ javac X.java && java X
A user can also enter this as one (very long) line:
$ echo 'public class X{public static void main(String[]args){System.out.println("Hello Java!");}}'>X.java;javac X.java&&java X
Compatible Environments (such as cmd.exe)
Works with cmd.exe on Windows (tested on Microsoft Windows XP [Version 5.1.2600])
C:\>echo public class X{public static void main(String[] args){System.out.println("Hello Java!");}}>X.java&&javac X.java&&java X
Hello Java!
JavaScript
$ js -e 'print("hello")'
hello
jq
$ jq -M -n 1+1
2
Julia
$ julia -e 'for x in ARGS; println(x); end' foo bar
foo
bar
K
$ k -e "\`0: \"hello\\n\""
Kotlin
The following one-liner works with GNOME Terminal on Ubuntu 14.04:
echo 'fun main(args: Array<String>) = println("Hello Kotlin!")' >X.kt;kotlinc X.kt -include-runtime -d X.jar && java -jar X.jar
- Output:
Hello Kotlin!
Lang
This is an example for the Standard Lang implementation of Lang.
$ lang -e "fn.println(Hello World)"
langur
Linux
$ langur -e 'writeln "Are we reaching Fiji?"'
Windows
C:\> langur /e 'writeln "Are we reaching Fiji?"'
- Output:
Are we reaching Fiji?
Lasso
From stdin:
echo " 'The date and time is: ' + date " | lasso9 --
Or alternatively:
$ lasso9 -s " 'The date and time is: ' + date "
Liberty BASIC
echo print "hello">oneLiner.bas & liberty -r oneLiner.bas echo print "hello">oneLiner.bas & liberty -r oneLiner.bas
Lua
lua -e 'print "Hello World!"'
Maple
maple -c'print(HELLO);' -cquit
Mathematica/Wolfram Language
echo Print[2+2] > file & math.exe -script file
min
min -e:"\"hi from min\" puts!"
Nanoquery
nq -e "println \"Hello Nanoquery!\""
NetLogo
Commands can be entered into the NetLogo Command Center. NetLogo is white-space delimited. Variables can be defined with the LET command and used in the statement. The CC can be in various modes, such as Turtle mode, where entered commands are ran as if contained in an ASK TURTLES statement.
Observer Mode
let x 15 ask turtles [ set xcor x set x x + 1 ]
Turtle Mode
right random 90 forward 10
NetRexx
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:
NetRexx portable processor, version NetRexx 3.01, build 40-20120823-0156 Copyright (c) RexxLA, 2011,2012. All rights reserved. Parts Copyright (c) IBM Corporation, 1995,2008. Program T_dO7RQs5HPElq ===== Exec: T_dO7RQs5HPElq ===== Goodbye, World! Processing of 'T_dO7RQs5HPElq' complete
NewLISP
newlisp -e "\"Hello\"
->"Hello"
Nim
The following works on any Linux system. With some minor changes, it should work on other systems too.
$ echo 'for i in 0..10: echo "Hello World"[0..i]' >/tmp/oneliner.nim; nim r oneliner H He Hel Hell Hello Hello Hello W Hello Wo Hello Wor Hello Worl Hello World
Objeck
./obc -run '"Hello"->PrintLine();' -dest hello.obe ; ./obr hello.obe
OCaml
$ ocaml <(echo 'print_endline "Hello"')
Hello
$ echo 'print_endline "Hello"' | ocaml -stdin
Hello
Octave
$ octave --eval 'printf("Hello World, it is %s!\n",datestr(now));'
Hello World, it is 28-Aug-2013 17:53:47!
Oforth
oforth --P"1000 seq map(#sqrt) sum print"
- Output:
21097.4558874807
ooRexx
rexx -e "say 'Goodbye, world.'"
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:
echo >tmp.oz "{System.show hello}"; ozc -l System -e tmp.oz
hello
With -l System
we make the System module available so that we can print something.
PARI/GP
echo "print(Pi)" | gp -q
Pascal
See Free Pascal
Perl
$ perl -e 'print "Hello\n"'
Hello
More information about the many ways of invoking perl can be found in perlrun.
Phix
Command line option -e added for 0.8.1. Outer quotes only rqd if snippet contains spaces, otherwise ignored.
Most one-liners will probably start with '?' since eg "1+2" gives a compilation error.
C:\Program Files (x86)\Phix>p -e ?357+452 809 C:\Program Files (x86)\Phix>p -e "?357+452" 809
PHP
assuming you have the PHP CLI (command-line interface) installed, not just the web server plugin
$ php -r 'echo "Hello\n";'
Hello
PicoLisp
$ picolisp -'prinl "Hello world!"' -bye
Hello world!
Pike
$ pike -e 'write("Hello\n");'
Hello
PowerShell
> powershell -Command "Write-Host 'Hello'"
Hello
Processing
The command-line tool processing-java takes a sketch directory (not a file) and so a simple program cannot be piped in from the shell using process substitution. However, a long shell one-liner may write a sketch file to disk, then run it, so long as the folder name and the PDE file name match, e.g. /Tmp/Tmp.pde
In bash:
mkdir -p Tmp; echo "println(\"hello world\");" > Tmp/Tmp.pde; processing-java --sketch="`pwd`/Tmp" --run
- Output:
hello world
Prolog
Command-Line Options
$ swipl -g "writeln('hello world')." -t 'halt.'
hello world
$
$ gprolog --init-goal "write('goodbye'),nl,halt"
goodbye
$
$ yap -q -g "current_prolog_flag(dialect, D), writeln(D), halt"
yap
<<<
$ swipl -q <<< "current_prolog_flag(dialect,D), writeln(D), halt."
swi
$ yap -q <<< "current_prolog_flag(dialect,D), writeln(D), halt."
yap
Pipe
$ echo "current_prolog_flag(dialect,D), writeln(D), halt." | swipl -q
swi
$ echo "current_prolog_flag(dialect,D), writeln(D), halt." | yap -q
yap
PureBasic
Runs on Linux with(thanks to) bash. Path variables must be set as decribed in INSTALL.
$ echo 'messagerequester("Greetings","hello")' > "dib.pb" && ./pbcompiler dib.pb -e "dib" && ./dib
Python
Prints "Hello"
$ python -c 'print "Hello"'
Hello
Web server with CGI
The python CGIHTTPServer module is also an executable library that performs as a web server with CGI. to start enter:
python -m CGIHTTPServer
It returns with:
Serving HTTP on 0.0.0.0 port 8000 ...
Quackery
$ QUACK=$(mktemp); echo "say 'hello'" > $QUACK; quackery $QUACK; rm $QUACK
hello
Via Python 3
As Quackery is implemented as a Python 3 function, assuming that quackery.py is in the module search path:
$ python3 -c 'import quackery ; quackery.quackery(r""" say '\''hello'\'' cr """)'
hello
R
$ echo 'cat("Hello\n")' | R --slave
Hello
Alternatively, using the Rscript front-end,
$ Rscript -e 'cat("Hello\n")'
Hello
Racket
$ racket -e "(displayln \"Hello World\")"
Hello World
Raku
(formerly Perl 6)
$ raku -e 'say "Hello, world!"'
Hello, world!
REBOL
rebview -vswq --do "print {Hello!} quit"
Output:
Hello!
Retro
echo '\'hello s:put nl bye' | retro
REXX
Note: Regina REXX is the only version of REXX that supports this type of behavior (taking it's input from a console stream).
╔══════════════════════════════════════════════╗
║ ║
║ from the MS Window command line (cmd.exe) ║
║ ║
╚══════════════════════════════════════════════╝
echo do j=10 by 20 for 4; say right('hello',j); end | regina
output when entering the (above) from the (DOS) command line:
hello hello hello hello
Ring
see "Hello World!" + nl
Output:
Hello World!
RPL
RPL command-line interpreter allows to pass several instructions and values in one line, provided there is no program branch instruction among them. It is nevertheless possible to have a program structure in the line by bracketing it with ≪ ≫
, which means "this is an unnamed program". Adding the word EVAL
at the end will execute the code, otherwise it would stay at level 1 of the stack.
" World" "Hello" SWAP +
≪ " World" "Hello" SWAP + ≫ EVAL
This less trivial one-liner example calculates S(5), where S(n) is a Machin-like formula :
≪ 0 0 5 FOR k 2 k * 1 + → n ≪ -1 k ^ n / 4 5 n ^ / 239 n ^ INV - * + ≫ NEXT 4 * ≫ EVAL
- Output:
3: "Hello world" 2: "Hello world" 1: 3.14159265262
Ruby
From Unix:
$ ruby -e 'puts "Hello"'
Hello
$ jruby -e 'puts "Hello from JRuby"'
Hello from JRuby
$ rbx -e 'puts "Hello from Rubinius"'
Hello from Rubinius
Run BASIC
print shell$("echo hello world")
Rust
The following code leaves the file rust_out in the current directory (it does not delete it to avoid to call another shell/system dependent command/program). The current directory is not specified by ./ in every system...
$ echo 'fn main(){println!("Hello!")}' | rustc -;./rust_out
S-lang
slsh -e 'print("Hello, World")'
Or, in MSW cmd.exe:
slsh -e "print(\"Hello, World\")"
Note that print() is included w/slsh, but is not part of S-Lang itself.
Scala
C:\>scala -e "println(\"Hello\")"
Hello
PS C:\> scala -e 'println(\"Hello\")'
Hello
The escaping of quotes is required by Windows. On Unix and shown in the example on Windows PowerShell, one could just use single quotes around the code.
Scheme
guile -c '(display "Hello, world!\n")'
sed
The first non-option argument is interpreted as the script.
$ sed q /proc/meminfo
Alternatively, scripts can be passed via the -e
option.
$ sed -e 's/[[:space:]]*$//' -e '/./!d' file.txt
Shiny
shiny -e "say 'hi'"
Sidef
% sidef -E "say 'hello'"
Slate
./slate --eval "[inform: 'hello'] ensure: [exit: 0].".
SNOBOL4
Portable version
echo 'a output = "Hello, World!";end' | snobol4 -b
Bash version
snobol4 -b <<<'a output = "Hello, World!";end'
Tcl
This is an area where Tcl is lacking, though when shell one-liners are required a construct like this is typically used:
$ echo 'puts Hello' | tclsh
Hello
TXR
$ echo 123-456-7890 | txr -c '@a-@b-@c' -
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 -c
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.
The -e
(evaluate) and -p
(evaluate and print) options provide shell one-liner access to
TXR Lisp:
$ txr -p '(+ 2 2)'
4
$ txr -e '(mkdir "foo" #o777)'
$ ls -ld foo
drwxrwxr-x 2 kaz kaz 4096 Mar 4 23:36 foo
UNIX Shell
Explicit call of the shell, passing the shell command via the -c
option:
$ sh -c ls
$ sh -c "echo hello"
To invoke a specific shell like Bash, Korn Shell or Z Shell:
$ bash -c 'paste <(echo 1) <(echo 2)'
$ ksh -c 'let i=3+4; print $i'
$ zsh -c 'if [[ 5 -lt 6 ]] { echo ok };'
Shell scripts almost never use sh -c
, because there are various implicit ways whereby the shell command language evaluates a command in a subshell:
$ VAR=`echo hello` # obsolescent backtick notation
$ VAR=$(echo hello) # modern POSIX notation
$ (echo hello) # execute in another shell process, not in this one
There are more details about `echo hello`
and $(echo hello)
at Execute a system command#UNIX Shell.
C Shell
Run a C shell command from any shell:
$ csh -fc 'if (5 < 6) echo ok'
es
Run a command, in extensible shell, from any shell:
$ es -c 'if {test 5 -lt 6} {echo ok}'
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>,
$ fun --main=-[hello]- --show
hello
$ fun --main="power/2 32" --cast %n
4294967296
$ fun --m="..mp2str mpfr..pi 120" --c %s
'3.1415926535897932384626433832795028847E+00'
Vedit macro language
The following DOS command starts Vedit and displays a message. When the user presses any key, Vedit exits.
vpw -c'Get_Key("Hello!") exit'
Wart
echo "prn 34" |wart
Wren
echo 'System.print("Hello from Wren!")' > tmp.wren; wren tmp.wren
- Output:
Hello from Wren!
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
echo 'println("Hello World ",5+6)' | zkl
- Output:
zkl 1.12.9, released 2014-05-01 Hello World 11 Hello World 11
- Programming Tasks
- Programming environment operations
- 11l
- ACL2
- Ada
- Aikido
- Aime
- ALGOL 68
- AppleScript
- Arturo
- AWK
- BASIC
- ZX Spectrum Basic
- BaCon
- Bc
- Binary Lambda Calculus
- Bracmat
- Burlesque
- C
- C sharp
- Clojure
- CMake
- COBOL
- Common Lisp
- D
- Dc
- Delphi
- E
- Elixir
- Emacs Lisp
- Erlang
- F Sharp
- Factor
- Forth
- Fortran
- Free Pascal
- FreeBASIC
- Frink
- FutureBasic
- Gambas
- Gema
- Go
- Groovy
- Haskell
- Huginn
- Icon
- Unicon
- Insitux
- J
- Java
- JavaScript
- Jq
- Julia
- K
- Kotlin
- Lang
- Langur
- Lasso
- Liberty BASIC
- Lua
- Maple
- Mathematica
- Wolfram Language
- Min
- Nanoquery
- NetLogo
- NetRexx
- NewLISP
- Nim
- Objeck
- OCaml
- Octave
- Oforth
- OoRexx
- Oz
- PARI/GP
- Pascal
- Perl
- Phix
- PHP
- PicoLisp
- Pike
- PowerShell
- Processing
- Prolog
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- REBOL
- Retro
- REXX
- Ring
- RPL
- Ruby
- Run BASIC
- Rust
- S-lang
- Scala
- Scheme
- Sed
- Shiny
- Sidef
- Slate
- SNOBOL4
- Tcl
- TXR
- UNIX Shell
- C Shell
- Es
- Ursala
- Vedit macro language
- Wart
- Wren
- Zkl
- 6502 Assembly/Omit
- 68000 Assembly/Omit
- Z80 Assembly/Omit
- 8086 Assembly/Omit
- X86 Assembly/Omit
- ARM Assembly/Omit
- AutoHotkey/Omit
- C++/Omit
- Java/Omit
- Maxima/Omit
- Modula-3/Omit
- SAS/Omit
- Stata/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit
- Pages with too many expensive parser function calls