bash se non più condizioni senza subshell?

Voglio combinare più condizioni in un'istruzione shell e annullare la combinazione. Ho il seguente codice di lavoro per una semplice combinazione di condizioni:

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

Funziona benissimo. Se voglio negarlo, posso usare il seguente codice di lavoro:

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

Funziona anche come previsto. Tuttavia, mi viene in mente che non so cosa stanno effettivamente facendo le parentesi lì. Io voglio usarli solo per il raggruppamento, ma è in realtà la deposizione delle uova una subshell? (Come posso dirlo?) In tal caso, esiste un modo per raggruppare le condizioni senza generare una subshell?

Devi usare { list;}invece di (list):

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

Entrambi sono comandi di raggruppamento , ma { list;}eseguono comandi nell'attuale ambiente di shell.

Si noti che, ;in { list;}è necessario per delimitare l'elenco dalla }parola inversa, è possibile utilizzare anche altri delimitatori. È richiesto anche lo spazio (o altro delimitatore) successivo {.

È possibile utilizzare interamente la testfunzionalità per ottenere ciò che si desidera. Dalla pagina man di 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.

Quindi la tua condizione potrebbe apparire come:

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

Per negare l'uso di parentesi sfuggite:

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

Per negare in modo portabile un condizionale complesso nella shell, è necessario applicare la legge di De Morgan e spingere la negazione fino in fondo all'interno delle [chiamate ...

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

... oppure devi usare then :; else...

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

if ! commandnon è disponibile in modo portabile e nemmeno lo è [[.

Se non hai bisogno di portabilità totale, non scrivere uno script di shell . In realtà hai più probabilità di trovare /usr/bin/perlun Unix selezionato casualmente di quello che sei bash.

altri hanno notato il raggruppamento dei {comandi composti ;}, ma se si eseguono test identici su un set, è possibile che si desideri utilizzare un tipo diverso:

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

... come è dimostrato altrove { :;}, non vi sono difficoltà nel nidificare i comandi composti ...

Si noti che quanto sopra (in genere) verifica i file regolari . Se stai cercando solo file esistenti e leggibili che non siano directory:

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

Se non ti importa se sono directory o no:

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

... funziona per qualsiasi file leggibile e accessibile , ma probabilmente si bloccherà per i cinquanta senza scrittori.

Questa non è una risposta completa alla tua domanda principale, ma ho notato che in un commento hai menzionato il test composto (file leggibile); per esempio,

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

Puoi consolidarlo un po 'definendo una funzione di shell; per esempio,

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

Aggiungi la gestione degli errori a (ad es. [ $# = 1 ]) A piacere. La prima ifaffermazione, sopra, ora può essere condensata

if readable_file file1  &&  readable_file file2  &&  readable_file file3

e puoi accorciarlo ulteriormente accorciando il nome della funzione. Allo stesso modo, è possibile definire not_readable_file()(o nrfin breve) e includere la negazione nella funzione.

Puoi annullare anche i test di parentesi graffa, quindi per riutilizzare il codice originale:

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

Voglio usarli solo per il raggruppamento, ma in realtà sta generando una subshell? (Come posso dirlo?)

Sì, i comandi all'interno di (...)vengono eseguiti in una subshell.

Per verificare se ci si trova in una subshell è possibile confrontare il PID della shell corrente con il PID della shell interattiva.

echo $BASHPID; (echo $BASHPID); 

Esempio di output, che dimostra che le parentesi generano una sottostruttura e le parentesi graffe non:

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