Lógica da linha de comando do Linux por OnWorks

Ir para o conteúdo

Lógica

Como descobrimos no Capítulo 27, o (()) O comando composto oferece suporte a uma variedade de operadores de comparação. Existem mais alguns que podem ser usados para avaliar a lógica. Aqui está a lista completa:

Tabela 34-6: Operadores de comparação

Descrição do operador

<= Menor ou igual a

> = Maior ou igual a

<Menor que

> Maior que

== Igual a

! = Diferente de

&& Logical AND

|| OR lógico

expr1?expr2:expr3 Operador de comparação (ternário). Se expressão expr1

avalia como sendo diferente de zero (aritmética verdadeira), então expr2, outro expr3.

Quando usadas para operações lógicas, as expressões seguem as regras da lógica aritmética; ou seja, expressões avaliadas como zero são consideradas falsas, enquanto expressões diferentes de zero são consideradas verdadeiras. o (()) O comando composto mapeia os resultados nos códigos de saída normais do shell:

[me @ linuxbox ~] $ if ((1)); então echo "true"; senão echo "false"; fi

verdadeiro

[me @ linuxbox ~] $ if ((0)); então echo "true"; senão echo "false"; fi

falso

[me @ linuxbox ~] $ if ((1)); então echo "true"; senão echo "false"; fi

verdadeiro

[me @ linuxbox ~] $ if ((0)); então echo "true"; senão echo "false"; fi

falso

O mais estranho dos operadores lógicos é o operador ternário. Este operador (que é modelado após aquele na linguagem de programação C) executa um teste lógico autônomo. Pode ser usado como uma espécie de instrução if / then / else. Ele atua em três expressões aritméticas (strings não funcionam), e se a primeira expressão for verdadeira (ou diferente de zero), a segunda expressão é executada. Caso contrário, a terceira expressão é executada. Podemos tentar isso na linha de comando:

[me @ linuxbox ~] $ a = 0 [me @ linuxbox ~] $ ((a <1? ++ a: - a)) [me @ linuxbox ~] $ echo $ a

1

[me @ linuxbox ~] $ ((a <1? ++ a: - a))

[me @ linuxbox ~] $ echo $ a

0

[me @ linuxbox ~] $ a = 0 [me @ linuxbox ~] $ ((a <1? ++ a: - a)) [me @ linuxbox ~] $ echo $ a

1

[me @ linuxbox ~] $ ((a <1? ++ a: - a))

[me @ linuxbox ~] $ echo $ a

0

Aqui, vemos um operador ternário em ação. Este exemplo implementa uma alternância. Cada vez que o operador é executado, o valor da variável a muda de zero para um ou vice-versa.

Observe que realizar a atribuição nas expressões não é simples.

Quando tentado, bater irá declarar um erro:

[me @ linuxbox ~] $ a = 0

[me @ linuxbox ~] $ ((a <1? a + = 1: a- = 1))

bash: ((: a <1? a + = 1: a- = 1: tentativa de atribuição a não variável (token de erro é "- = 1")

[me @ linuxbox ~] $ a = 0

[me @ linuxbox ~] $ ((a <1? a + = 1: a- = 1))

bash: ((: a <1? a + = 1: a- = 1: tentativa de atribuição a não variável (token de erro é "- = 1")

Este problema pode ser mitigado cercando a expressão de atribuição entre parênteses:

[me @ linuxbox ~] $ ((a <1? (a + = 1) :( a- = 1)))

A seguir, vemos um exemplo mais completo do uso de operadores aritméticos em um script que produz uma tabela simples de números:

#! / Bin / bash

# arith-loop: script para demonstrar operadores aritméticos terminado = 0

a = 0

printf "a \ ta ** 2 \ ta ** 3 \ n" printf "= \ t ==== \ t ==== \ n"

até ((terminado)); faça b = $ ((a ** 2))

c = $ ((a ** 3))

printf "% d \ t% d \ t% d \ n" $ a $ b $ c ((a <10? ++ a: (concluído = 1)))

feito

#! / Bin / bash

# arith-loop: script para demonstrar operadores aritméticos terminado = 0

a = 0

printf "a \ ta ** 2 \ ta ** 3 \ n" printf "= \ t ==== \ t ==== \ n"

até ((terminado)); faça b = $ ((a ** 2))

c = $ ((a ** 3))

printf "% d \ t% d \ t% d \ n" $ a $ b $ c ((a <10? ++ a: (concluído = 1)))

feito

Neste script, implementamos um loop until com base no valor do acabado variável. Inicialmente, a variável é definida como zero (falsa aritmética) e continuamos o loop até que se torne diferente de zero. Dentro do loop, calculamos o quadrado e o cubo da variável do contador

uma. No final do loop, o valor da variável do contador é avaliado. Se for menor que 10 (o número máximo de iterações), é incrementado em um, caso contrário, a variável finalizada recebe o valor de um, tornando finalizado aritmeticamente verdadeiro, encerrando assim o loop. A execução do script fornece este resultado:

[me @ linuxbox ~] $ loop aritmético

a

= 0

1

2

3

4

5

6

7

8

9