Présentation
Bash let est une commande intégrée dans les systèmes Linux utilisée pour évaluer les expressions arithmétiques. Contrairement à d'autres commandes d'évaluation et d'expansion arithmétiques, let est une commande simple avec son propre environnement. La let La commande permet également l'expansion arithmétique.
Dans ce didacticiel, nous allons passer en revue la syntaxe de la commande let, les options et les exemples d'utilisation.
Prérequis
- Un système exécutant une distribution Linux
- Accès à la fenêtre du terminal ou à la ligne de commande
Syntaxe de l'instruction let bash
La let La commande utilise la syntaxe de base suivante :
let [expression]
Dans la syntaxe ci-dessus, expression est une expression arithmétique dont vous voulez le let commande à évaluer. let ne fonctionne qu'avec des expressions contenant des nombres entiers. La commande ne prend pas en charge les nombres à virgule flottante .
La let La commande permet aux utilisateurs d'évaluer plusieurs expressions simultanément. Dans ce cas, la syntaxe est :
let [expression 1] [expression 2] … [expression 3]let opérateurs arithmétiques
Le let de Bash La commande est capable d'évaluer les expressions qui contiennent les opérateurs arithmétiques du tableau ci-dessous. Les entrées sont répertoriées dans l'ordre de priorité décroissante, avec les opérateurs de même priorité répertoriés sur la même ligne :
| Opérateur | Description |
var++ var-- | Post-incrémentation (++) : Interpréter la valeur d'une variable et lui ajouter 1. Post-décrémentation (--) : Interpréter la valeur d'une variable et en soustraire 1. |
++var --var | Pré-incrémentation (++) : Ajoutez 1 à la valeur d'une variable, puis interprétez la valeur. Pré-décrémentation (--) : Soustrayez 1 de la valeur d'une variable, puis interprétez la valeur. |
-expr +expr | Moins unaire : Renvoie la valeur de l'expression multipliée par -1. Plus unaire : Renvoie la valeur de l'expression inchangée (multipliée par 1). |
! ~ | Négation logique : Renvoie faux si l'opérande est vrai et vrai si l'opérande est faux. Négation au niveau du bit : Inversez les bits dans la représentation binaire d'un nombre. |
** | Exponentiation : Élever un entier à la puissance d'un autre. |
* / % | Opérateurs arithmétiques de base : Multiplication. Division. Reste (modulo). |
+ - | Opérateurs arithmétiques de base : Une addition. Soustraction. |
<< >> | Décalage bit à gauche. Décalage au niveau du bit vers la droite. |
<= >= < > | Comparaison des valeurs : Inférieur ou égal à. Plus grand ou égal à. Moins que. Supérieur à. |
== != | Égalité : Renvoie vrai si les opérandes sont égaux. Inégalité : Renvoie faux si les opérandes sont égaux. |
& | ET bit à bit : Multiplie les chiffres correspondants de deux valeurs binaires. |
^ | XOR bit à bit : Compare les chiffres correspondants de deux valeurs binaires et renvoie 1 si les chiffres diffèrent. |
| | OU binaire : Compare les chiffres correspondants de deux valeurs binaires et renvoie 1 si l'un des chiffres est un 1. |
&& | ET logique : Renvoie vrai si les deux opérandes sont vrais. |
|| | OU logique : Renvoie vrai si l'un des opérandes est vrai. |
expr1 ? expr2 : expr3 | Opérateur conditionnel : Si expr1 est vrai, renvoie expr2 . Si expr1 est faux, renvoie expr3 . |
=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |= | Affectation : Attribuez une valeur à une variable. |
Exemples de let bash
La let La commande vous permet d'attribuer des valeurs aux variables et d'effectuer des opérations arithmétiques, au niveau du bit et logiques. Lisez les sections ci-dessous pour des exemples.
Attribuer une valeur à une variable
Utilisez le let commande pour affecter une valeur à une variable avec :
let "[variable] = [value]"Par exemple, attribuez la valeur 5 à la variable var1 et imprimez la valeur en sortie :
let "var1 = 5"; echo $var1
De même, après avoir défini une valeur de variable, le let permet d'affecter la même valeur à une autre variable :
let "var1 = 5" "var2=var1"; echo $var2
Effectuer des opérations arithmétiques de base
Après avoir défini les valeurs des variables, utilisez le let commande pour effectuer des opérations arithmétiques de base. Par exemple, définissez var1 comme 6 et var2 comme 2 et effectuer l'addition, la soustraction, la multiplication, la division et le module :
let "var1 = 6" "var2 = 2" "var3=var1+var2"; echo $var3
let "var1 = 6" "var2 = 2" "var3=var1-var2"; echo $var3
let "var1 = 6" "var2 = 2" "var3=var1*var2"; echo $var3
let "var1 = 6" "var2 = 2" "var3=var1/var2"; echo $var3
let "var1 = 6" "var2 = 2" "var3=var1%var2"; echo $var3
Dans cet exemple, le let la commande définit la valeur de var3 comme résultat de l'opération arithmétique et imprime le résultat.
Exécution de l'exponentiation
La let la commande nécessite deux valeurs entières pour effectuer une exponentiation . La première valeur (base ) est élevé à la puissance de la seconde valeur (power ):
let "[base] ** [power]"Par exemple, pour élever la valeur de base de 3 à la puissance 2 et imprimer le résultat, utilisez cette commande :
let "var1 = 3 ** 2"; echo $var1
Exécution d'opérations unaires
Utilisez un moins unaire avec le let commande pour changer une expression de positif en négatif et vice versa :
let "var1 = 2 + 3" "var1=-var1"; echo $var1
Le plus unaire multiplie l'expression par 1 et renvoie une valeur inchangée :
let "var1 = 2 + 3" "var1=+var1"; echo $var1
Modifier la valeur de la variable par incréments
Utilisation de la post-incrémentation ou post-décrémentation opérateurs interprète la valeur de la variable puis l'augmente ou la diminue de 1 :
let "var1 = 10" "var2=var1++"; echo $var1 $var2
Dans l'exemple ci-dessus, la variable var2 obtient la valeur de var1 (10) avant qu'il ne soit augmenté de 1. La même chose se produit lors d'une post-décrémentation :
let "var1 = 10" "var2=var1--"; echo $var1 $var2
Effectuer une pré-incrémentation augmente la valeur de var1 par 1 (11), puis attribue la nouvelle valeur à var2 :
let "var1 = 10" "var2=++var1"; echo $var1 $var2
Effectuer une pré-décrémentation fait de même. Cependant, cette fois, cela diminue la valeur de var1 par 1 (9) :
let "var1 = 10" "var2=--var1"; echo $var1 $var2
Effectuer des décalages de bits
Effectuer des décalages de bits en utilisant le let La commande décale l'ordre des chiffres d'un nombre binaire vers la gauche ou vers la droite. Par exemple, effectuer un décalage vers la gauche du nombre 8 deux fois le multiplie par deux :
let "var1 = 8 << 2"; echo $var1
Inversement, effectuer deux fois un décalage vers la droite divise deux fois la valeur par 2 :
let "var1 = 8 >> 2"; echo $var1
Exécution d'opérations au niveau du bit
Une négation au niveau du bit inverse chaque chiffre d'un nombre binaire. Cette opération change 1 en 0 et inversement :
let "var1 = 5" "var2=~var1"; echo $var2
Dans l'exemple ci-dessus, la commande let convertit la valeur de 5 en un entier signé 32 bits (0000000000000000000000000000101) et inverse les chiffres. Cette opération donne -6 (111111111111111111111111111010).
Un ET au niveau du bit L'opérateur convertit une paire de valeurs en entiers signés 32 bits et compare les chiffres dans l'ordre. L'action renvoie 1 si les deux chiffres sont 1, sinon elle renvoie 0 :
let "var1 = 5" "var2 = 10" "var3 = var1&var2"; echo $var3
Le OU au niveau du bit compare les chiffres correspondants de deux valeurs et renvoie 1. Mais, au moins un des bits doit être 1 :
let "var1 = 5" "var2 = 10" "var3 = var1|var2"; echo $var3
Le XOR au niveau du bit compare les chiffres correspondants de deux valeurs et renvoie 0 si les chiffres correspondent. Sinon, l'opérateur renvoie 1 :
let "var1 = 5" "var2 = 10" "var3 = var1^var2"; echo $var3