Como posso saber se um arquivo regular não existe no Bash?

Usei o seguinte script para verificar se existe um arquivo:

#!/bin/bash

FILE=$1     
if [ -f $FILE ]; then
   echo "File $FILE exists."
else
   echo "File $FILE does not exist."
fi

Qual é a sintaxe correta a ser usada se eu quiser apenas verificar se o arquivo não existe?

#!/bin/bash

FILE=$1     
if [ $FILE does not exist ]; then
   echo "File $FILE does not exist."
fi

O comando test ( [aqui) possui um operador lógico "não", que é o ponto de exclamação (semelhante a muitos outros idiomas). Tente o seguinte:

if [ ! -f /tmp/foo.txt ]; then
    echo "File not found!"
fi

Teste de arquivo bash

-b filename- Bloquear arquivo especial
-c filename- Arquivo de caractere especial
-d directoryname- Verificar a existência do diretório
-e filename- Verificar a existência do arquivo, independentemente do tipo (nó, diretório, soquete etc.)
-f filename- Verificar a existência regular do arquivo e não um diretório
-G filename- Verificar se o arquivo existe e é de propriedade de ID do grupo efetivo
-G filename set-group-id- Verdadeiro se o arquivo existir e estiver definido como id do grupo
-k filename- Bit fixo
-L filename- Link simbólico
-O filename- Verdadeiro se o arquivo existir e pertencer ao ID do usuário efetivo
-r filename- Verifique se o arquivo é legível
-S filename- Verifique se o arquivo é soquete
-s filename- Verifique se arquivo com tamanho diferente de zero
-u filename- Verifique se o bit do conjunto de IDs de usuário está definido
-w filename- Verifique se o arquivo é gravável
-x filename- Verifique se o arquivo é executável

Como usar:

#!/bin/bash
file=./file
if [ -e "$file" ]; then
    echo "File exists"
else 
    echo "File does not exist"
fi 

Uma expressão de teste pode ser negada usando o !operador

#!/bin/bash
file=./file
if [ ! -e "$file" ]; then
    echo "File does not exist"
else 
    echo "File exists"
fi 

Você pode negar uma expressão com "!":

#!/bin/bash
FILE=$1

if [ ! -f "$FILE" ]
then
    echo "File $FILE does not exist"
fi

A página de manual relevante é man testou, equivalentemente, man [- ou help testou help [para o comando bash interno.

[[ -f $FILE ]] || printf '%s does not exist!\n' "$FILE"

Além disso, é possível que o arquivo seja um link simbólico quebrado ou um arquivo não regular, como, por exemplo, um soquete, dispositivo ou fifo. Por exemplo, para adicionar uma verificação de links simbólicos quebrados:

if [[ ! -f $FILE ]]; then
    if [[ -L $FILE ]]; then
        printf '%s is a broken symlink!\n' "$FILE"
    else
        printf '%s does not exist!\n' "$FILE"
    fi
fi

Vale ressaltar que, se você precisar executar um único comando, poderá abreviar

if [ ! -f "$file" ]; then
    echo "$file"
fi

para

test -f "$file" || echo "$file"

ou

[ -f "$file" ] || echo "$file"

Prefiro fazer o seguinte one-liner, no formato compatível com shell POSIX :

$ [ -f "/$DIR/$FILE" ] || echo "$FILE NOT FOUND"

$ [ -f "/$DIR/$FILE" ] && echo "$FILE FOUND"

Para alguns comandos, como eu faria em um script:

$  [ -f "/$DIR/$FILE" ] || { echo "$FILE NOT FOUND" ; exit 1 ;}

Depois que comecei a fazer isso, raramente uso mais a sintaxe totalmente digitada !!

Para testar a existência do arquivo, o parâmetro pode ser qualquer um dos seguintes:

-e: Returns true if file exists (regular file, directory, or symlink)
-f: Returns true if file exists and is a regular file
-d: Returns true if file exists and is a directory
-h: Returns true if file exists and is a symlink

Todos os testes abaixo se aplicam a arquivos, diretórios e links simbólicos regulares:

-r: Returns true if file exists and is readable
-w: Returns true if file exists and is writable
-x: Returns true if file exists and is executable
-s: Returns true if file exists and has a size > 0

Script de exemplo:

#!/bin/bash
FILE=$1

if [ -f "$FILE" ]; then
   echo "File $FILE exists"
else
   echo "File $FILE does not exist"
fi

Você consegue fazer isso:

[[ ! -f "$FILE" ]] && echo "File doesn't exist"

ou

if [[ ! -f "$FILE" ]]; then
    echo "File doesn't exist"
fi

Se você deseja procurar arquivos e pastas, use a -eopção em vez de -f. -eretorna true para arquivos regulares, diretórios, soquete, arquivos especiais de caracteres, bloquear arquivos especiais etc.

Você deve ter cuidado ao executar testuma variável não citada, pois ela pode produzir resultados inesperados:

$ [ -f ]
$ echo $?
0
$ [ -f "" ]
$ echo $?
1

A recomendação é geralmente ter a variável testada entre aspas duplas:

#!/bin/sh
FILE=$1

if [ ! -f "$FILE" ]
then
   echo "File $FILE does not exist."
fi

Existem três maneiras distintas de fazer isso:

1. Negue o status de saída com bash (nenhuma outra resposta disse isso):

   if ! [ -e "$file" ]; then
       echo "file does not exist"
   fi

   Ou:

   ! [ -e "$file" ] && echo "file does not exist"

2. Negue o teste dentro do comando test [(essa é a maneira que a maioria das respostas apresentou anteriormente):

   if [ ! -e "$file" ]; then
       echo "file does not exist"
   fi

   Ou:

   [ ! -e "$file" ] && echo "file does not exist"

3. Aja com o resultado negativo do teste (em ||vez de&& ):

   Somente:

   [ -e "$file" ] || echo "file does not exist"

   Isso parece bobo (IMO), não o use, a menos que seu código precise ser portátil para o shell Bourne (como o /bin/shSolaris 10 ou anterior) que não possui o operador de negação de pipeline ( !):

   if [ -e "$file" ]; then
       :
   else
       echo "file does not exist"
   fi

No

[ -f "$file" ]

o [comando faz uma stat()(não lstat()) chamada do sistema no caminho armazenado $filee retorna true se a chamada do sistema for bem-sucedida e o tipo de arquivo retornado por stat()" regular ".

Portanto, se [ -f "$file" ]retorna true, você pode dizer que o arquivo existe e é um arquivo regular ou um link simbólico que eventualmente está sendo resolvido para um arquivo regular (ou pelo menos era no momento do stat()).

No entanto, se retornar falso (ou se [ ! -f "$file" ]ou ! [ -f "$file" ]retornar verdadeiro), há muitas possibilidades diferentes:

• o arquivo não existe
• o arquivo existe, mas não é regular (pode ser um dispositivo, fifo, diretório, soquete ...)
• o arquivo existe, mas você não tem permissão de pesquisa para o diretório pai
• o arquivo existe, mas esse caminho para acessá-lo é muito longo
• o arquivo é um link simbólico para um arquivo normal, mas você não tem permissão de pesquisa para alguns dos diretórios envolvidos na resolução do link simbólico.
• ... qualquer outro motivo pelo qual a stat()chamada do sistema possa falhar.

Em suma, deve ser:

if [ -f "$file" ]; then
  printf '"%s" is a path to a regular file or symlink to regular file\n' "$file"
elif [ -e "$file" ]; then
  printf '"%s" exists but is not a regular file\n' "$file"
elif [ -L "$file" ]; then
  printf '"%s" exists, is a symlink but I cannot tell if it eventually resolves to an actual file, regular or not\n' "$file"
else
  printf 'I cannot tell if "%s" exists, let alone whether it is a regular file or not\n' "$file"
fi

Para ter certeza de que o arquivo não existe, precisaríamos que a stat()chamada do sistema retornasse com um código de erro de ENOENT( ENOTDIRnos diz que um dos componentes do caminho não é um diretório, outro caso em que podemos dizer que o arquivo não existe) existir por esse caminho). Infelizmente, o [comando não nos informa disso. Ele retornará false se o código de erro é ENOENT, EACCESS (permissão negada), ENAMETOOLONG ou qualquer outra coisa.

O [ -e "$file" ]teste também pode ser feito com ls -Ld -- "$file" > /dev/null. Nesse caso, lsinformará o motivo da stat()falha, embora as informações não possam ser facilmente usadas programaticamente:

$ file=/var/spool/cron/crontabs/root
$ if [ ! -e "$file" ]; then echo does not exist; fi
does not exist
$ if ! ls -Ld -- "$file" > /dev/null; then echo stat failed; fi
ls: cannot access '/var/spool/cron/crontabs/root': Permission denied
stat failed

Pelo menos lsme diz que não é porque o arquivo não existe que falha. É porque ele não pode dizer se o arquivo existe ou não. O [comando apenas ignorou o problema.

Com o zshshell, você pode consultar o código de erro com a $ERRNOvariável especial após o [comando com falha e decodificar esse número usando a $errnosmatriz especial no zsh/systemmódulo:

zmodload zsh/system
ERRNO=0
if [ ! -f "$file" ]; then
  err=$ERRNO
  case $errnos[err] in
    ("") echo exists, not a regular file;;
    (ENOENT|ENOTDIR)
       if [ -L "$file" ]; then
         echo broken link
       else
         echo does not exist
       fi;;
    (*) syserror -p "can't tell: " "$err"
  esac
fi

(cuidado, o $errnossuporte foi quebrado com algumas versões de zshquando construído com versões recentes dogcc ).

Para reverter um teste, use "!". Isso é equivalente ao operador lógico "não" em outros idiomas. Tente o seguinte:

if [ ! -f /tmp/foo.txt ];
then
    echo "File not found!"
fi

Ou escrito de uma maneira um pouco diferente:

if [ ! -f /tmp/foo.txt ]
    then echo "File not found!"
fi

Ou você pode usar:

if ! [ -f /tmp/foo.txt ]
    then echo "File not found!"
fi

Ou, apresentando todos juntos:

if ! [ -f /tmp/foo.txt ]; then echo "File not found!"; fi

Que pode ser escrito (usando o operador "and": &&) como:

[ ! -f /tmp/foo.txt ] && echo "File not found!"

Que parece mais curto assim:

[ -f /tmp/foo.txt ] || echo "File not found!"

A testcoisa pode contar também. Funcionou para mim (com base no Bash Shell: verificar se o arquivo existe ou não ):

test -e FILENAME && echo "File exists" || echo "File doesn't exist"

Este código também está funcionando.

#!/bin/bash
FILE=$1
if [ -f $FILE ]; then
 echo "File '$FILE' Exists"
else
 echo "The File '$FILE' Does Not Exist"
fi

A maneira mais simples

FILE=$1
[ ! -e "${FILE}" ] && echo "does not exist" || echo "exists"

Esse script de shell também funciona para encontrar um arquivo em um diretório:

echo "enter file"

read -r a

if [ -s /home/trainee02/"$a" ]
then
    echo "yes. file is there."
else
    echo "sorry. file is not there."
fi

às vezes pode ser útil usar && e || operadores.

Como em (se você tiver o comando "test"):

test -b $FILE && echo File not there!

ou

test -b $FILE || echo File there!

Se você deseja usar em testvez de [], pode usar !para obter a negação:

if ! test "$FILE"; then
  echo "does not exist"
fi

Você também pode agrupar vários comandos em uma linha

[ -f "filename" ] || ( echo test1 && echo test2 && echo test3 )

ou

[ -f "filename" ] || { echo test1 && echo test2 && echo test3 ;}

Se o nome do arquivo não sair, a saída será

test1
test2
test3

Nota: (...) é executado em um subshell, {...;} é executado no mesmo shell. A notação de colchete funciona somente no bash.

envfile=.env

if [ ! -f "$envfile" ]
then
    echo "$envfile does not exist"
    exit 1
fi