bash si no múltiples condiciones sin subshell?

Quiero combinar varias condiciones en una instrucción if de shell y negar la combinación. Tengo el siguiente código de trabajo para una combinación simple de condiciones:

if [ -f file1 ] && [ -f file2 ] && [ -f file3 ] ; then
  # do stuff with the files
fi

Esto funciona bien Si quiero negarlo, puedo usar el siguiente código de trabajo:

if ! ( [ -f file1 ] && [ -f file2 ] && [ -f file3 ] ) ; then
  echo "Error: You done goofed."
  exit 1
fi
# do stuff with the files

Esto también funciona como se esperaba. Sin embargo, se me ocurre que no sé qué hacen los paréntesis en realidad allí. Yo quiero a utilizarlos sólo para la agrupación, pero ¿es realmente el desove un subnivel? (¿Cómo puedo saberlo?) Si es así, ¿hay alguna forma de agrupar las condiciones sin generar una subshell?

Debe usar en { list;}lugar de (list):

if ! { [ -f file1 ] && [ -f file2 ] && [ -f file3 ]; }; then
  : do something
fi

Ambos son Comandos de Agrupación , pero { list;}ejecutan comandos en el entorno actual del shell.

Tenga en cuenta que, el ;en { list;}que se necesita para delimitar la lista de }palabra inversa, se pueden utilizar otros delimitador también. {También se requiere el espacio (u otro delimitador) después .

Puede utilizar completamente la testfuncionalidad para lograr lo que desea. Desde la página del manual de test:

 ! expression  True if expression is false.
 expression1 -a expression2
               True if both expression1 and expression2 are true.
 expression1 -o expression2
               True if either expression1 or expression2 are true.
 (expression)  True if expression is true.

Entonces su condición podría verse así:

if [ -f file1 -a -f file2 -a -f file3 ] ; then
    # do stuff with the files
fi

Para negar el uso de paréntesis escapados:

if [ ! \( -f file1 -a -f file2 -a -f file3 \) ] ; then
    echo "Error: You done goofed."
    exit 1
fi
# do stuff with the files

A negar de forma portátil un condicional complejo en shell, debe aplicar la ley de De Morgan y empujar la negación hasta el fondo dentro de las [llamadas ...

if [ ! -f file1 ] || [ ! -f file2 ] || [ ! -f file3 ]
then
    # do stuff
fi

... o debes usar then :; else...

if [ -f file1 ] && [ -f file2 ] && [ -f file3 ]
then :
else
  # do stuff
fi

if ! commandno está disponible de forma portátil y tampoco lo está [[.

Si no necesita portabilidad total, no escriba un script de shell . En realidad, es más probable que encuentres /usr/bin/perlen un Unix seleccionado al azar de lo que eresbash .

otros han notado la agrupación de {comandos compuestos ;}, pero si está realizando pruebas idénticas en un conjunto, es posible que desee utilizar un tipo diferente:

if  ! for f in file1 file2 file3
      do  [ -f "$f" ] || ! break
      done
then  : do stuff
fi

... como se demuestra en otra parte { :;}, no hay dificultad involucrada con los comandos compuestos de anidación ...

Tenga en cuenta que lo anterior (normalmente) prueba los archivos normales . Si solo está buscando archivos existentes y legibles que no sean directorios:

if  ! for f in file1 file2 file3
      do  [ ! -d "$f" ] && 
          [   -r "$f" ] || ! break
      done
then  : do stuff
fi

Si no te importa si son directorios o no:

if  ! command <file1 <file2 <file3
then  : do stuff
fi

... funciona para cualquier archivo legible y accesible , pero es probable que se bloquee por quince sin escritores.

Esta no es una respuesta completa a su pregunta principal, pero noté que menciona las pruebas compuestas (archivo legible) en un comentario; p.ej,

if [ -f file1 ] && [ -r file1 ] && [ -f file2 ] && [ -r file2 ] && [ -f file3 ] && [ -r file3 ]

Puede consolidar esto un poco definiendo una función de shell; p.ej,

readable_file()
{
    [ -f "$1" ]  &&  [ -r "$1" ]
}

Agregue manejo de errores a (p. Ej. [ $# = 1 ]) Al gusto. La primera ifdeclaración, arriba, ahora se puede condensar a

if readable_file file1  &&  readable_file file2  &&  readable_file file3

y puede acortar esto aún más acortando el nombre de la función. Del mismo modo, podría definir not_readable_file()(o nrfpara abreviar) e incluir la negación en la función.

También puede negar dentro de las pruebas de llaves, para reutilizar su código original:

if [[ ! -f file1 ]] || [[ ! -f file2 ]] || [[ ! -f file3 ]] ; then
  # do stuff with the files
fi

Quiero usarlos solo para agrupar, pero ¿realmente está generando una subshell? (¿Cómo puedo decir?)

Sí, los comandos dentro de (...)se ejecutan en una subshell.

Para probar si está en un subshell, puede comparar el PID de su shell actual con el PID del shell interactivo.

echo $BASHPID; (echo $BASHPID); 

Ejemplo de salida, que demuestra que los paréntesis generan una subshell y las llaves no:

$ echo $BASHPID; (echo $BASHPID); { echo $BASHPID;}
50827
50843
50827
$