bash se não várias condições sem subshell?

Eu quero combinar várias condições em uma declaração shell if e negar a combinação. Eu tenho o seguinte código de trabalho para uma combinação simples de condições:

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

Isso funciona bem. Se eu quiser negar, posso usar o seguinte código de trabalho:

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

Isso também funciona conforme o esperado. No entanto, me ocorre que não sei o que os parênteses estão fazendo ali. Eu quero usá-los apenas para agrupar, mas é realmente gerando um subshell? (Como posso saber?) Em caso afirmativo, existe uma maneira de agrupar as condições sem gerar um subshell?

Você precisa usar em { list;}vez de (list):

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

Ambos são comandos de agrupamento , mas { list;}executam comandos no ambiente atual do shell.

Observe que, o ;in { list;}é necessário para delimitar a lista da }palavra reversa, você também pode usar outro delimitador. O espaço (ou outro delimitador) depois {também é necessário.

Você pode usar inteiramente a testfuncionalidade para alcançar o que deseja. Na página do 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.

Portanto, sua condição pode parecer com:

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

Para negar o uso de parênteses escapados:

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

Para portably negar uma condicional complexo no shell, você deve aplicar a lei de De Morgan e empurre a negação todo o caminho dentro das [chamadas ...

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

... ou você deve usar then :; else...

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

if ! commandnão está disponível de forma portável e nem está [[.

Se você não precisar de portabilidade total, não escreva um script de shell . É mais provável que você encontre /usr/bin/perlum Unix selecionado aleatoriamente do que você bash.

outros notaram o agrupamento de {comandos compostos ;}, mas se você estiver executando testes idênticos em um conjunto, poderá usar um tipo diferente:

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

... como é demonstrado em outro lugar { :;}, não há dificuldade em aninhar comandos compostos ...

Observe que o acima (normalmente) testa arquivos regulares . Se você estiver procurando apenas arquivos legíveis e existentes que não sejam diretórios:

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

Se você não se importa se são diretórios ou não:

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

... funciona para qualquer arquivo legível e acessível , mas provavelmente ficará travado por quinze sem gravadores.

Esta não é uma resposta completa à sua pergunta principal, mas notei que você mencionou o teste composto (arquivo legível) em um comentário; por exemplo,

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

Você pode consolidar isso um pouco, definindo uma função shell; por exemplo,

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

Adicione o tratamento de erros a (por exemplo, [ $# = 1 ]) a gosto. A primeira ifdeclaração, acima, agora pode ser condensada para

if readable_file file1  &&  readable_file file2  &&  readable_file file3

e você pode encurtar ainda mais, encurtando o nome da função. Da mesma forma, você pode definir not_readable_file()(ou nrfabreviar) e incluir a negação na função.

Você também pode negar os testes de chaves, para reutilizar seu código original:

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

Eu quero usá-los apenas para agrupar, mas é realmente gerando um subshell? (Como posso eu saber?)

Sim, os comandos dentro do (...)são executados em um subshell.

Para testar se você está em um subshell, você pode comparar o PID do seu shell atual com o PID do shell interativo.

echo $BASHPID; (echo $BASHPID); 

Exemplo de saída, demonstrando que os parênteses geram um subshell e as chaves não:

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