¿Cuál es la forma portátil (POSIX) de lograr la sustitución del proceso?

Algunos shells, como bash, admiten la sustitución de procesos, que es una forma de presentar la salida del proceso como un archivo, como este:

$ diff <(sort file1) <(sort file2)

Sin embargo, esta construcción no es POSIX y, por lo tanto, no es portátil. ¿Cómo se puede lograr la sustitución del proceso de una manera amigable con POSIX (es decir, una que funcione /bin/sh) ?

nota: la pregunta no es cómo diferenciar dos archivos ordenados, ¡eso es solo un ejemplo artificial para demostrar la sustitución del proceso !

Esa característica fue introducida por ksh(documentada por primera vez en ksh86) y estaba haciendo uso de la /dev/fd/ncaracterística (agregada de forma independiente en algunos sistemas BSD y AT&T anteriormente). En kshy hasta ksh93u, no funcionaría a menos que su sistema tuviera soporte para / dev / fd / n. zsh, bash y ksh93u+superiores pueden hacer uso de canalizaciones con nombre temporales (canalizaciones con nombre agregadas en SysIII, creo) donde / dev / fd / n no están disponibles.

En los sistemas donde está disponible (POSIX no los especifica), puede realizar la sustitución del proceso usted mismo ( ) con:/dev/fd/ndiff <(cmd1) <(cmd2)

{
  cmd1 4<&- | {
    # in here fd 3 points to the reading end of the pipe
    # from cmd1, while fd 0 has been restored from the original
    # stdin (saved on fd 4, now closed as no longer needed)

    cmd2 3<&- | diff /dev/fd/3 -

  } 3<&0 <&4 4<&- # restore the original stdin for cmd2

} 4<&0 # save a copy of stdin for cmd2

Sin embargo, eso no funciona ksh93en Linux, ya que las tuberías de shell se implementan con pares de sockets en lugar de tuberías y la apertura /dev/fd/3donde fd 3 apunta a un socket no funciona en Linux.

Aunque POSIX no especifica . Sí especifica tuberías con nombre. Las canalizaciones con nombre funcionan como las canalizaciones normales, excepto que puede acceder a ellas desde el sistema de archivos. El problema aquí es que debe crear archivos temporales y limpiar después, lo cual es difícil de hacer de manera confiable, especialmente teniendo en cuenta que POSIX no tiene un mecanismo estándar (como el que se encuentra en algunos sistemas) para crear archivos o directorios temporales, y hacer el manejo de la señal de manera portátil (para limpiar al colgar o matar) también es difícil de hacer de forma portátil./dev/fd/nmktemp -d

Podrías hacer algo como:

tmpfifo() (
  n=0
  until
    fifo=$1.$$.$n
    mkfifo -m 600 -- "$fifo" 2> /dev/null
  do
    n=$((n + 1))
    # give up after 20 attempts as it could be a permanent condition
    # that prevents us from creating fifos. You'd need to raise that
    # limit if you intend to create (and use at the same time)
    # more than 20 fifos in your script
    [ "$n" -lt 20 ] || exit 1
  done
  printf '%s\n' "$fifo"
)

cleanup() { rm -f -- "$fifo"; }
fifo=$(tmpfifo /tmp/fifo) || exit

cmd2 > "$fifo" & cmd1 | diff - "$fifo"
rm -f -- "$fifo"

(no cuidar el manejo de la señal aquí).

Si es necesario para evitar la variable perdida en lo útil cmd | while read A B C, en lugar de:

VAR="before"
while read A B C 
do
  VAR="$A $VAR"
done < <(cmd)
echo "$VAR"

puedes usar:

VAR="before"
while read A B C 
do
  VAR="$A $VAR"
done << EndOfText
`cmd`
EndOfText
echo "$VAR"

Entonces para responder la pregunta:

sort file1 | diff /dev/stdin /dev/stdout 2<<EOT
`sort file2`
EOT