¿Cómo puedo saber si un archivo normal no existe en Bash?

He usado el siguiente script para ver si existe un archivo:

#!/bin/bash

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

¿Cuál es la sintaxis correcta para usar si solo quiero verificar si el archivo no existe?

#!/bin/bash

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

El comando de prueba ( [aquí) tiene un operador lógico "no", que es el signo de exclamación (similar a muchos otros idiomas). Prueba esto:

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

Prueba de archivo bash

-b filename- Bloquear archivo especial
-c filename- Archivo de caracteres especiales
-d directoryname- Verificar existencia de directorio
-e filename- Verificar existencia de archivo, independientemente del tipo (nodo, directorio, socket, etc.)
-f filename- Verificar existencia de archivo normal no un directorio
-G filename- Verificar si el archivo existe y es propiedad de ID de grupo efectivo
-G filename set-group-id- Verdadero si el archivo existe y es set-group-id
-k filename- Bit Sticky
-L filename- Enlace simbólico
-O filename- Verdadero si el archivo existe y es propiedad del ID de usuario efectivo
-r filename- Verifique si el archivo es legible
-S filename- Verifique si el archivo es socket
-s filename- Verifique si archivo es de tamaño distinto de cero
-u filename- Comprobar si el bit archivo de conjunto-user-id se fija
-w filename- Comprobar si el archivo se puede escribir
-x filename- Comprobar si el archivo es ejecutable

Cómo utilizar:

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

Se puede negar una expresión de prueba utilizando el !operador

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

Puede negar una expresión con "!":

#!/bin/bash
FILE=$1

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

La página de manual relevante es man testo, de manera equivalente, man [- help testo help [para el comando bash incorporado.

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

Además, es posible que el archivo sea un enlace simbólico roto, o un archivo no regular, como por ejemplo un socket, dispositivo o fifo. Por ejemplo, para agregar un cheque por enlaces simbólicos rotos:

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 la pena mencionar que si necesita ejecutar un solo comando puede abreviar

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

a

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

o

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

Prefiero hacer el siguiente one-liner, en formato compatible con shell POSIX :

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

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

Para un par de comandos, como lo haría en un script:

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

¡Una vez que comencé a hacer esto, rara vez uso la sintaxis completamente tipada!

Para probar la existencia del archivo, el parámetro puede ser cualquiera de los siguientes:

-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

Todas las pruebas a continuación se aplican a archivos, directorios y enlaces simbólicos normales:

-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 ejemplo:

#!/bin/bash
FILE=$1

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

Puedes hacerlo:

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

o

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

Si desea verificar el archivo y la carpeta, use la -eopción en lugar de -f. -edevuelve verdadero para archivos regulares, directorios, socket, archivos especiales de caracteres, archivos especiales de bloque, etc.

Debe tener cuidado al ejecutar testuna variable sin comillas, ya que podría producir resultados inesperados:

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

La recomendación generalmente es tener la variable probada entre comillas dobles:

#!/bin/sh
FILE=$1

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

Hay tres formas distintas de hacer esto:

1. Niegue el estado de salida con bash (ninguna otra respuesta ha dicho esto):

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

   O:

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

2. Niegue la prueba dentro del comando de prueba [(esa es la forma en que la mayoría de las respuestas se han presentado antes):

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

   O:

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

3. Actúe sobre el resultado de que la prueba sea negativa (en ||lugar de &&):

   Solamente:

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

   Esto parece una tontería (IMO), no lo use a menos que su código tenga que ser portátil para el shell Bourne (como el /bin/shde Solaris 10 o anterior) que carecía del operador de negación de canalización ( !):

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

En

[ -f "$file" ]

el [comando realiza una stat()(no lstat()) llamada al sistema en la ruta almacenada $filey devuelve verdadero si esa llamada al sistema tiene éxito y el tipo de archivo que devuelve stat()es " regular ".

Entonces, si [ -f "$file" ]devuelve verdadero, puede decir que el archivo existe y que es un archivo normal o un enlace simbólico que finalmente se resuelve en un archivo normal (o al menos lo era en el momento de stat()).

Sin embargo si devuelve falso (o si [ ! -f "$file" ]o ! [ -f "$file" ]devolver true), hay muchas posibilidades diferentes:

• el archivo no existe
• el archivo existe pero no es un archivo normal (podría ser un dispositivo, quince, directorio, socket ...)
• el archivo existe pero no tiene permiso de búsqueda para el directorio padre
• el archivo existe pero esa ruta para acceder es demasiado larga
• el archivo es un enlace simbólico a un archivo normal, pero no tiene permiso de búsqueda para algunos de los directorios involucrados en la resolución del enlace simbólico.
• ... cualquier otra razón por la cual la stat()llamada al sistema puede fallar.

En resumen, debería 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 saber con certeza que el archivo no existe, necesitaríamos que la stat()llamada del sistema regrese con un código de error de ENOENT( ENOTDIRnos dice que uno de los componentes de la ruta no es un directorio, es otro caso en el que podemos decir que el archivo no existir por ese camino). Desafortunadamente, el[ comando no nos deja saber eso. Devolverá falso si el código de error es ENOENT, EACCESS (permiso denegado), ENAMETOOLONG o cualquier otra cosa.

La [ -e "$file" ]prueba también se puede hacer con ls -Ld -- "$file" > /dev/null. En ese caso, lsle diremos por qué stat()falló, aunque la información no se puede usar fácilmente mediante programación:

$ 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

Al menos lsme dice que no es porque el archivo no existe que falla. Es porque no puede decir si el archivo existe o no. El [comando simplemente ignoró el problema.

Con el zshshell, puede consultar el código de error con la $ERRNOvariable especial después del [comando que falla y decodificar ese número utilizando la $errnosmatriz especial en el 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

(Tenga en cuenta que el $errnossoporte se rompió con algunas versiones de zshcuando se creó con versiones recientes degcc ).

Para revertir una prueba, use "!". Eso es equivalente al operador lógico "no" en otros idiomas. Prueba esto:

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

O escrito de una manera ligeramente diferente:

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

O podrías usar:

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

O, presionando todos juntos:

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

Que puede escribirse (usando el operador "y": &&) como:

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

Que se ve más corto así:

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

La testcosa también puede contar. Funcionó para mí (basado en Bash Shell: Verificar archivo existe o no ):

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

Este código también funciona.

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

La forma mas simple

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

Este script de shell también funciona para encontrar un archivo en un directorio:

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

a veces puede ser útil usar && y || operadores.

Como en (si tiene el comando "prueba"):

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

o

test -b $FILE || echo File there!

Si desea usar en testlugar de [], puede usar !para obtener la negación:

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

También puede agrupar múltiples comandos en un solo revestimiento

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

o

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

Si el nombre de archivo no sale, la salida será

test1
test2
test3

Nota: (...) se ejecuta en un subshell, {...;} se ejecuta en el mismo shell. La notación de corchete funciona solo en bash.

envfile=.env

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