Shell one-liner: Difference between revisions

{{task|Programming environment operations}}

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.

 

=={{header|Aikido}}==

 

=={{header|Aime}}==

 

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

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

Output:

<pre>Hello</pre>

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

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

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

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

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

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

Output:

<pre>Hello</pre>

 

=={{header|AWK}}==

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

 

A more "complex" and "real" example:

 

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

=={{header|BASIC}}==

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

 

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

 

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

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.

 

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

 

 

=={{header|C}}==

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

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

 

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

 

Requires PowerShell 2:

> [HelloWorld]::SayHi()

 

=={{header|Clojure}}==

clj-env-dir comes with clojure-contrib.

 

#'user/add2

 

=={{header|CMake}}==

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

 

 

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

 

{{works with|SBCL}}

{{works with|CLISP}}

 

=={{header|D}}==

{{works with|D|2}}

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

<pre>Hello World!</pre>

 

=={{header|E}}==

 

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

 

 

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

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

 

=={{header|Erlang}}==

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

 

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

 

=={{header|Factor}}==

 

=={{header|Forth}}==

{{works with|GNU Forth}}

 

=={{header|Gema}}==

 

=={{header|Go}}==

<pre>

</pre>

 

=={{header|Groovy}}==

{{works with|UNIX Shell}}

 

{{works with|Windows Command Interpreter}}

 

=={{header|Haskell}}==

 

=={{header|J}}==

 

 

=={{header|Java}}==

 

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

 

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

 

 

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

 

=={{header|JavaScript}}==

{{works with|SpiderMonkey}}

 

=={{header|K}}==

{{works with|Kona}}

 

 

=={{header|NewLISP}}==

 

=={{header|Objeck}}==

{{works with|UNIX Shell}}

 

=={{header|OCaml}}==

 

=={{header|Oz}}==

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

 

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

 

 

=={{header|PHP}}==

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

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

 

=={{header|PowerShell}}==

 

=={{header|PureBasic}}==

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

 

=={{header|Python}}==

===Prints "Hello"===

 

===Web server with CGI===

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

It returns with:

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

 

=={{header|R}}==

 

Alternatively, using the Rscript front-end,

 

=={{header|REBOL}}==

 

Output:

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

hello

hello

hello

hello

</pre>

 

=={{header|Ruby}}==

From [[Unix]]:

 

{{works with|JRuby}}

 

{{works with|Rubinius}}

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

{{works with|Guile}}

 

=={{header|Shiny}}==

 

=={{header|Slate}}==

 

=={{header|SNOBOL4}}==

Portable version

 

Bash version

 

=={{header|Tcl}}==

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

 

=={{header|TXR}}==

 

a="123"

b="456"

c="7890"

 

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

 

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

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

 

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

 

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

 

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

 

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

 

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

Run a C shell command from any shell:

 

 

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

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

 

 

=={{header|Ursala}}==

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

 

hello

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

4294967296

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

 

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

The following DOS command starts Vedit and displays a message.

When the user presses any key, Vedit exits.

 

{{omit from|AutoHotkey|No interactive shell}}

{{omit from|Modula-3}}

{{omit from|TI-83 BASIC}}

{{omit from|TI-89 BASIC}} <!-- Does not have an external OS/command processor. -->