Existe-t-il une différence majeure lors de la comparaison d'une variable sous forme de chaîne ou d'int

Par curiosité, lors de la comparaison d'une variable bash (sa valeur étant un integer), il est possible de la tester par rapport à une valeur prédéfinie déclarée en tant que intou en tant que string.

Exemple de script :

#!/bin/bash
f1()
{
        [ "$1" == "1" ] && echo "$FUNCNAME: \"1\" compared as string"
}

f2()
{
        [[ "$1" -eq 1 ]] && echo "$FUNCNAME: \"1\" compared as int"
}

f1 $1
f2 $1

Sortie :

$  ./param.sh 1
f1: "1" compared as string
f2: "1" compared as int

et

$  ./param.sh blah
$

Les deux fonctions se comportent de la même manière, et je me demande donc s'il existe une méthode préférée lors de la vérification d'une variable entière? J'irais pour la vérification intcontre intcar c'est plus strict mais je me demande s'il y a des inconvénients à le faire string?

Dans ce cas, f2()la comparaison est également plus stricte, c'est-à-dire que le passage d'une valeur décimale la cassera, alors que f1()cela ne posera aucun problème.

Oui, beaucoup de différences. Par exemple, =vérifie l'égalité exacte des chaînes, mais -eqévalue les deux expressions de manière arithmétique avant de vérifier l'égalité:

$ [ " 1 " -eq 1 ] && echo equal || echo not
equal
$ [ " 1 " = 1 ] && echo equal || echo not
not

$ [ +1 -eq 1 ] && echo equal || echo not
equal
$ [ +1 = 1 ] && echo equal || echo not
not

$ [ "0+1" -eq 1 ] && echo equal || echo not
equal
$ [ "0+1" = 1 ] && echo equal || echo not
not

De plus, la chaîne vide se trouve être numériquement égale à zéro:

$ [ "" -eq 0 ] && echo equal || echo not
equal
$ [ "" = 0 ] && echo equal || echo not
not

Et une toute autre classe de différences apparaît lorsque vous intégrez les opérateurs de comparaison - en considérant <vs -lt, par exemple:

$ [[ 2 -lt 10 ]] && echo less || echo not
less
$ [[ 2 < 10 ]] && echo less || echo not
not

Cela est dû au fait que la chaîne "2" est alphabétiquement après la chaîne "10" (puisque 1 vient avant 2), mais le nombre "2" est numériquement inférieur au nombre "10".

La comparaison entiers vs chaînes devient plus significative lorsque vous comparez plus ou moins que:

#!/bin/bash

eleven=11
nine=9

[[ $nine < $eleven ]] && echo string   # fail

[[ "$nine" -lt "$eleven" ]] && echo integer # pass

Le premier échoue car 9 vient après 11 lorsqu'il est trié lexicographiquement.

Notez que l'utilisation de guillemets ne détermine pas si vous comparez des chaînes ou des nombres, l'opérateur le fait. Vous pouvez ajouter ou supprimer les citations ci-dessus, cela ne fait aucune différence. Bash capture les variables non définies entre crochets, donc les guillemets ne sont pas nécessaires. L'utilisation de guillemets avec des crochets simples pour les tests numériques ne vous sauvera pas puisque:

[ "" -lt 11 ]

est quand même une erreur ("expression entière requise"). Les citations sont une sauvegarde efficace avec des comparaisons de chaînes entre crochets simples:

[ "" \< 11 ]

Remarque dans les doubles crochets, ""seront , -eq 0mais pas == 0.

En plus de ce qui a été dit.
La comparaison pour l'égalité est plus rapide avec les nombres, bien que dans les scripts shell, il soit rare que vous ayez besoin d'un calcul rapide.

$ b=234
$ time for ((a=1;a<1000000;a++)); do [[ $b = "234" ]]; done

real    0m13.008s
user    0m12.677s
sys 0m0.312s

$ time for ((a=1;a<1000000;a++)); do [[ $b -eq 234 ]]; done

real    0m10.266s
user    0m9.657s
sys 0m0.572s