paulo1205
(usa Ubuntu)
Enviado em 14/10/2022 - 02:29h
Minions escreveu:
O if fi só funciona com numero inteiro?
Não. O comando
if apenas verifica se o código de retorno de um outro comando é verdadeiro ou falso, e desvia o fluxo de execução de acordo com esse resultado.
Considere a seguinte construção.
if getent passwd paulo > /dev/null; then
echo 'Existe um usuário chamado "paulo".'
else
echo 'Não foi encontrado nenhum usuário chamado "paulo".' >&2
fi
Tal trecho faz exatamente o seguinte:
1. Chama o comando externo
getent para verificar se existe um usuário cujo
login seja "paulo", redirecionando a saída para
/dev/null, para que nada seja impresso na tela como parte da consulta. Se o usuário for encontrado, o comando vai retornar o código de retorno
0 (que o shell interpreta como verdadeiro); caso contrário, o código retornado será
2 (qualquer valor diferente de zero é considerado como falso).
2. O comando
if automaticamente intercepta o código de saída do comando recém-executado e desvia o fluxo de execução de acordo: se esse código for verdadeiro, vai executar o bloco iniciado por
then e terminado pela próxima ocorrência de
elif,
else ou
fi; caso contrário, ele vai pular sobre tal bloco, e desviando justamente para o ponto onde for encontrado o
elif,
else ou
fi que o termina.
Quando você tem uma construção tal como “
if [ $a -lt $b ]”, vai acontecer a mesma coisa: o
shell vai executar o comando
[, e é esse comando que efetivamente vai realizar o teste condicional, devolvendo ao
if apenas um código de saída que vai ser interpretado como verdadeiro ou falso.
Originalmente, o comando
[ era apenas o comando externo, figurando como um executável com nome
/bin/[, que normalmente tinha como nome alternativo
/bin/test (i.e. era um outro
hard link para o mesmo
inode), sendo que a única diferença entre esses dois era que o comando, quando invocado com o nome
test, não exigia o terminador sintático “
]”, ao passo que esse terminador era exigido quando o comando era invocado com o nome
[. Entretanto, como era muito ineficiente chamar um comando externo a cada vez que se precisava realizar um teste condicional, alguns
shells (provavelmente iniciando com o
ksh de 1988) passaram a implementar uma versão interna desse comando, chamando-a de
[[, em vez de simplesmente
[, que trazia ganhos de desempenho não apenas por não exigir a invocação de um comando externo, mas também por não executar num processo separado, mas sim no mesmo processo em que foi invocado. Além disso, com um comando de teste de expressões interno, o
shell podia acrescentar novos operadores, tal como
-o, que permite verificar se o
shell uma determinada opção de execução do
shell está ativa ou não, algo que não é possível de se fazer quando se invoca um comando externo.
Além do
[[, o
ksh também introduziu uma forma totalmente interna de avaliar operações aritméticas, algo que o
shell original também não tinha. Se uma variável
n tinha um valor numérico, e a pessoa queria acrescentar
1 ao valor corrente dessa variável, o
sh original exigia que se fizesse algo parecido com “
v=`expr $v + 1`”, invocando o comando externo
expr e interceptando a saída que esse comando imprimia e substituindo com ela o valor da variável. Com o
ksh, surgiram as construções
((expressão)), que serve para avaliar uma expressão aritmética ou lógica, inclusive aquelas envolvendo variáveis, e
$((expressão)), que faz o mesmo processamento de expressão aritmética e substitui o valor do resultado como parte da linha de comando.
var=1
echo $((var+1)) # imprime “2”
((var=10*var+1)) # agora var vai valer 11.
echo $(((var*=2)+2)) # agora var vai valer 22, e o comando echo vai imprimir “24”
Com o tempo, outros
shells adotaram alguns dos comandos internos
[[ expressão ]] e
((expressão)) e substituições aritmética
$((expressão)) e de interceptação de saída
$(comando) (que é semelhante em efeito à antiga forma
`comando`, mas que, ao contrário desta última, permite aninhamentos). Diferentes
shells adotaram diferentes conjuntos ou subconjuntos desses recursos.
O
ksh93 introduziu aritmética de ponto flutuante, no que foi seguido pelo
zsh, mas não pelo Bash e demais
shells.
Eis um pequeno exemplo de programa em ksh93 usando aritmética de ponto flutuante.
#!/bin/ksh93
typeset -E a b # Define que as variáveis ‘a’ e ‘b’ vão guardar apenas dados de ponto flutuante.
a=0
((b=cos(a))) # Usa comando de avaliação aritmética para calcular o cosseno de 0
n=0
while ((a!=b)); do # Usa comando de avaliação aritmética para comparar os valores de a e b, e o seu código de retorno é usado pelo comando while para saber se continua executando o laço de repetição.
((a=b, b=cos(a), ++n)) # Comando de avaliação aritmética usando o operador “,”, para fazer três operações diferentes em sequência: copiar o valor de b para a, calcular o novo valor de b como sendo o cosseno de a, e incrementar o valor de n.
done
echo "$a=cos($a) após $n iterações."
... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)
