Bash
Expressions conditionnelles

Syntaxe

• [[-OP $ filename]]
• [[$ file1 -OP $ file2]]
• [[-z $ string]]
• [[-n $ string]]
• [["$ string1" == "$ string2"]]
• [["$ string1" == $ pattern]]

Remarques

Comparaison de fichier

if [[ $file1 -ef $file2 ]]; then
  echo "$file1 and $file2 are the same file"
fi

"Même fichier" signifie que la modification de l'un des fichiers en place affecte l'autre. Deux fichiers peuvent être identiques même s'ils ont des noms différents, par exemple s'il s'agit de liens matériels ou de liens symboliques avec la même cible, ou s'il s'agit d'un lien symbolique pointant vers l'autre.

Si deux fichiers ont le même contenu, mais qu'il s'agit de fichiers distincts (de sorte que la modification de l'un n'affecte pas l'autre), alors -ef signale comme étant différents. Si vous souhaitez comparer deux fichiers octet par octet, utilisez l'utilitaire cmp .

if cmp -s -- "$file1" "$file2"; then
  echo "$file1 and $file2 have identical contents"
else
  echo "$file1 and $file2 differ"
fi

Pour produire une liste lisible par l'homme des différences entre les fichiers texte, utilisez l'utilitaire diff .

if diff -u "$file1" "$file2"; then
  echo "$file1 and $file2 have identical contents"
else
  : # the differences between the files have been listed
fi

Tests d'accès aux fichiers

if [[ -r $filename ]]; then
  echo "$filename is a readable file"
fi
if [[ -w $filename ]]; then
  echo "$filename is a writable file"
fi
if [[ -x $filename ]]; then
  echo "$filename is an executable file"
fi

Ces tests prennent en compte les autorisations et la propriété pour déterminer si le script (ou les programmes lancés à partir du script) peuvent accéder au fichier.

Méfiez-vous des conditions de course (TOCTOU) : le fait que le test réussisse maintenant ne signifie pas qu'il est toujours valide sur la ligne suivante. Il est généralement préférable d’essayer d’accéder à un fichier et de traiter l’erreur plutôt que d’essayer d’abord et de gérer ensuite l’erreur au cas où le fichier aurait changé entre-temps.

Comparaisons numériques

Les comparaisons numériques utilisent les opérateurs et amis -eq

if [[ $num1 -eq $num2 ]]; then
  echo "$num1 == $num2"
fi
if [[ $num1 -le $num2 ]]; then
  echo "$num1 <= $num2"
fi

Il y a six opérateurs numériques:

• -eq égal
• -ne pas égal
• -le moins ou égal
• -lt moins que
• -ge plus grand ou égal
• -gt supérieur à

Notez que les opérateurs < et > intérieur de [[ … ]] comparent des chaînes, pas des nombres.

if [[ 9 -lt 10 ]]; then
  echo "9 is before 10 in numeric order"
fi
if [[ 9 > 10 ]]; then
  echo "9 is after 10 in lexicographic order"
fi

Les deux côtés doivent être des nombres écrits en décimal (ou en octal avec un zéro non significatif). Vous pouvez également utiliser la syntaxe d'expression arithmétique ((…)) , qui effectue des calculs d' entiers dans une syntaxe similaire à C / Java /….

x=2
if ((2*x == 4)); then
  echo "2 times 2 is 4"
fi
((x += 1))
echo "2 plus 1 is $x"

Comparaison de chaînes et correspondance

La comparaison de chaînes utilise l'opérateur == entre des chaînes entre guillemets . L'opérateur != Annule la comparaison.

if [[ "$string1" == "$string2" ]]; then
  echo "\$string1 and \$string2 are identical"
fi
if [[ "$string1" != "$string2" ]]; then
  echo "\$string1 and \$string2 are not identical"
fi

Si le membre de droite n'est pas cité, c'est un modèle générique auquel $string1 est associé.

string='abc'
pattern1='a*'
pattern2='x*'
if [[ "$string" == $pattern1 ]]; then
  # the test is true
  echo "The string $string matches the pattern $pattern"
fi
if [[ "$string" != $pattern2 ]]; then
  # the test is false
  echo "The string $string does not match the pattern $pattern"
fi

Les opérateurs < et > comparent les chaînes dans l'ordre lexicographique (il n'y a pas d'opérateur moins ou moins égal ou plus grand que les chaînes).

Il y a des tests unaires pour la chaîne vide.

if [[ -n "$string" ]]; then
  echo "$string is non-empty"
fi
if [[ -z "${string// }" ]]; then
  echo "$string is empty or contains only spaces"
fi
if [[ -z "$string" ]]; then
  echo "$string is empty"
fi

Au-dessus, la vérification -z peut signifier que $string n'est pas défini ou qu'elle est définie sur une chaîne vide. Pour distinguer entre vide et non défini, utilisez:

if [[ -n "${string+x}" ]]; then
    echo "$string is set, possibly to the empty string"
fi
if [[ -n "${string-x}" ]]; then
    echo "$string is either unset or set to a non-empty string"
fi
if [[ -z "${string+x}" ]]; then
    echo "$string is unset"
fi
if [[ -z "${string-x}" ]]; then
    echo "$string is set to an empty string"
fi

où x est arbitraire. Ou sous forme de tableau :

                        +-------+-------+-----------+
            $string is: | unset | empty | non-empty |
+-----------------------+-------+-------+-----------+
| [[ -z ${string} ]]    | true  | true  | false     |
| [[ -z ${string+x} ]]  | true  | false | false     |
| [[ -z ${string-x} ]]  | false | true  | false     |
| [[ -n ${string} ]]    | false | false | true      |
| [[ -n ${string+x} ]]  | false | true  | true      |
| [[ -n ${string-x} ]]  | true  | false | true      |
+-----------------------+-------+-------+-----------+

Sinon , l'état peut être vérifié dans une déclaration de cas:

case ${var+x$var} in
  (x) echo empty;;
  ("") echo unset;;
  (x*[![:blank:]]*) echo non-blank;;
  (*) echo blank
esac

Où [:blank:] est un caractère d'espacement horizontal spécifique aux paramètres régionaux (tabulation, espace, etc.).

Tests de type de fichier

L'opérateur conditionnel -e teste si un fichier existe (y compris tous les types de fichiers: répertoires, etc.).

if [[ -e $filename ]]; then
  echo "$filename exists"
fi

Il existe également des tests pour des types de fichiers spécifiques.

if [[ -f $filename ]]; then
  echo "$filename is a regular file"
elif [[ -d $filename ]]; then
  echo "$filename is a directory"
elif [[ -p $filename ]]; then
  echo "$filename is a named pipe"
elif [[ -S $filename ]]; then
  echo "$filename is a named socket"
elif [[ -b $filename ]]; then
  echo "$filename is a block device"
elif [[ -c $filename ]]; then
  echo "$filename is a character device"
fi
if [[ -L $filename ]]; then
  echo "$filename is a symbolic link (to any file type)"
fi

Pour un lien symbolique, hormis -L , ces tests s'appliquent à la cible et renvoient false pour un lien rompu.

if [[ -L $filename || -e $filename ]]; then
  echo "$filename exists (but may be a broken symbolic link)"
fi

if [[ -L $filename && ! -e $filename ]]; then
  echo "$filename is a broken symbolic link"
fi

Test sur l'état de sortie d'une commande

Statut de sortie 0: succès
Etat de sortie autre que 0: échec

Pour tester le statut de sortie d'une commande:

if command;then
    echo 'success'
else
    echo 'failure'
fi

Un test de ligne

Vous pouvez faire des choses comme ceci:

[[ $s = 'something' ]] && echo 'matched' || echo "didn't match"
[[ $s == 'something' ]] && echo 'matched' || echo "didn't match"
[[ $s != 'something' ]] && echo "didn't match" || echo "matched"
[[ $s -eq 10 ]] && echo 'equal' || echo "not equal"
(( $s == 10 )) && echo 'equal' || echo 'not equal'

Un test de ligne pour le statut de sortie:

command && echo 'exited with 0' || echo 'non 0 exit'
cmd && cmd1 && echo 'previous cmds were successful' || echo 'one of them failed'
cmd || cmd1 #If cmd fails try cmd1