bash sinon conditions multiples sans sous-shell?

Je veux combiner plusieurs conditions dans une instruction shell if et annuler la combinaison. J'ai le code de travail suivant pour une combinaison simple de conditions:

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

Cela fonctionne bien. Si je veux l'annuler, je peux utiliser le code de travail suivant:

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

Cela fonctionne également comme prévu. Cependant, il me vient à l'esprit que je ne sais pas ce que les parenthèses font réellement là-bas. Je veux les utiliser uniquement pour le regroupement, mais est-ce réellement un sous-shell? (Comment savoir?) Dans l'affirmative, existe-t-il un moyen de regrouper les conditions sans engendrer un sous-shell?

Vous devez utiliser { list;}au lieu de (list):

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

Les deux sont des commandes de regroupement , mais { list;}exécutent des commandes dans l'environnement shell actuel.

Notez que, l' ;en { list;}est nécessaire pour délimiter la liste de }mots inverse, vous pouvez utiliser d' autres delimiter ainsi. L'espace (ou autre délimiteur) après {est également requis.

Vous pouvez utiliser entièrement la testfonctionnalité pour réaliser ce que vous voulez. À partir de la page de manuel 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.

Votre état pourrait donc ressembler à:

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

Pour annuler l'utilisation de parenthèses d'échappement:

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

Pour annuler de manière portative un conditionnel complexe en shell, vous devez soit appliquer la loi de De Morgan et pousser la négation jusqu'en bas dans les [appels ...

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

... ou vous devez utiliser then :; else...

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

if ! commandn'est pas disponible sur le marché et ni l'un ni l'autre [[.

Si vous n'avez pas besoin d'une portabilité totale, n'écrivez pas de script shell . Vous êtes en fait plus susceptible de trouver /usr/bin/perlsur un Unix sélectionné au hasard que vous bash.

d'autres ont noté le regroupement des {commandes composées ;}, mais si vous effectuez des tests identiques sur un ensemble, vous pouvez utiliser un type différent:

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

... comme cela a été démontré ailleurs { :;}, l'imbrication des commandes composées ne pose aucun problème ...

Notez que les tests ci-dessus (généralement) pour les fichiers réguliers . Si vous cherchez seulement existants , lisibles les fichiers qui ne sont pas des répertoires:

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

Si vous ne vous souciez pas qu'il s'agisse de répertoires ou non:

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

... fonctionne pour tout fichier lisible et accessible , mais se bloquera probablement pour fifos sans écrivains.

Ce n'est pas une réponse complète à votre question principale, mais j'ai remarqué que vous mentionnez les tests composés (fichier lisible) dans un commentaire; par exemple,

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

Vous pouvez consolider cela un peu en définissant une fonction shell; par exemple,

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

Ajoutez la gestion des erreurs à (par exemple, [ $# = 1 ]) au goût. La première ifdéclaration ci-dessus peut maintenant être condensée en

if readable_file file1  &&  readable_file file2  &&  readable_file file3

et vous pouvez encore raccourcir cela en raccourcissant le nom de la fonction. De même, vous pouvez définir not_readable_file()(ou nrfpour faire court) et inclure la négation dans la fonction.

Vous pouvez également annuler les tests d'accolade, donc pour réutiliser votre code d'origine:

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

Je veux les utiliser uniquement pour le regroupement, mais est-ce réellement un sous-shell? (Comment savoir?)

Oui, les commandes dans le (...)sont exécutées dans un sous-shell.

Pour tester si vous êtes dans un sous-shell, vous pouvez comparer le PID de votre shell actuel avec le PID du shell interactif.

echo $BASHPID; (echo $BASHPID); 

Exemple de sortie, démontrant que les parenthèses génèrent un sous-shell et les accolades ne font pas:

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