Comando bash let builtin
Em sistemas operacionais do tipo Unix, let é um comando interno do shell Bash que avalia expressões aritméticas.
Descrição
Usar let é semelhante a incluir uma expressão aritmética entre parênteses duplos, por exemplo:
(( expr ))
No entanto, ao contrário de (( … )) , que é um comando composto , let é um comando interno. Como tal, seus argumentos individuais estão sujeitos a expansão por bash. Por exemplo, permita que os argumentos passem por globbing , expansão do nome do caminho e divisão de palavras, a menos que você coloque os argumentos individuais entre aspas duplas.
Na maioria das situações, é preferível usar parênteses duplos para avaliar expressões aritméticas. No entanto, é importante entender como let é diferente e usá-lo quando apropriado.
Como todos os comandos simples, let tem seu próprio ambiente. Variáveis usadas em expressões têm escopo local para o comando. Assim, por exemplo, um argumento para deixar não estará ciente de outras variáveis de shell, a menos que sejam exportadas .
A exceção é sempre que let avalia uma expressão que define explicitamente o valor de uma variável. Nesse caso, o valor dessa variável persiste no shell atual. (Se isso soa um pouco complicado, é porque é. Veja abaixo exemplos .)
Sintaxe
deixe arg [ arg ...]
Descrição
let avalia cada argumento, arg , como uma expressão matemática. Os argumentos são avaliados da esquerda para a direita.
Todos os números são representados internamente como números inteiros de largura fixa. (O Bash não suporta aritmética de ponto flutuante.)
Nenhuma verificação de estouro é executada, portanto, operações em números inteiros muito grandes podem produzir um resultado inesperado, sem causar erros.
A divisão por zero é detectada, no entanto, e causa um erro.
Operadores aritméticos
Ao avaliar uma expressão, vamos interpreta os seguintes operadores matemáticos e executa a operação correspondente. Na tabela abaixo, os operadores são listados linha por linha em ordem decrescente de precedência . Os operadores listados na mesma linha têm a mesma precedência.
| Operador | Operação |
|---|---|
| var ++ , var – | Pós-incremento ( ++ ), Pós-decremento ( – ). Interprete o valor da variável inteira var e adicione ou subtraia um (1) a ela. |
| ++ var , – var | Pré-incremento ( ++ ), Pré-decremento ( – ). Adicione ou subtraia um (1) ao valor da variável inteira var e, em seguida, interprete o valor. |
| – expr , + expr | Unário menos, Unário mais. Unário menos retorna o valor da expressão expr que precede, como se tivesse sido multiplicada pela negativa (-1). Unary plus retorna a expressão expr inalterada, como se tivesse sido multiplicada por um (1). |
| ! , ~ | Negação lógica , negação bit a bit . A negação lógica retorna falso se seu operando for verdadeiro e verdadeiro se o operando for falso. A negação bit a bit inverte os bits na representação binária do operando numérico. |
| ** | Exponenciação. |
| * , / , % | Multiplicação, Divisão, Restante (módulo). |
| + , – | Adição subtração. |
| << , >> | Deslocar bit a esquerda, deslocar bit a direita. |
| <= , > = , < , > | Comparação: Menor que ou igual a, Maior que ou igual a, Menor que, Maior que. |
| == ,! = | Igualdade, Desigualdade. A igualdade retorna true se seus operandos forem iguais, false caso contrário. A desigualdade retorna true se seus operandos não forem iguais, false caso contrário. |
| & | AND bit a bit. Os dígitos binários correspondentes de ambos os operandos são multiplicados para produzir um resultado; para qualquer dígito, o dígito resultante é 1 se e somente se o dígito correspondente nos dois operandos também for 1 . |
| ^ | XOR bit a bit (OR eXclusivo). Um dígito binário do resultado é 1 se e somente se os dígitos correspondentes dos operandos diferirem. Por exemplo, se o primeiro dígito binário do primeiro operando for 1 e o primeiro dígito do segundo operando for 0 , o primeiro dígito do resultado será 1 . |
| | | OR bit a bit. Se um dos dígitos correspondentes nos operandos for 1 , esse dígito no resultado também será 1 . |
| && | AND lógico. Retorna true se os dois operandos forem verdadeiros. |
| || | OR lógico. Retorna true se um dos operandos for verdadeiro. |
| expr1 ? expr2 : expr3 | Operador condicional ( ternário ). Se expr1 for verdadeiro, retorne expr2 . Se expr1 for falso, retorne expr3 . |
| = , * = , / = , % = , + = , – = , << = , >> = , & = , ^ = , | = | Tarefa. Atribua o valor da expressão que segue o operador à variável que a precede. Se um operador prefixar o sinal de igual, essa operação será executada antes da atribuição. Por exemplo, let “var + = 5” é equivalente a let “var = var + 5” . A operação de atribuição em si avalia o valor atribuído. |
Status de saída
Se o argumento mais à direita fornecido para permitir for avaliado como zero (aritmeticamente falso), o status de saída será 1 (status de saída FALSO).
Se o argumento mais à direita fornecido para permitir avaliar como diferente de zero (aritmeticamente verdadeiro), o status de saída será 0 (status de saída TRUE).
Outras maneiras de avaliar aritmética
Antes de começarmos a usar let , vejamos outras maneiras de fazer coisas semelhantes no bash. Então veremos como deixar é um pouco diferente.
Para começar, defina o valor de uma variável. Você pode fazer isso no bash sem deixar , usando o formulário varname = value . Por exemplo:
myvar = 5
Observe que não há espaço antes ou depois do sinal de igual. Se você colocar um espaço antes do = , o bash assume que myvar é um nome de comando. Por exemplo:
myvar = 5
myvar: comando não encontrado
Da mesma forma, você receberá um erro se colocar um espaço após o sinal de igual:
myvar = 5
5: comando não encontrado
Bash interpreta o comando acima como: “Com myvar igual a nada, execute o comando 5 “. Portanto, ao atribuir variáveis dessa maneira no bash, certifique-se de não usar espaços ao redor do sinal de igual.
Por padrão, as variáveis bash são “sem tipo de letra” – elas não têm um tipo de dados inerente. Por exemplo, você pode atribuir um número inteiro ou um valor de sequência a uma variável sem tipo. Portanto, se tentarmos atribuir “5 + 5” a myvar , ele será atribuído literalmente , como uma string, e nenhuma matemática será executada nela.
myvar = "5 + 5"; echo $ myvar
5 + 5
No entanto, se desejar, você pode declarar uma variável como tipo inteiro usando o comando declare builtin. O uso de declare -i define o atributo “número inteiro” para sua variável, o que permite a avaliação aritmética ao atribuir valor.
declare -i myvar; myvar = "5 + 5"; echo $ myvar
10
Antes de continuarmos, vamos desarmar o atributo inteiro, tornando a variável sem tipo novamente. Você pode fazer isso usando um sinal de adição, em vez de um traço, na frente da letra da opção:
declarar + i myvar
Outra maneira de executar a avaliação aritmética de uma expressão é colocá-la entre parênteses duplos:
((myvar = 6 + 6)); echo $ myvar
12
Observe que myvar está entre parênteses duplos: a atribuição de variável faz parte da expressão. Além disso, observe que não há problema em ter espaços antes e depois do sinal de igual em uma expressão aritmética.
Para retornar o valor de uma expressão aritmética diretamente, para que seu resultado possa ser usado como parte de uma instrução maior, prefixe os parênteses duplos com um sinal de dólar (” $ “), assim:
eco $ ((7 + 7))
14
Usando o cifrão, o resultado final da expressão é retornado como o valor. Usando essa sintaxe, não precisamos definir uma variável para usar o valor posteriormente.
Além disso, observe que expressões entre parênteses duplos podem ser aninhadas :
echo $ ((myvar = 7 + $ ((vartwo = 4 + 4)))))
15
echo $ vartwo
8
Agora vamos executar alguns exemplos de comandos usando let .
Exemplos
deixe "myvar = 5"; echo $ myvar
Defina a variável myvar para o valor 5 e , em seguida, faça eco do valor de myvar no terminal. Resultado:
5
deixe "varone = 1" "vartwo = varone ++"; eco $ varone, $ vartwo
Defina varone como 1 , defina vartwo com o valor de varone e depois aumente o valor de varone em um. Resultado:
2, 1
deixe "varone = 1" "vartwo = ++ varone"; eco $ varone, $ vartwo
Defina varone como 1 , aumente o valor de varone em um e, em seguida, defina o valor de vartwo como o valor de varone . Resultado:
2, 2
deixe "myvar = 48% 5"; echo $ myvar
Defina myvar para o restante de 48 dividido por 5 (que é 3 ). Resultado:
3
deixe "myvar = 16 << 2"; echo $ myvar
Defina myvar como o número 16 , com deslocamento de bits para a esquerda duas vezes (o que dá o mesmo resultado que a multiplicação por 2, duas vezes). Resultado:
64
deixe "myvar = 16 >> 2"; echo $ myvar
Defina myvar como o número 16 , com desvio de bits duas vezes à direita (o que resulta no mesmo resultado que a divisão por 2, duas vezes). Resultado:
4
deixe "myvar = 5, myvar * = 2"; echo $ myvar
Defina myvar como 5 e defina myvar como seu próprio valor multiplicado por 2 . Observe que neste exemplo, instruções seqüenciais são separadas por vírgula. Resultado:
10
bar = 5 deixe "foo = bar"; eco $ foo, $ bar
Defina a barra como 5 e , em seguida, defina o valor da barra como foo . Quando o bash processa o próximo comando (” echo $ foo, $ bar “), ele conhece o foo porque seu valor foi definido na expressão, mas não o conhece porque o valor da barra era local para o comando anterior. Resultado:
5
bar = 5 deixe "foo = bar, bar ++"; eco $ foo, $ bar
Semelhante ao comando acima, mas desta vez, vamos alterar o valor da barra incrementando-a, para que o escopo da barra se torne o shell atual e o comando echo esteja ciente de seu valor. Resultado:
5, 6
Comandos relacionados
eval – Avalie argumentos e execute-os como um comando.