xargs treat multiple lines as arguments to single command invocation

Question

I am having a hard time print a seq of number, and then appending something at the end.

seq 1 3 | xargs -I {} echo {} 4

results in

1 4
2 4
3 4

However I want the result to be

1 2 3 4

Since I am learning xargs, I only want to use xargs to achieve this.

Answer 1

If you wanted to pass a certain number of lines as arguments to a single invocation of command via GNU xargs you would run something like:

multi-line cmd | xargs -d '\n' -n N command

i.e. use \n as delimiter and pass N lines¹ at a time to command which would be the equivalent of running

command line1 line2 ... lineN  

Now, xargs operates like this:

input | xargs [options] [command [initial-arguments]]

which means whatever arguments xargs adds to your command line when building it up, they will come after the initial-arguments of command so e.g.

multi-line cmd | xargs -d '\n' -n N command initial-args

will execute

command initial-args line1 line2 ... lineN  

which is why you won't be able to run

seq 1 3 | xargs -d '\n' -n 3 echo 4

and get the expected output because 4 will be considered as initial-argument and the end result will be

4 1 2 3

What you could do is invoke a shell to run command - that will enable you to position any additional arguments at the end:

seq 1 3 | xargs -d '\n' -n 3 sh -c 'echo "$@" 4' bang

1 2 3 4

---

What is bang in the above one-liner? sh -c syntax is

sh -c command_string [command_name [argument...]]

so 'echo "$@" 4' is the command_string ($@ expands to the positional parameters, in this case the ones added by xargs) and bang is the special parameter 0, the command_name (you can use any name e.g. sh) Worth reading: Why $0 is not a positional parameter?

---

Note that my post pertains to GNU xargs and its exclusive -d switch. Alternatively, you could do it in shell, saving the output lines into an array and passing its elements as arguments to command before any additional arguments, so
e.g. with bash

readarray -t args < <(multi-line cmd)
command "${args[@]}" additional-arg(s)

or with zsh

args=("${(@f)$(multi-line cmd)}")
command "${args[@]}" additional-arg(s)

---

^{1: assuming those N lines fall within ARG_MAX limits}

Answer 2

Changing some lines into a single line is done with paste -s.

In this case, you want to change four lines into a single line. The four lines are created with seq 1 3; echo 4:

$ seq 1 3; echo 4
1
2
3
4

Pass these through paste -d ' ' -s - to convert them into a single line, delimiting each original line with a space character:

$ { seq 1 3; echo 4; } | paste -d ' ' -s -
1 2 3 4

You could pass the lines through tr '\n' ' ' instead of through paste -s, but this would also replace the final newline character with a space (the one after 4), which is probably not what you want to do.

Answer 3

On BSDs, that's what the -J option is for:

$ seq 3 | xargs -J {} echo {} 4
1 2 3 4

In any case, xargs will still call the command multiple times if the list of arguments is so big that it won't fit within the execve() limit.

With other xargs implementations, as already said you can get sh to reorder the arguments:

$ seq 3 | xargs sh -c 'echo "$@" 4' sh
1 2 3 4

With xargs implementations that don't support the -r option, you can also leverage sh to check that at least one argument was passed:

cmd1 | xargs sh -c '[ "$#" -eq 0 ] || exec cmd2 "$@" additional args' sh

Note the exec that saves a fork in shell implementations that don't do that optimisation automatically. For builtin commands such as echo, in some sh implementations such as bash, using exec causes the external command (if available) to be called instead of the builtin one, making it behave more like when sh is not used (xargs cmd2).

Answer 4

The xargs part is fine. The seq can take a separator like so

seq -s ' ' 1 3 | xargs -I {} echo {} 4