C'è qualche differenza sostanziale quando si confronta una variabile come stringa o come int

Per curiosità, quando si esegue un confronto di variabili bash (il cui valore è un integer) è possibile testarlo con un valore predefinito dichiarato come into come string.

Script di esempio :

#!/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

Uscita :

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

e

$  ./param.sh blah
$

Entrambe le funzioni si comportano allo stesso modo, quindi mi chiedo se esiste un modo preferito quando si controlla una variabile intera? Vorrei fare un controllo intrispetto intal fatto che è più rigoroso, ma mi chiedo se ci siano degli svantaggi nel farlo string?

In questo caso, f2()è anche più rigoroso il confronto, vale a dire che passare un valore decimale lo interromperà, mentre non f1()lo prenderà nessun problema.

Sì, molte differenze. Ad esempio, =verifica l'uguaglianza esatta delle stringhe, ma -eqvaluta entrambe le espressioni in modo aritmetico prima di verificare l'uguaglianza:

$ [ " 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

Inoltre, la stringa vuota risulta numericamente uguale a zero:

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

E tutta un'altra classe di differenze appare quando si inseriscono gli operatori di confronto - considerando <vs -lt, ad esempio:

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

Questo perché la stringa "2" è in ordine alfabetico dopo la stringa "10" (poiché 1 precede 2), ma il numero "2" è numericamente inferiore al numero "10".

Il confronto tra numero intero e stringa diventa più significativo quando si confronta un valore maggiore o minore di:

#!/bin/bash

eleven=11
nine=9

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

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

Il primo fallisce perché 9 viene dopo 11 se ordinato lessicograficamente.

Si noti che l'uso delle virgolette non determina se si stanno confrontando stringhe o numeri, come fa l'operatore. È possibile aggiungere o rimuovere le virgolette sopra, non fa alcuna differenza. Bash rileva variabili indefinite tra parentesi doppie, quindi le virgolette non sono necessarie. L'uso delle virgolette con parentesi singole per i test numerici non ti salverà dal momento che:

[ "" -lt 11 ]

è comunque un errore ("espressione intera richiesta"). Le virgolette sono una protezione efficace con confronti di stringhe tra parentesi singole:

[ "" \< 11 ]

Nota tra parentesi doppie , ""sarà -eq 0ma non == 0.

Oltre a quanto detto.
Il confronto per l'uguaglianza è più veloce con i numeri, anche se negli script di shell è raro che sia necessario un calcolo rapido.

$ 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