Run two commands on one argument (without scripting)

Question

How can I perform two commands on one input, without typing that input twice?

For example, the stat command tells a lot about a file, but doesn't indicate its file type:

stat fileName

The file command, tells what type a file is:

file fileName

You can perform this in one line this way:

stat fileName ; file fileName

However, you have to type the fileName twice.

How can you execute both commands on the same input (without typing the input or a variable of the input twice)?

In Linux, I know how to pipe outputs, but how do you pipe inputs?

Answer 1

Probably going to get my knuckles rapped for this, here's a hacky combination of bash brace expansion and eval that seems to do the trick

eval {stat,file}" fileName;"

Answer 2

With zsh, you can use anonymous functions:

(){stat $1; file $1} filename

With es lambdas:

@{stat $1; file $1} filename

You could also do:

{ stat -; file -;} < filename

(doing the stat first as the file will update the access time).

I'd do:

f=filename; stat "$f"; file "$f"

though, that's what variables are for.

Answer 3

Here is another way:

$ stat filename && file "$_"

Example:

$ stat /usr/bin/yum && file "$_"
  File: ‘/usr/bin/yum’
  Size: 801         Blocks: 8          IO Block: 4096   regular file
Device: 804h/2052d  Inode: 1189124     Links: 1
Access: (0755/-rwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Context: system_u:object_r:rpm_exec_t:s0
Access: 2014-06-11 22:55:53.783586098 +0700
Modify: 2014-05-22 16:49:35.000000000 +0700
Change: 2014-06-11 19:15:30.047017844 +0700
 Birth: -
/usr/bin/yum: Python script, ASCII text executable

That works in bash and zsh. That also works in mksh and dash but only when interactive. In AT&T ksh, that only works when the file "$_" is on a different line from the stat one.

Answer 4

All of these answers seem like scripting to me, to a greater or lesser extent. For a solution that really involves no scripting, and assumes that you're sitting at the keyboard typing into a shell, you can try:

stat somefile Enter
file Esc_   Enter

In bash, zsh, and ksh at least, in both vi and emacs modes, pressing Escape and then underscore inserts the last word from the previous line into the edit buffer for the current line.

Or, you can use history substitution:

stat somefile Enter
file !$ Enter

In bash, zsh, csh, tcsh, and most other shells, !$ is replaced with the last word of the previous command line when the current command line is parsed.

Answer 5

This answer is similar to a couple of the others:

stat filename  &&  file !#:1

Unlike the other answers, which automatically repeat the last argument from the previous command, this one requires you to count:

ls -ld filename  &&  file !#:2

Unlike some of the other answers, this does not require quotes:

stat "useless cat"  &&  file !#:1

or

echo Sometimes a '$cigar' is just a !#:3.

Answer 6

The way I have found to do this reasonably simply is using xargs, it takes a file / pipe and converts its contents into a program arguments . This can be combined with tee which splits a stream and sends it to two or more programs, In your case you need:

echo filename | tee >(xargs stat) >(xargs file) | cat

Unlike many of the other answers this will work in bash and most other shells under Linux. I shall suggest this is a good use case of a variable but if you absolutely cannot use one this is the best way to do it only with pipes and simple utilities (assuming you do not have a particularly fancy shell).

Additionally you can do this for any number of programs by simply adding them in the same manner as these two after the tee.

EDIT

As suggested in the comments there are a couple of flaws in this answer, the first is the potential for output interlacing. This can be fixed as so:

echo filename | tee >(xargs stat) >(( wait $!; xargs file )) | cat

This will force the commands to run in turn and output will never be interlaced.

The second issue is avoiding process substitution which is not available in some shells, this can be achieved by using tpipe instead of tee as so:

echo filename | tpipe 'xargs stat' | ( wait $!; xargs file )

This should be portable to nearly any shell (I hope) and solves the issues in the other commend, however I am writing this last one from memory as my current system does not have tpipe available.

Answer 7

This is similar to a couple of the other answers, but is more portable than this one and much simpler than this one:

sh -c 'stat "$0"; file "$0"' filename

or

sh -c 'stat "$1"; file "$1"' sh filename

in which sh is assigned to $0.  Although it is three characters more to type, this (second) form is preferable because that $0 is the name you give to that inline script.  It's used, for instance, in error messages by the shell for that script, like when file or stat can't be found or can't be executed for any reason.

---

If you want to do

stat filename1 filename2 filename3 …; file filename1 filename2 filename3 …

for an arbitrary number of files, do

sh -c 'stat "$@"; file "$@"' sh filename1 filename2 filename3 …

which works because "$@" is equivalent to "$1" "$2" "$3" ….

Answer 8

I think you are asking a wrong question, at least for what you are trying to do. stat and file commands are taking parameters which is the name of a file and not the content of it. It is later on the command which does reading of the file identified by the name you are specifying.

A pipe is supposed to have two ends, one used as input and another one as output and this make sense as you might need to do different processing along the way with different tools until you get needed result. Saying that you know how to pipe outputs but don't know how to pipe inputs is not correct in principle.

In your case you don't need a pipe at all since you have to provide the input in a form of a file name. And even if those tools (stat and file) would read stdin, pipe is not relevant here again as input should not be altered by any of the tool when it gets to the second one.

Answer 9

There are a few different references to 'input' here, so I will give a few scenarios with understanding it in mind first. For your quick answer to the question in shortest form:

stat testfile < <($1)> outputfile

The above will perform a stat on testfile, take (redirect) it's STDOUT and include that into the next special function (the <() part) then output the final results of whatever that was, into a new file (outputfile). The file is called, then referenced with bash built-ins ($1 each time after, until you begin a new set of instructions).

Your question is great, and there are several answers and ways to do this, but it does indeed change with what you are doing specifically.

For instance, you can loop that as well, which is quite handy. A common usage of this is, in psuedo-code mindset, is:

run program < <($output_from_program)> my_own.log

Taking that in and expanding on that knowledge allows you to create things such as:

ls -A; (while read line; do printf "\e[1;31mFound a file\e[0m: $line\n"; done) < <(/bin/grep thatword * | /usr/bin/tee -a files_that_matched_thatword)

This will perform a simple ls -A on your current directory, then tell while to loop through each result from the ls -A to (and here's where it's tricky!) grep "thatword" in each of those results, and only perform the previous printf (in red) if it actually found a file with "thatword" in it. It will also log the results of the grep into a new text file, files_that_matched_thatword.

Example output:

ls -A; (while read line; do printf "\e[1;31mFound a file\e[0m: $line\n"; done) < <(/bin/grep thatword * | /usr/bin/tee -a files_that_matched_thatword)

index.html

All of that simply printed the ls -A result, nothing special. Add something for it to grep this time:

echo "thatword" >> newfile

Now re-run it:

ls -A; (while read line; do printf "\e[1;31mFound a file\e[0m: $line\n"; done) < <(/bin/grep thatword * | /usr/bin/tee -a files_that_matched_thatword)

files_that_matched_thatword  index.html  newfile

Found a file: newfile:thatword

While perhaps a more exhausting answer than you're looking for at present, I believe keeping handy notes like this around will benefit you much more in future endeavours.

Answer 10

This should work for all file names in the current directory.

sh -c "$(printf 'stat -- "$1";file -- "$1";shift%.0b\n' *)" -- *