Come faccio a sapere se un file normale non esiste in Bash?

Ho usato il seguente script per vedere se esiste un file:

#!/bin/bash

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

Qual è la sintassi corretta da usare se voglio solo verificare se il file non esiste?

#!/bin/bash

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

Il comando test ( [qui) ha un operatore logico "non" che è il punto esclamativo (simile a molte altre lingue). Prova questo:

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

Test dei file Bash

-b filename- Blocca file speciale
-c filename- File di caratteri speciali
-d directoryname- Controlla l'esistenza di directory
-e filename- Controlla l'esistenza del file, indipendentemente dal tipo (nodo, directory, socket, ecc.)
-f filename- Controlla l'esistenza di file regolari non una directory
-G filename- Controlla se il file esiste ed è di proprietà di ID gruppo effettivo
-G filename set-group-id- Vero se il file esiste ed è set-group-id
-k filename- Bit appiccicoso
-L filename- Collegamento simbolico
-O filename- Vero se il file esiste ed è di proprietà dell'ID utente effettivo
-r filename- Verifica se il file è leggibile
-S filename- Verifica se il file è socket
-s filename- Verifica se il file ha dimensioni diverse da zero
-u filename- Controlla se il file set-user-id bit è impostato
-w filename- Controlla se il file è scrivibile
-x filename- Controlla se il file è eseguibile

Come usare:

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

Un'espressione di test può essere negato utilizzando l' !operatore

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

Puoi negare un'espressione con "!":

#!/bin/bash
FILE=$1

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

La pagina man rilevante è man testo, equivalentemente, man [- help testo help [per il comando bash incorporato.

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

Inoltre, è possibile che il file sia un collegamento simbolico interrotto o un file non regolare, come ad esempio un socket, un dispositivo o un FIFO. Ad esempio, per aggiungere un controllo per collegamenti simbolici non funzionanti:

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 ricordare che se è necessario eseguire un singolo comando è possibile abbreviare

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

per

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

o

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

Preferisco fare il seguente one-liner, in formato compatibile con shell POSIX :

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

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

Per un paio di comandi, come farei in uno script:

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

Una volta che ho iniziato a fare questo, raramente uso più la sintassi completamente digitata !!

Per verificare l'esistenza del file, il parametro può essere uno dei seguenti:

-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

Tutti i test seguenti si applicano a file, directory e collegamenti simbolici regolari:

-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 di esempio:

#!/bin/bash
FILE=$1

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

Puoi farlo:

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

o

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

Se si desidera controllare entrambi i file e le cartelle, utilizzare l' -eopzione anziché -f. -eritorna vero per file regolari, directory, socket, file speciali di caratteri, blocchi di file speciali ecc.

Dovresti fare attenzione a eseguire testuna variabile non quotata, perché potrebbe produrre risultati imprevisti:

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

La raccomandazione è di solito di avere la variabile testata racchiusa tra virgolette doppie:

#!/bin/sh
FILE=$1

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

Esistono tre modi distinti per farlo:

1. Annulla lo stato di uscita con bash (nessun'altra risposta ha detto questo):

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

   O:

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

2. Annulla il test all'interno del comando test [(questo è il modo in cui la maggior parte delle risposte prima hanno presentato):

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

   O:

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

3. Agire sul risultato del test in modo negativo ( ||anziché &&):

   Solo:

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

   Questo sembra sciocco (IMO), non usarlo a meno che il tuo codice non debba essere portabile sulla shell Bourne (come quella /bin/shdi Solaris 10 o precedente) che mancava dell'operatore di negazione della pipeline ( !):

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

In

[ -f "$file" ]

il [comando esegue una stat()(non lstat()) chiamata di sistema sul percorso memorizzato $filee restituisce true se la chiamata di sistema ha esito positivo e il tipo di file restituito dastat() è " regolare ".

Quindi se [ -f "$file" ] restituisce true, puoi dire che il file esiste ed è un file normale o un link simbolico che alla fine si risolve in un file normale (o almeno lo era al momento delstat() ).

Tuttavia, se restituisce false (o if[ ! -f "$file" ] o ! [ -f "$file" ]return true), ci sono molte diverse possibilità:

• il file non esiste
• il file esiste ma non è un normale file (potrebbe essere un dispositivo, fifo, directory, socket ...)
• il file esiste ma non si dispone dell'autorizzazione di ricerca nella directory principale
• il file esiste ma quel percorso per accedervi è troppo lungo
• il file è un collegamento simbolico a un file normale, ma non si dispone dell'autorizzazione di ricerca per alcune directory coinvolte nella risoluzione del collegamento simbolico.
• ... qualsiasi altro motivo per cui la stat()chiamata di sistema potrebbe non riuscire.

In breve, dovrebbe essere:

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

Per sapere con certezza che il file non esiste, avremmo bisogno che la stat()chiamata di sistema ritorni con un codice di errore di ENOENT( ENOTDIRci dice che uno dei componenti del percorso non è una directory è un altro caso in cui possiamo dire che il file non esiste da quel percorso). Sfortunatamente il [comando non ce lo fa sapere. Restituirà falso se il codice di errore è ENOENT, EACCESS (autorizzazione negata), ENAMETOOLONG o qualsiasi altra cosa.

Il [ -e "$file" ]test può anche essere eseguito con ls -Ld -- "$file" > /dev/null. In tal caso, lsti dirà perché l' stat()errore non è riuscito, sebbene le informazioni non possano essere facilmente utilizzate a livello di codice:

$ 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

Almeno lsmi dice che non è perché il file non esiste che non riesce. È perché non può dire se il file esiste o no. Il [comando ha semplicemente ignorato il problema.

Con la zshshell, è possibile eseguire una query sul codice di errore con la $ERRNOvariabile speciale dopo il [comando non riuscito e decodificare quel numero utilizzando l' $errnosarray speciale nel zsh/systemmodulo:

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

(attenzione il $errnossupporto è stato interrotto con alcune versioni di zshquando costruito con versioni recenti digcc ).

Per invertire un test, utilizzare "!". Ciò equivale all'operatore logico "non" in altre lingue. Prova questo:

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

O scritto in un modo leggermente diverso:

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

Oppure potresti usare:

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

Oppure, presentando tutti insieme:

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

Che può essere scritto (usando poi "e" operatore: &&) come:

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

Che sembra più corto in questo modo:

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

Anche la testcosa può contare. Ha funzionato per me (basato su Bash Shell: Controlla che il file esista o meno ):

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

Anche questo codice funziona.

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

Il modo più semplice

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

Questo script di shell funziona anche per trovare un file in una directory:

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 volte può essere utile usare && e || operatori.

Come in (se hai il comando "test"):

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

o

test -b $FILE || echo File there!

Se si desidera utilizzare testinvece di [], è possibile utilizzare !per ottenere la negazione:

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

È inoltre possibile raggruppare più comandi in una riga

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

o

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

Se il nome file non viene chiuso, l'output sarà

test1
test2
test3

Nota: (...) viene eseguito in una subshell, {...;} viene eseguito nella stessa shell. La notazione parentesi graffa funziona solo in bash.

envfile=.env

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