Execution of external programs

Suppose you need to do something more complicated and use the file name in the file variable as the command argument. You can use $ for interpolation in the same way as in a string literal (see the section Lines).

When running external programs through the shell, the following problem often occurs: if the file name contains characters that are special to the shell, they may cause undesirable behavior. Let’s say, for example, that you need to sort the contents not of the /etc/passwd file, but of the /Volumes/External HD/data.csv file. Let’s try to do this.

How was the file name enclosed in quotation marks? Julia knows that the file variable is intended for interpolation as the only argument, so this word is enclosed in quotation marks. In fact, this is not entirely accurate: the shell never interprets the value of the file variable, so there is no need for actual quotation marks. The quotation marks are inserted only for presentation to the user. This will work even when interpolating the value as part of a shell word.

As you can see, the space in the path variable is escaped accordingly. But what if you need to interpolate a few words? In this case, just use an array (or any other iterable container).

If you interpolate the array as part of a shell word, Julia emulates argument generation. {a,b,c} shells.

Moreover, when interpolating multiple arrays into a single word, the shell’s behavior of forming a Cartesian product is emulated.

Since you can interpolate literal arrays, this generative functionality can be used without creating temporary array objects.

A developer inevitably wants to write complex commands, so you should consider using quotation marks. Here is a simple example of one-line Perl code in a shell prompt.

A Perl expression should be enclosed in single quotes for two reasons: so that spaces do not split the expression into multiple shell words, and so that using Perl variables such as $| (yes, this is the name of a variable in Perl) does not result in interpolation. In other cases, you can use double quotes to make the interpolation happen.

In general, the syntax of Julia’s back apostrophes is carefully thought out, so you can simply cut and paste shell commands as they are into back apostrophes, and they will work: escaping, quoting, and interpolation will function the same way as in the shell. The only difference is that the interpolation is integrated and takes into account Julia’s idea of what is a single string value and what is a container for multiple values. Let’s try to run the two examples above in Julia.

The results are identical, and Julia’s interpolation behavior mimics the behavior of the shell, with some improvements related to the fact that Julia supports iterable first-class objects, while most shells use strings separated by a certain space for this, which creates ambiguity. When trying to transfer shell commands to Julia, try cutting and pasting them first. Since Julia displays commands before executing them, you can simply study their interpretation without any negative consequences.

Shell metacharacters such as |, &, and > must be enclosed in quotation marks (or escaped) inside Julia back apostrophes.

This expression invokes the echo command with three words as arguments: hello, | and sort'. The result is a single line: `hello | sort'. Then how can we build a pipeline? Instead of using `|" inside the reverse apostrophes, a pipeline is used (`pipeline).

The output of the echo command is passed to the sort command. Of course, this is not very interesting, since you only need to sort one row, but you can perform more remarkable actions.

The five highest user ID values in the UNIX system are displayed here. The cut, sort, and tail commands are generated as direct children of the current `julia' process without an intermediate shell process. Julia independently performs the work of configuring the transfer and connection of file descriptors, which is usually done by the shell. Because Julia does this on its own, it provides maximum control and can implement things that shells cannot.

Julia can execute multiple commands in parallel.

The order of output here is non-deterministic, since two echo processes run almost simultaneously and compete for the right to write to the descriptor first. 'stdout`, which is common to them and the parent process `julia'. Julia allows you to transfer the output from both of these processes to another program.

From the point of view of UNIX pipelining, what happens here is that one UNIX transfer channel object is created and written by both echo processes, and the other end of the transfer channel is read by the sort command.

I/O redirection can be performed by passing named arguments 'stdin`, stdout and stderr to the `pipeline' function.

The syntax of the reverse apostrophe creates an object of the type Cmd. Such an object can also be built directly from an existing Cmd object or a list of arguments.

This allows you to specify several aspects of the Cmd runtime using named arguments. For example, the keyword dir controls the working directory `Cmd'.

And the keyword env allows you to set runtime variables.

For a list of additional named arguments, see the description Cmd. Commands setenv and 'addenv` are used to replace or add to the Cmd runtime variables, respectively.