Shell one-liner: Difference between revisions
(deleted incorrect examples as promised (belong to second category I listed on talk); changed <pre> to <lang> which seems to format spaces better) |
m (Tidy up formatting) |
||
Line 9: | Line 9: | ||
=={{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}} |
||
<lang>$ a68g -e 'print(("Hello",new line))'</lang> |
<lang bash>$ a68g -e 'print(("Hello",new line))'</lang> |
||
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: |
||
<lang>code='print(("Hello", new line))' |
<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 && |
||
Line 24: | Line 24: | ||
=={{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. |
||
⚫ | |||
⚫ | |||
A more "complex" and "real" example: |
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) |
''Select'' field 2 and 4 of lines matching the regular expression <tt>/IN/</tt> (i.e. where IN appears) |
||
=={{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: |
||
<lang bash>echo 'print "foo"'|basic</lang> |
<lang bash>echo 'print "foo"'|basic</lang> |
||
Line 65: | Line 61: | ||
=={{header|C}}== |
=={{header|C}}== |
||
{{works with|gcc}} |
{{works with|gcc}} |
||
The following code leaves the file <tt>a.out</tt> in the current directory (it does not |
The following code leaves the file <tt>a.out</tt> in the current directory (it does not |
||
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... |
||
< |
<lang bash>$ echo 'main() {printf("Hello\n");}' | gcc -w -x c -; ./a.out</lang> |
||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
Line 75: | Line 70: | ||
Requires PowerShell 2: |
Requires PowerShell 2: |
||
<lang>> Add-Type -TypeDefinition "public class HelloWorld { public static void SayHi() { System.Console.WriteLine(""Hi!""); } }" |
<lang powershell>> Add-Type -TypeDefinition "public class HelloWorld { public static void SayHi() { System.Console.WriteLine(""Hi!""); } }" |
||
> [HelloWorld]::SayHi() |
> [HelloWorld]::SayHi() |
||
Hi!</lang> |
Hi!</lang> |
||
Line 115: | Line 110: | ||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
<lang bash>emacs -batch -eval '(princ "Hello World!\n")' </lang> |
<lang bash>emacs -batch -eval '(princ "Hello World!\n")' </lang> |
||
Or another example that does something useful: indent a [[C]] source file: |
Or another example that does something useful: indent a [[C]] source file: |
||
<lang bash>emacs -batch sample.c --eval '(indent-region (point-min) (point-max) nil)' -f save-buffer</lang> |
<lang bash>emacs -batch sample.c --eval '(indent-region (point-min) (point-max) nil)' -f save-buffer</lang> |
||
=={{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). |
||
<lang>$ erl -noshell -eval 'io:format("hello~n").' -s erlang halt |
<lang bash>$ erl -noshell -eval 'io:format("hello~n").' -s erlang halt |
||
hello</lang> |
hello</lang> |
||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
<lang>> echo printfn "Hello from F#" | fsi --quiet |
<lang cmd>> echo printfn "Hello from F#" | fsi --quiet |
||
Hello from F#</lang> |
Hello from F#</lang> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
<lang>$ factor -run=none -e="USE: io \"hi\" print"</lang> |
<lang bash>$ factor -run=none -e="USE: io \"hi\" print"</lang> |
||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
{{works with|GNU Forth}} |
{{works with|GNU Forth}} |
||
<lang>$ gforth -e ".( Hello) cr bye" |
<lang bash>$ gforth -e ".( Hello) cr bye" |
||
Hello</lang> |
Hello</lang> |
||
=={{header|Gema}}== |
=={{header|Gema}}== |
||
<lang>$ gema -p '\B=Hello\n@end' |
<lang bash>$ gema -p '\B=Hello\n@end' |
||
Hello</lang> |
Hello</lang> |
||
Line 157: | Line 149: | ||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
{{works with|UNIX Shell}} |
{{works with|UNIX Shell}} |
||
<lang>$ groovysh -q "println 'Hello'" |
<lang bash>$ groovysh -q "println 'Hello'" |
||
Hello</lang> |
Hello</lang> |
||
{{works with|Windows Command Interpreter}} |
{{works with|Windows Command Interpreter}} |
||
<lang>C:\Users\user> groovysh -q "println 'Hello'" |
<lang cmd>C:\Users\user> groovysh -q "println 'Hello'" |
||
Hello</lang> |
Hello</lang> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
<lang>$ ghc -e 'putStrLn "Hello"' |
<lang bash>$ ghc -e 'putStrLn "Hello"' |
||
Hello</lang> |
Hello</lang> |
||
=={{header|J}}== |
=={{header|J}}== |
||
<lang>$ jconsole -js "exit echo 'Hello'" |
<lang bash>$ jconsole -js "exit echo 'Hello'" |
||
Hello</lang> |
Hello</lang> |
||
Line 179: | Line 171: | ||
<lang bash>$ echo 'public class X{public static void main(String[]args){' \ |
<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</lang> |
||
</lang> |
|||
A user can also enter this as one (very long) line: |
A user can also enter this as one (very long) line: |
||
Line 187: | Line 178: | ||
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]) |
||
<lang>C:\>echo public class X{public static void main(String[] args){System.out.println("Hello Java!");}}>X.java&&javac X.java&&java X |
<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!</lang> |
Hello Java!</lang> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
{{works with|SpiderMonkey}} |
{{works with|SpiderMonkey}} |
||
<lang>$ js -e 'print("hello")' |
<lang bash>$ js -e 'print("hello")' |
||
hello</lang> |
hello</lang> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
<lang>lua -e 'print "Hello World!"'</lang> |
<lang bash>lua -e 'print "Hello World!"'</lang> |
||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
{{works with|UNIX Shell}} |
{{works with|UNIX Shell}} |
||
<lang>./obc -run '"Hello"->PrintLine();' -dest hello.obe ; ./obr hello.obe</lang> |
<lang bash>./obc -run '"Hello"->PrintLine();' -dest hello.obe ; ./obr hello.obe</lang> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<lang>$ ocaml <(echo 'print_endline "Hello"') |
<lang bash>$ ocaml <(echo 'print_endline "Hello"') |
||
Hello</lang> |
Hello</lang> |
||
Line 213: | Line 204: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
<lang>$ perl -e 'print "Hello\n"' |
<lang bash>$ perl -e 'print "Hello\n"' |
||
Hello</lang> |
Hello</lang> |
||
Line 219: | Line 210: | ||
{{works with|Rakudo|#22 "Thousand Oaks"}} |
{{works with|Rakudo|#22 "Thousand Oaks"}} |
||
<lang>$ perl6 -e 'say "Hello, world!"' |
<lang bash>$ perl6 -e 'say "Hello, world!"' |
||
Hello, world!</lang> |
Hello, world!</lang> |
||
=={{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 |
||
<lang>$ php -r 'echo "Hello\n";' |
<lang bash>$ php -r 'echo "Hello\n";' |
||
Hello</lang> |
Hello</lang> |
||
Line 232: | Line 223: | ||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
<lang |
<lang bash>$ pike -e 'write("Hello\n");' |
||
Hello</lang> |
Hello</lang> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
<lang>> powershell -Command "Write-Host 'Hello'" |
<lang cmd>> powershell -Command "Write-Host 'Hello'" |
||
Hello</lang> |
Hello</lang> |
||
=={{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. |
||
<lang>$ echo 'messagerequester("Greetings","hello")' > "dib.pb" && ./pbcompiler dib.pb -e "dib" && ./dib</lang> |
<lang bash>$ echo 'messagerequester("Greetings","hello")' > "dib.pb" && ./pbcompiler dib.pb -e "dib" && ./dib</lang> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Prints "Hello"=== |
===Prints "Hello"=== |
||
<lang>$ python -c 'print "Hello"' |
<lang bash>$ python -c 'print "Hello"' |
||
Hello</lang> |
Hello</lang> |
||
Line 252: | Line 243: | ||
<lang bash>python -m CGIHTTPServer</lang> |
<lang bash>python -m CGIHTTPServer</lang> |
||
It returns with: |
It returns with: |
||
< |
<pre>Serving HTTP on 0.0.0.0 port 8000 ...</pre> |
||
=={{header|R}}== |
=={{header|R}}== |
||
<lang>$ echo 'cat("Hello\n")' | R --slave |
<lang bash>$ echo 'cat("Hello\n")' | R --slave |
||
Hello</lang> |
Hello</lang> |
||
Alternatively, using the Rscript front-end, |
Alternatively, using the Rscript front-end, |
||
⚫ | |||
⚫ | |||
Hello</lang> |
Hello</lang> |
||
Line 267: | Line 257: | ||
Output: |
Output: |
||
⚫ | |||
⚫ | |||
=={{header|Retro}}== |
=={{header|Retro}}== |
||
Line 275: | Line 264: | ||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
From [[Unix]]: |
From [[Unix]]: |
||
<lang bash>$ ruby -e 'puts "Hello"' |
<lang bash>$ ruby -e 'puts "Hello"' |
||
Hello</lang> |
Hello</lang> |
||
Line 290: | Line 278: | ||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
<lang>C:\>scala -e "println(\"Hello\")" |
<lang cmd>C:\>scala -e "println(\"Hello\")" |
||
Hello</lang> |
Hello</lang> |
||
The escaping of quotes is required by Windows. On Unix, one could just use single quotes around the code. In either case, any required libraries should have their JAR files pointed at by the environment variable CLASSPATH. |
The escaping of quotes is required by Windows. On Unix, one could just use single quotes around the code. In either case, any required libraries should have their JAR files pointed at by the environment variable CLASSPATH. |
||
Line 310: | Line 298: | ||
Bash version |
Bash version |
||
<lang snobol>snobol4 -b <<<'a output = "Hello, World!";end'</lang> |
<lang snobol>snobol4 -b <<<'a output = "Hello, World!";end'</lang> |
||
=={{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: |
||
<lang>$ echo 'puts Hello' | tclsh |
<lang bash>$ echo 'puts Hello' | tclsh |
||
Hello</lang> |
Hello</lang> |
||
(This apparent weakness is purposeful; it leaves a larger fraction of the space of possible arguments open to use by the script being executed.) |
(This apparent weakness is purposeful; it leaves a larger fraction of the space of possible arguments open to use by the script being executed.) |
||
Line 323: | Line 310: | ||
Invoking from the shell, a multi-line TXR query is passed using -c as a single argument. It invokes the shell command using bang notation in <code>@(next)</code>, collect its output and dumps the bindings: |
Invoking from the shell, a multi-line TXR query is passed using -c as a single argument. It invokes the shell command using bang notation in <code>@(next)</code>, collect its output and dumps the bindings: |
||
<lang>$ txr -c '@(next `!for x in 0 1 2 3 4; do echo $x; done`) |
<lang bash>$ txr -c '@(next `!for x in 0 1 2 3 4; do echo $x; done`) |
||
@(collect) |
@(collect) |
||
@X |
@X |
||
Line 335: | Line 322: | ||
{{works with|bash}} |
{{works with|bash}} |
||
If we eval the above command back into the shell, we create an array (if the shell supports array syntax). |
If we eval the above command back into the shell, we create an array (if the shell supports array syntax). |
||
⚫ | |||
⚫ | |||
@(collect) |
@(collect) |
||
@X |
@X |
||
Line 347: | Line 332: | ||
=={{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 bash>$ sh -c ls</lang> |
<lang bash>$ sh -c ls</lang> |
||
<lang bash>$ sh -c "echo hello"</lang> |
<lang bash>$ sh -c "echo hello"</lang> |
||
Line 374: | Line 356: | ||
=={{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>, |
|||
<lang>$ fun --main=-[hello]- --show |
<lang bash>$ fun --main=-[hello]- --show |
||
hello |
hello |
||
$ fun --main="power/2 32" --cast %n |
$ fun --main="power/2 32" --cast %n |
||
Line 388: | Line 366: | ||
=={{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. |
||
<lang>vpw -c'Get_Key("Hello!") exit'</lang> |
<lang cmd>vpw -c'Get_Key("Hello!") exit'</lang> |
||
{{omit from|Ada}} |
{{omit from|Ada}} |
Revision as of 12:33, 3 October 2011
You are encouraged to solve this task according to the task description, using any language you may know.
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.
Aikido
<lang aikido>echo 'println ("Hello")' | aikido</lang>
ALGOL 68
<lang bash>$ a68g -e 'print(("Hello",new line))'</lang> Output:
Hello
For an ELLA ALGOL 68 one-liner, merge these lines of shell code: <lang bash>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</lang> Output:
Hello
AWK
Maybe the most common way one can use awk is from the command line for one-liners, feeding the interpreter with an input. <lang bash>$ awk 'BEGIN { print "Hello"; }'</lang>
A more "complex" and "real" example: <lang bash>$ awk '/IN/ { print $2, $4; }' <input.txt</lang>
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: <lang bash>echo 'print "foo"'|basic</lang>
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): <lang dos>echo print "foo"|basic</lang>
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:
<lang zxbasic>PRINT "Hello World!"</lang>
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... <lang bash>$ echo 'main() {printf("Hello\n");}' | gcc -w -x c -; ./a.out</lang>
C#
Note: whilst small, this is more than one line.
Requires PowerShell 2: <lang powershell>> Add-Type -TypeDefinition "public class HelloWorld { public static void SayHi() { System.Console.WriteLine(""Hi!""); } }" > [HelloWorld]::SayHi() Hi!</lang>
Clojure
Note: whilst small, this is more than one line.
clj-env-dir comes with clojure-contrib.
<lang bash>$ clj-env-dir -e "(defn add2 [x] (inc (inc x))) (add2 40)"
- 'user/add2
42</lang>
CMake
This only works with Unix systems that have the device node /dev/stdin
.
<lang bash>echo 'message(STATUS "Goodbye, World!")' | cmake -P /dev/stdin</lang>
Common Lisp
Varies by implementation
<lang bash>sbcl --noinform --eval '(progn (princ "Hello") (terpri) (quit))'</lang>
<lang bash>clisp.exe -q -x "(progn (format t \"Hello from CLISP\") (quit))"</lang>
D
requires rdmd <lang d>rdmd --eval="writeln(q{Hello World!})"</lang>
Hello World!
E
<lang bash>rune --src.e 'println("Hello")'</lang>
The --src
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()'</lang>
Emacs Lisp
<lang bash>emacs -batch -eval '(princ "Hello World!\n")' </lang> Or another example that does something useful: indent a C source file: <lang bash>emacs -batch sample.c --eval '(indent-region (point-min) (point-max) nil)' -f save-buffer</lang>
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). <lang bash>$ erl -noshell -eval 'io:format("hello~n").' -s erlang halt hello</lang>
F#
<lang cmd>> echo printfn "Hello from F#" | fsi --quiet Hello from F#</lang>
Factor
<lang bash>$ factor -run=none -e="USE: io \"hi\" print"</lang>
Forth
<lang bash>$ gforth -e ".( Hello) cr bye" Hello</lang>
Gema
<lang bash>$ gema -p '\B=Hello\n@end' Hello</lang>
Go
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, <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 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:
hllowrld
Groovy
<lang bash>$ groovysh -q "println 'Hello'" Hello</lang>
<lang cmd>C:\Users\user> groovysh -q "println 'Hello'" Hello</lang>
Haskell
<lang bash>$ ghc -e 'putStrLn "Hello"' Hello</lang>
J
<lang bash>$ jconsole -js "exit echo 'Hello'" Hello</lang>
That said, note that J interpreters can themselves be thought of as command shells.
Java
These three lines work with Bourne Shell or C Shell on Unix/Linux/MacOSX/Windows+cygwin
<lang bash>$ echo 'public class X{public static void main(String[]args){' \ > 'System.out.println("Hello Java!");}}' >X.java $ javac X.java && java X</lang>
A user can also enter this as one (very long) line:
<lang bash>$ echo 'public class X{public static void main(String[]args){System.out.println("Hello Java!");}}'>X.java;javac X.java&&java X</lang>
Works with cmd.exe on Windows (tested on Microsoft Windows XP [Version 5.1.2600]) <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!</lang>
JavaScript
<lang bash>$ js -e 'print("hello")' hello</lang>
Lua
<lang bash>lua -e 'print "Hello World!"'</lang>
Objeck
<lang bash>./obc -run '"Hello"->PrintLine();' -dest hello.obe ; ./obr hello.obe</lang>
OCaml
<lang bash>$ ocaml <(echo 'print_endline "Hello"') Hello</lang>
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: <lang bash>echo >tmp.oz "{System.show hello}"; ozc -l System -e tmp.oz hello</lang>
With -l System
we make the System module available so that we can print something.
Perl
<lang bash>$ perl -e 'print "Hello\n"' Hello</lang>
Perl 6
<lang bash>$ perl6 -e 'say "Hello, world!"' Hello, world!</lang>
PHP
assuming you have the PHP CLI (command-line interface) installed, not just the web server plugin <lang bash>$ php -r 'echo "Hello\n";' Hello</lang>
PicoLisp
<lang PicoLisp>$ picolisp -'prinl "Hello world!"' -bye Hello world!</lang>
Pike
<lang bash>$ pike -e 'write("Hello\n");' Hello</lang>
PowerShell
<lang cmd>> powershell -Command "Write-Host 'Hello'" Hello</lang>
PureBasic
Runs on Linux with(thanks to) bash. Path variables must be set as decribed in INSTALL. <lang bash>$ echo 'messagerequester("Greetings","hello")' > "dib.pb" && ./pbcompiler dib.pb -e "dib" && ./dib</lang>
Python
Prints "Hello"
<lang bash>$ python -c 'print "Hello"' Hello</lang>
Web server with CGI
The python CGIHTTPServer module is also an executable library that performs as a web server with CGI. to start enter: <lang bash>python -m CGIHTTPServer</lang> It returns with:
Serving HTTP on 0.0.0.0 port 8000 ...
R
<lang bash>$ echo 'cat("Hello\n")' | R --slave Hello</lang>
Alternatively, using the Rscript front-end, <lang bash>$ Rscript -e 'cat("Hello\n")' Hello</lang>
REBOL
<lang bash>rebview -vswq --do "print {Hello!} quit" </lang>
Output:
Hello!
Retro
<lang Retro>echo '"hello\n" puts bye' | ./retro</lang>
Ruby
From Unix: <lang bash>$ ruby -e 'puts "Hello"' Hello</lang>
From Unix, to other implementations of Ruby:
<lang bash>$ jruby -rjava -e'java.lang.System.out.println("Hello from JRuby")' Hello from JRuby</lang>
<lang bash>$ rbx -ractor -e'Actor.spawn {puts "Hello from Rubinius"}' Hello from Rubinius</lang>
Scala
<lang cmd>C:\>scala -e "println(\"Hello\")" Hello</lang> The escaping of quotes is required by Windows. On Unix, one could just use single quotes around the code. In either case, any required libraries should have their JAR files pointed at by the environment variable CLASSPATH.
Scheme
<lang scheme>guile -c '(display "Hello, world!\n")'</lang>
Shiny
<lang shiny>shiny -e "say 'hi'" </lang>
Slate
<lang slate>./slate --eval "[inform: 'hello'] ensure: [exit: 0].".</lang>
SNOBOL4
Portable version <lang snobol>echo 'a output = "Hello, World!";end' | snobol4 -b</lang>
Bash version <lang snobol>snobol4 -b <<<'a output = "Hello, World!";end'</lang>
Tcl
This is an area where Tcl is lacking, though when shell one-liners are required a construct like this is typically used: <lang bash>$ echo 'puts Hello' | tclsh Hello</lang> (This apparent weakness is purposeful; it leaves a larger fraction of the space of possible arguments open to use by the script being executed.)
TXR
Note: whilst small, this is more than one line.
Invoking from the shell, a multi-line TXR query is passed using -c as a single argument. It invokes the shell command using bang notation in @(next)
, collect its output and dumps the bindings:
<lang bash>$ txr -c '@(next `!for x in 0 1 2 3 4; do echo $x; done`) @(collect) @X @(end) ' X[0]="0" X[1]="1" X[2]="2" X[3]="3" X[4]="4"</lang>
If we eval the above command back into the shell, we create an array (if the shell supports array syntax). <lang bash>$ eval $(txr -c '@(next `!for x in 0 1 2 3 4; do echo $x; done`) @(collect) @X @(end) ') $ echo ${X[*]} 0 1 2 3 4</lang>
UNIX Shell
Explicit call of the shell, passing the shell command via the -c
option:
<lang bash>$ sh -c ls</lang>
<lang bash>$ sh -c "echo hello"</lang>
To invoke a specific shell like Bash, Korn Shell or Z Shell:
<lang bash>$ bash -c 'paste <(echo 1) <(echo 2)' $ ksh -c 'let i=3+4; print $i' $ zsh -c 'if 5 -lt 6 { echo ok };'</lang>
Shell scripts almost never use sh -c
, because there are various implicit ways whereby the shell command language evaluates a command in a subshell:
<lang bash>$ VAR=`echo hello` # obsolescent backtick notation $ VAR=$(echo hello) # modern POSIX notation $ (echo hello) # execute in another shell process, not in this one</lang>
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:
<lang bash>$ csh -fc 'if (5 < 6) echo ok'</lang>
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>,
<lang bash>$ fun --main=-[hello]- --show hello $ fun --main="power/2 32" --cast %n 4294967296 $ fun --m="..mp2str mpfr..pi 120" --c %s '3.1415926535897932384626433832795028847E+00'</lang>
Vedit macro language
The following DOS command starts Vedit and displays a message. When the user presses any key, Vedit exits. <lang cmd>vpw -c'Get_Key("Hello!") exit'</lang>
- Programming Tasks
- Programming environment operations
- Aikido
- ALGOL 68
- AWK
- BASIC
- ZX Spectrum Basic
- C
- C sharp
- Clojure
- CMake
- Common Lisp
- D
- E
- Emacs Lisp
- Erlang
- F Sharp
- Factor
- Forth
- Gema
- Go
- Groovy
- Haskell
- J
- Java
- JavaScript
- Lua
- Objeck
- OCaml
- Oz
- Perl
- Perl 6
- PHP
- PicoLisp
- Pike
- PowerShell
- PureBasic
- Python
- R
- REBOL
- Retro
- Ruby
- Scala
- Scheme
- Shiny
- Slate
- SNOBOL4
- Tcl
- TXR
- UNIX Shell
- C Shell
- Ursala
- Vedit macro language
- Ada/Omit
- Go/Omit
- Java/Omit
- Modula-3/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit