Comment savoir si un fichier standard n'existe pas dans Bash?

J'ai utilisé le script suivant pour voir si un fichier existe:

#!/bin/bash

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

Quelle est la syntaxe correcte à utiliser si je veux seulement vérifier si le fichier n'existe pas ?

#!/bin/bash

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

La commande de test ( [ici) a un opérateur logique "non" qui est le point d'exclamation (similaire à de nombreuses autres langues). Essaye ça:

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

Test de fichier Bash

-b filename- Bloquer le fichier spécial
-c filename- Fichier de caractères spéciaux
-d directoryname- Vérifier l'existence du répertoire
-e filename- Vérifier l'existence du fichier, quel que soit le type (nœud, répertoire, socket, etc.)
-f filename- Vérifier l'existence régulière du fichier et non un répertoire
-G filename- Vérifier si le fichier existe et appartient à ID de groupe effectif
-G filename set-group-id- Vrai si le fichier existe et est défini-group-id
-k filename- Sticky bit
-L filename- Lien symbolique
-O filename- Vrai si le fichier existe et appartient à l'ID utilisateur effectif
-r filename- Vérifiez si le fichier est lisible
-S filename- Vérifiez si le fichier est socket
-s filename- Vérifiez si le fichier est de taille différente de zéro
-u filename- Vérifiez si le fichier set-user-id est défini
-w filename- Vérifiez si le fichier est accessible en écriture
-x filename- Vérifiez si le fichier est exécutable

Comment utiliser:

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

Une expression de test peut être annulée à l'aide de l' !opérateur

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

Vous pouvez annuler une expression avec "!":

#!/bin/bash
FILE=$1

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

La page de manuel appropriée est man testou, de manière équivalente, man [- ou help testou help [pour la commande bash intégrée.

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

En outre, il est possible que le fichier soit un lien symbolique rompu ou un fichier non régulier, comme par exemple un socket, un périphérique ou un fifo. Par exemple, pour ajouter une vérification des liens symboliques rompus:

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

Il convient de mentionner que si vous devez exécuter une seule commande, vous pouvez abréger

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

à

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

ou

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

Je préfère faire le one-liner suivant, au format compatible POSIX shell:

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

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

Pour quelques commandes, comme je le ferais dans un script:

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

Une fois que j'ai commencé à le faire, j'utilise rarement la syntaxe entièrement typée !!

Pour tester l'existence du fichier, le paramètre peut être l'un des suivants:

-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

Tous les tests ci-dessous s'appliquent aux fichiers, répertoires et liens symboliques standard:

-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

Exemple de script:

#!/bin/bash
FILE=$1

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

Tu peux le faire:

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

ou

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

Si vous souhaitez vérifier le fichier et le dossier à la fois, utilisez l' -eoption au lieu de -f. -erenvoie vrai pour les fichiers, répertoires, socket, fichiers spéciaux de caractères normaux, fichiers spéciaux de bloc, etc.

Vous devez être prudent lors de l'exécution testd'une variable sans guillemets, car cela pourrait produire des résultats inattendus:

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

Il est généralement recommandé de placer la variable testée entre guillemets doubles:

#!/bin/sh
FILE=$1

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

Il existe trois façons distinctes de procéder:

1. Annulez le statut de sortie avec bash (aucune autre réponse ne l'a dit):

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

   Ou:

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

2. Annulez le test dans la commande test [(c'est la façon dont la plupart des réponses ont été présentées auparavant):

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

   Ou:

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

3. Agir sur le résultat du test négatif ( ||au lieu de &&):

   Seulement:

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

   Cela a l'air idiot (IMO), ne l'utilisez pas sauf si votre code doit être portable sur le shell Bourne (comme celui /bin/shde Solaris 10 ou antérieur) qui manquait de l'opérateur de négation du pipeline ( !):

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

Dans

[ -f "$file" ]

la [commande effectue un stat()(pas lstat()) appel système sur le chemin stocké dans $fileet renvoie true si cet appel système réussit et que le type de fichier renvoyé par stat()est " normal ".

Donc, si [ -f "$file" ]renvoie true, vous pouvez dire que le fichier existe et qu'il s'agit d'un fichier normal ou d'un lien symbolique qui se résout finalement en un fichier normal (ou du moins c'était au moment de lastat() ).

Cependant, si elle renvoie false (ou si [ ! -f "$file" ]ou ! [ -f "$file" ]retourne true), il existe de nombreuses possibilités différentes:

• le fichier n'existe pas
• le fichier existe mais n'est pas un habitué fichier (peut être un périphérique, fifo, répertoire, socket ...)
• le fichier existe mais vous ne disposez pas des droits de recherche sur le répertoire parent
• le fichier existe mais ce chemin d'accès est trop long
• le fichier est un lien symbolique vers un fichier standard, mais vous n'avez pas l'autorisation de recherche sur certains des répertoires impliqués dans la résolution du lien symbolique.
• ... toute autre raison pour laquelle l' stat()appel système peut échouer.

Bref, ce devrait être:

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

Pour savoir avec certitude que le fichier n'existe pas, nous aurions besoin de l' stat()appel système pour retourner avec un code d'erreur de ENOENT( ENOTDIRnous indique que l'un des composants du chemin n'est pas un répertoire est un autre cas où nous pouvons dire que le fichier ne l'est pas exister par ce chemin). Malheureusement,[ commande ne nous le fait pas savoir. Il retournera faux si le code d'erreur est ENOENT, EACCESS (autorisation refusée), ENAMETOOLONG ou autre.

Le [ -e "$file" ]test peut également être effectué avec ls -Ld -- "$file" > /dev/null. Dans ce cas, lsvous dira pourquoi l' stat()échec, bien que les informations ne puissent pas être facilement utilisées par programme:

$ 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

Au moins lsme dit que ce n'est pas parce que le fichier n'existe pas qu'il échoue. C'est parce qu'il ne peut pas dire si le fichier existe ou non. La [commande a simplement ignoré le problème.

Avec le zshshell, vous pouvez interroger le code d'erreur avec la $ERRNOvariable spéciale après la [commande en échec et décoder ce nombre à l'aide du $errnostableau spécial du zsh/systemmodule:

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

(attention, le $errnossupport a été rompu avec certaines versions de zshlors de sa construction avec des versions récentes degcc ).

Pour inverser un test, utilisez "!". Cela équivaut à l'opérateur logique "non" dans d'autres langues. Essaye ça:

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

Ou écrit d'une manière légèrement différente:

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

Ou vous pouvez utiliser:

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

Ou, en présageant tous ensemble:

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

Qui peut s'écrire (en utilisant alors l'opérateur "et": &&) comme:

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

Qui ressemble plus court à ceci:

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

La testchose peut aussi compter. Cela a fonctionné pour moi (basé sur Bash Shell: Vérifier que le fichier existe ou non ):

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

Ce code fonctionne également.

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

La manière la plus simple

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

Ce script shell fonctionne également pour trouver un fichier dans un répertoire:

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

parfois, il peut être utile d'utiliser && et || les opérateurs.

Comme dans (si vous avez la commande "test"):

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

ou

test -b $FILE || echo File there!

Si vous souhaitez utiliser à la testplace de [], vous pouvez utiliser !pour obtenir la négation:

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

Vous pouvez également regrouper plusieurs commandes dans la même ligne

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

ou

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

Si le nom de fichier ne se ferme pas, la sortie sera

test1
test2
test3

Remarque: (...) s'exécute dans un sous-shell, {...;} s'exécute dans le même shell. La notation entre accolades ne fonctionne qu'en bash.

envfile=.env

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