Useful use of cat(1)

(No "cat content" media here. Believe me, that I was more than attempted.)

2022-01-03 (see recent changes)

• embedded cat

    ( cmd; cat file; cmd ) | cmd 

  A generic method to mix both fixed/existing and dynamic output.

  Rather special example: This was useful for me on a Redhat Linux, where man(1) otherwise annoyingly
  would intersperse the output with headers and footers for a print version, which is rarely used, though...
  I tried: ( echo -e ".pl 1100i"; cat "$1"; echo ".pl \\n(nlu+10\n" ) | tbl | nroff -man

  Another example: If your bc(1) cannot be made to default to some decimal digits (Tom Rodman, in comp.unix.shell)

  _bc() { { echo "scale=4"; cat;}|bc -l;}
or bc() { { echo "scale=4"; cat;}|command bc -l;} if you like

  Another example via hackernews: a commandline "webserver":

  while :; do nc -l -p 8888 -c "printf 'HTTP/1.0 200 OK\r\n\r\n'; cat file"; echo request answered; done

• create text files without editor

    cat > textfile

  then typing plain text and closing with EOF (aka <ctrl-d>) was the quickest way for me to create text files on systems running in some rescue mode.

• how to transfer a huge amount of dynamically created data to a remote host, without temporarily saving it (e.g., no local space to save and use scp):

    tar cf - . | ssh remotehost 'cat > big.tar'

• actual concatenation, e.g., the opposite to split(1)

    cat xa* > c

  ...very related: a filter only reads from STDIN and you want to hand over several arguments.
  A redirection doesn't allow this. Examples: using tr, or converting tai64-timestamps in qmail-logs:

      cat log1 log2 log3 | tr '[:upper:]' '[:lower:]'
      cat log1 log2 log3 | tai64nlocal 

  ...related: falling back to STDIN if no arguments were supplied:
  (Chris F.A. Johnson, Richard L. Hamilton in c.u.s)

      cat -- "$@" | cmd
      cat ${1+"$@"} | cmd 

  The double dash safes from confusing cat with file arguments with leading dashes.
  But it's not strictly portable, and the expression after cat in the 2nd example is explained behind the link.

• easy "intuitive" switching on the command line between different types input
  Let's assume you are writing and debugging a new filter command.
  Imagine switching between these two variants several times:

      cat known_data | new_filter | ...
             command | new_filter | ...

  and compare with this, which avoids cat but means more typing:

      new_filter < known_data | ...
      command    | new_filter | ...

  This is just a matter of taste. But I frequently use the variant with cat exactly for this reason of convenience.

  PS: In some cases, you could put the redirection at the left side,
  but only with simple commands, not with compound commands like loops, grouped lists and subshells

      < known_data new_filter | ...
      command    | new_filter | ...

• ...related: automatically switch between fetching (and saving) a remote file, or using the local copy if it has already been fetched.
  Thanks to Janis Papanagnou for this useful example.

    if  [ -f remote-file-copy ]
      then  cat remote-file-copy
      else  curl address | tee remote-file-copy
    fi | further-pipeline-processing 

• here documents (force as-is output, if there are character sequences which are special to echo(1) if printf(1) is not available)

    cat<<EOF          cat<<EOF|cmd
    $VARIABLE         $VARIABLE
    EOF               EOF 

  Be careful if you put the above into a function: Traditional bourne shells and ksh up to 88g can have
  problems with the handling of the temporary files for storing the here-document.

  (Reminder from Janis Papanagnou for how to embed a here-doc in a pipeline added, for those who haven't seen it, yet)

• convert file content into arguments

    cmd `cat file`
    for i in `cat file`; do ...

  However, don't forget about possible problems with characters from IFS, most likely spaces.

  Janis Papanagnou reminds that a non-portable (even non-standard) way without cat,
  supported by some modern shells is

    cmd $(< file ) 

• largefile problems (Darren Dunham, in comp.unix.shell)

    cat file | cmd 

  A workaround for commands which have been compiled without largefile support but accept a pipe, e.g. compressing utilities.
  This is not purely academic; it rarely occured, especially in the transition period to well established large file support (for example gzip-1.2.4).

• ...related: select()

  select can be applied to pipes, sockets and ttys but not to regular files.
  A program pathologically using select could be used again. (academic, but well spotted by Dan Mercer in comp.unix.programmer)

• eliminate pager functionality, pagers (like more(1)/less(1)/pg(1)) usually test stdout/stderr for an interactive TTY,
  and also a simple way to force ps(1) to print long lines (complete arguments)

    script_or_command | cat

• conditionally empty filter

    if  condition
     then filter() { cat - ;}
     else filter() { some-filter-pipeline ;}
    fi 

  or, depending on the constraints, you might decide just in time,

    filter() {
    if  condition
     then cat -
     else some-filter-pipeline
    fi;} 

  This item originally saved the command to a variable, which would be unecessary difficult to use later.
  Thanks to Janis Papanagnou for the suggestion to use a function which makes it practically useful.

• ...related: pipeline status.

  If the last command in a pipeline would return an undesirable exit status, force the pipeline to return success with

    cmd1 | cmd2 | cat

  while an alternative is "{ cmd1 | cmd2 || true; }"

• Take yourself out of a pipeline

  A process can't be removed from a pipeline transparently.
  But it could replace itself with cat(1) as transparent connector.

          exec("/bin/cat");

  Mentioned by Warren Toomey on the THUS mailing list

• Using flags of cat(1), e.g.

    cat -v 

  However, this is controversial from the viewpoint of the unix tradition "do one thing and do it well".
  See the paper "Program Design in the Unix Environment" by Rob Pike and Brian Kernighan (local copy) for a rant about this. Also known as "cat -v considered harmful".