Existe alguma diferença importante ao comparar uma variável como uma string ou como um int

Por curiosidade, ao fazer uma comparação de variáveis ​​bash (seu valor é um integer), é possível testá-lo em relação a algum valor predefinido, declarado como intou como string.

Exemplo 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

Saída :

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

e

$  ./param.sh blah
$

Ambas as funções se comportam da mesma maneira, e então eu estou querendo saber se há uma maneira preferida ao verificar uma variável inteira? Eu iria para a verificação intversus int, pois é mais rigoroso, mas gostaria de saber se há alguma desvantagem em fazê-lo string?

Nesse caso, f2()também é mais rigoroso quanto à comparação, ou seja, passar um valor decimal o quebrará, enquanto f1()isso não causará problemas.

Sim, muitas diferenças. Por exemplo, =verifica a igualdade exata da string, mas -eqavalia as duas expressões aritmeticamente antes de verificar a igualdade:

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

Além disso, a cadeia vazia é numericamente igual a zero:

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

E toda uma outra classe de diferenças aparece quando você coloca os operadores de comparação - considerando <vs -lt, por exemplo:

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

Isso ocorre porque a sequência "2" é alfabética após a sequência "10" (já que 1 vem antes de 2), mas o número "2" é numericamente menor que o número "10".

A comparação entre números inteiros e seqüências de caracteres se torna mais significativa quando você está comparando maior ou menor que:

#!/bin/bash

eleven=11
nine=9

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

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

O primeiro falha porque 9 vem após 11 quando classificado lexicograficamente.

Observe que o uso de aspas não determina se você está comparando cadeias ou números, o operador faz. Você pode adicionar ou remover as aspas acima, isso não faz nenhuma diferença. O Bash captura variáveis ​​indefinidas entre colchetes duplos, portanto, as aspas não são necessárias. Usar aspas com colchetes simples para testes numéricos não o salvará, pois:

[ "" -lt 11 ]

de qualquer maneira, é um erro ("é necessária uma expressão inteira"). As cotações são uma salvaguarda eficaz com comparações de cadeias entre colchetes:

[ "" \< 11 ]

Observe entre parênteses duplos , mas ""será que -eq 0não == 0.

Além do que foi dito.
A comparação da igualdade é mais rápida com os números, embora nos scripts de shell seja raro que você precise de um cálculo rápido.

$ 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