How to make xargs append trailing arguments with -n? - xargs

Question

xargs is good at inserting initial arguments:
seq 0 10 | xargs -n 3 echo foo
produces this output:
foo 0 1 2
foo 3 4 5
foo 6 7 8
foo 9 10
What about when I also want trailing arguments?
That is, what command:
seq 0 10 | xargs -n 3 <WHAT GOES HERE?>
will produce the following desired output:
foo 0 1 2 bar
foo 3 4 5 bar
foo 6 7 8 bar
foo 9 10 bar
I tried the following:
seq 0 10 | xargs -n 3 -I {} echo foo {} bar
which is almost right, except that it apparently forces 1 item per command line, which isn't what I want:
foo 0 bar
foo 1 bar
foo 2 bar
foo 3 bar
foo 4 bar
foo 5 bar
foo 6 bar
foo 7 bar
foo 8 bar
foo 9 bar
foo 10 bar

Answer 1

Use the -i parameter of xargs such as:
ls -1 | xargs -t -i echo "Found {} file"
Note that the -t is only there to show the command that will be issued. When running live, leave off the -t parameter.
The {} is replaced by the actual argument. Note, that this does mean each command is run only once per file. Not as a group of files. If you need to use a different replace string, specify it after the -i
ls -1 | xargs -t -i[] xargs echo "Found []{} file"
Would keep {} after the filename which is now replaced on the occurance of []
To achieve desired output
Create a script file called runme.sh
#!/bin/sh
echo "foo $# bar"
Make sure to chmod +X and then use
seq 0 10 | xargs -n 3 ./runme.sh
This would produce
foo tests tree.php user_admin.php bar
foo user_domains.php user_group_admin.php utilities.php bar
foo vdef.php bar

Answer 2

After figuring this out with a head-start from #netniV's answer,
I now see that the man page actually contains an example
showing how to do it:
xargs sh -c 'emacs "$#" < /dev/tty' emacs
Launches the minimum number of copies of Emacs needed, one after the
other, to edit the files listed on xargs' standard input. This example
achieves the same effect as BSD's -o option, but in a more flexible and portable way.
And the wikipedia page shows a similar technique, with an explanation of the dummy arg at the end:
Another way to achieve a similar effect is to use a shell as the launched command, and deal with the complexity in that shell, for
example:
$ mkdir ~/backups
$ find /path -type f -name '*~' -print0 | xargs -0 bash -c 'for filename; do cp -a "$filename" ~/backups; done' bash
The word bash at the end of the line is interpreted by bash -c as special parameter $0. If the word bash weren't present, the name of
the first matched file would be assigned to $0 and the file wouldn't
be copied to ~/backups. Any word can be used instead of bash, but
since $0 usually expands to the name of the shell or shell script
being executed, bash is a good choice.
So, here's how to do it:
seq 0 10 | xargs -n 3 sh -c 'echo foo "$#" bar' some_dummy_string
The output is as desired:
foo 0 1 2 bar
foo 3 4 5 bar
foo 6 7 8 bar
foo 9 10 bar