Les variables sont la partie essentielle de la programmation, ou on peut dire qu'elles sont l'esprit d'un langage de programmation. Les variables spécifient l'emplacement mémoire au moyen de caractères, numériques et alphanumériques. Ils sont utilisés pour être référencés et manipulés dans un programme informatique.
Quelles sont les variables ?
Les variables sont les conteneurs qui stockent des données ou une information utile comme valeur à l'intérieur. Voici la syntaxe d'une variable :
Variable_name =value
Une variable est une forme combinée de deux mots, c'est-à-dire variable + able, ce qui signifie que sa valeur peut être modifiée et qu'elle peut être utilisée plusieurs fois.
strep
La variable est connue comme le stockage temporaire de tout type de données comme un entier, un flottant, un caractère, etc. Un nom de variable peut inclure alphabets, chiffres et traits de soulignement , et son nom peut commencer uniquement par des alphabets et un trait de soulignement.
Remarque : Nous ne pouvons pas définir un nom de variable commençant par un chiffre.
Que sont les variables Bash ?
Nous ne pouvons pas utiliser de variables bash sans disposer des informations appropriées ( syntaxe, types de données, types, travail ) à ce sujet, passons donc à ce bref tutoriel pour avoir une vue d'ensemble appropriée des variables Bash.
Dans un premier temps, connaissez la syntaxe.
Syntaxe:
Variable_name=value
Ensemble de règles pour définir les variables Bash :
- Préfixez le nom de la variable avec le signe dollar ($) lors de la lecture ou de l'impression d'une variable.
- Oubliez le signe dollar ($) lorsque vous définissez une variable avec n'importe quelle valeur.
- Un nom de variable peut être alphanumérique ou écrit avec un trait de soulignement (_).
- Un nom de variable est sensible à la casse : x et X sont considérés comme deux variables différentes.
- Le nom de la variable peut être écrit en lettres UPPER_CASE ou LOWER_CASE ou un mélange des deux comme vous le souhaitez.
- Une variable peut être placée n'importe où dans un script Bash ou sur la ligne de commande, car au moment de l'exécution, Bash la remplacera par la valeur qui lui est attribuée. Cela est devenu possible grâce à la substitution avant d'exécuter la commande.
- Il ne doit pas y avoir d'espace de part et d'autre du signe égal (=) entre le nom de la variable et sa valeur. Voici quelques exemples de Variables invalides ayant des espaces (indiqués par des points ...) entre eux comme indiqué ci-dessous :
var1=...variable1
var2...=variable2
var3...=...variable3 - Il n'est pas nécessaire d'utiliser des guillemets, simples ou doubles, pour définir une variable avec une valeur à un seul caractère telle que var1=variable . Pour saisir plusieurs mots ou une chaîne en tant qu'élément unique dans une variable, utilisez des guillemets pour placer votre contenu dans cette variable.
- Le guillemet simple ('') permet de traiter chaque caractère.
- Double Quote ('') aide à effectuer la substitution.
Types de données
Dans les langages de programmation formels, vous devez définir le type de données de n'importe quelle variable au moment de la déclaration de la variable. Par exemple:
int year=2012 char comp_name='jtp'
Mais dans le cas de Bash, vous n'avez pas besoin de définir le type de données d'une variable au moment de la déclaration de la variable. Les variables Bash sont non typé , ce qui signifie simplement taper le nom de la variable en attribuant sa valeur, et il prendra automatiquement en compte ce type de données.
De telle sorte que si vous attribuez une valeur numérique à la variable, elle fonctionnera comme un entier et si vous attribuez une valeur de caractère à la variable, ce sera une chaîne.
year=2012 comp_name=jtp
à l'aide de la commande echo, lisez-les en attribuant le signe $ avant leur nom, tel que
écho $année
echo $nom
Types de variables Bash
Il existe deux types de variables dans un shell ou dans tout système UNIX.
- Variables définies par le système
- Variables définies par l'utilisateur
1. Variables définies par le système : Ce sont les variables prédéfinies telles qu'elles sont créées et maintenues par le système d'exploitation LINUX lui-même. Leur convention standard est qu'ils sont généralement définis en majuscules, c'est-à-dire UPPER_CASE. Ainsi, chaque fois que vous voyez une variable définie en majuscules, il s’agit très probablement des variables définies par le système.
Il s'agit des variables suivantes définies par le système, comme indiqué ci-dessous :
1. BASH représente le nom du shell.
Exemple:
BASH=/usr/bin/bash
2. BASH_VERSION spécifie la version du shell détenue par Bash.
Exemple:
BASH_VERSION=4.2.46(2)
3. COLONNES précisez le n° de colonnes pour notre écran.
Exemple:
COLUMNS=80
4. MAISON spécifie le répertoire personnel de l'utilisateur.
Exemple:
HOME=/home/jatpoint
5. NOM DU JOURNAL spécifie le nom d'utilisateur de journalisation.
Exemple:
LOGNAME=javatpoint
6. OSTYPE indique le type de système d'exploitation.
Exemple:
OSTYPE=linux-gnu
7. Personnes handicapées représente le répertoire de travail actuel.
Exemple:
PWD=/home/javatpoint
8. NOM D'UTILISATEUR spécifie le nom de l'utilisateur actuellement connecté.
Exemple:
USERNAME=javatpoint
Pour connaître la liste de ces variables dans votre système, tapez les commandes ensemble, env , et printenv sur le terminal de ligne de commande comme suit :
1. Taper le ensemble commande.
Sortir:
2. Taper le env commande
Sortir:
3. Taper la commande printenv
Sortir:
Appelons ces variables via Bash Shell. Voici les étapes indiquées :
Étape 1: Créez un script nommé par Bash_sdvar et tapez le code suivant sur la console Bash comme suit :
#! /bin/bash # Bash System-defined Variables echo $HOME # Home Directory echo $PWD # current working directory echo $BASH # Bash shell name echo $BASH_VERSION # Bash shell Version echo $LOGNAME # Name of the Login User echo $OSTYPE # Type of OS
Étape 2. Regardez la console Bash ci-dessous :
Étape 3. Enregistrez et exécutez le script. Il affichera le résultat comme vous pouvez le voir dans la figure ci-dessous.
Sortir:
2. Variables définies par l'utilisateur : Ces variables sont créées et gérées par l'utilisateur. Généralement, ces types de variables sont définis dans LOWER_CASES. Il n’existe pas de règle stricte pour écrire ces variables en minuscules. Nous pouvons également les écrire en majuscules.
Créons un script Bash pour définir ces variables. Suivez les étapes ci-dessous :
Étape 1. Créez un script nommé par bash_yard et tapez le code suivant sur la console Bash :
#! /bin/bash # User-Defined Variables name=Peter ROLL_NO=5245325 echo 'The student name is $name and his Roll number is $ROLL_NO.'
Étape 2. Voir le code sur la console Bash.
Étape 3. Enregistrez et exécutez le script.
Sortir:
Fonctionnement des variables Bash
Après avoir eu une démonstration de base des variables, passons à la question de savoir comment fonctionnent-elles ?
Il y a deux actions que nous effectuons habituellement pour une variable dans Bash, comme indiqué ci-dessous :
- définir une valeur pour une variable
- lire la valeur pour ça.
Une valeur de variable peut être définie de différentes manières, la plus courante étant de définir la valeur directement. Pour lire une variable, nous pouvons placer son nom (préfixé par le signe $) n'importe où dans le script.
Bash vérifie d'abord tous les noms de variables comme s'ils étaient présents dans le script. Ensuite, il interprète chaque ligne de notre script. Après avoir identifié chaque variable, il remplace un nom de variable par la valeur qui lui est attribuée. Après tout, il interprète/exécute cette ligne de code et continue ce processus pour chaque ligne codée de notre script.
REMARQUE : les deux types de variables dans Bash (dont nous avons discuté) fonctionnent aussi bien sur le terminal que sur le script Bash. Voyons leur travail sur terminal et Bash à travers un exemple simple :
Exemple: Appelez un nom d'utilisateur par XYZ, son emplacement où il travaille actuellement et la version de Bash Shell qu'il utilise pour Bash Scripting.
1. Travailler sur le terminal
2. Travailler sur Bash Shell
Voir le script nommé par Bash_Var ci-dessous :
Dans le 3rdligne du script , nous avons déclaré une variable NOM D'UTILISATEUR pour stocker le nom d'utilisateur XYZ comme sa valeur.
Dans les deux dernières lignes , nous avons imprimé le message prévu en utilisant le écho commande.
Il y a deux variables et une commande dans ce message. Chacun d'entre eux est précédé du signe dollar ($) où :
Pour une meilleure compréhension, créez ce script en suivant le code donné :
#! /bin/bash #Bash Variables USER_NAME=XYZ echo Hey there! $USER_NAME is any user currently working on the directory $PWD with Bash Shell Version $BASH_VERSION.
Il affichera le résultat comme vous pouvez le voir dans l'image suivante :
Sortir:
Il existe d'autres exemples pour pratiquer les variables sur le terminal et Bash Shell. En suivant le ensemble de règles (discuté précédemment) s'entraîner sur les variables comme suit :
A. Utilisation du terminal de ligne de commande
1. Définition des variables
2. Lire et référencer les variables
3. Variables invalides
4. Combinaison de deux variables de chaîne
5. Concaténation de chaînes avec des variables
REMARQUE : n'utilisez pas de guillemets simples pour combiner deux variables ni pour concaténer des chaînes avec des variables. De telle sorte que si vous concaténez des chaînes en les mettant entre guillemets simples, votre lecture échouera, comme vous pouvez le voir dans l'image ci-dessous :
B. Utilisation du script Bash :
C'est un exemple de combinant les variables String.
Sortir:
Arguments de ligne de commande
Les arguments de ligne de commande sont utilisés pour rendre un script plus dynamique en transmettant des entrées au code. Nous transmettons ces arguments au moment de l'exécution du script sous la forme suivante :
./script_name arg1 arg2 arg3.....
Il ne doit y avoir aucun espace entre le nom du script et tous les arguments qui passent.
Comment utiliser les arguments de ligne de commande ?
Dans un Bash Shell, ils sont utilisés avec la référence des paramètres par défaut suivants ou des variables spéciales.
Voici les deux méthodes que nous utilisons pour transmettre les arguments de ligne de commande :
Méthode 1 : Utilisation du numéro de position
C'est la première façon d'accéder aux arguments en utilisant les paramètres par défaut (...). L'image ci-dessous l'explique :
Sortir:
Méthode 2 : utilisation de Array.
C'est la deuxième façon de transmettre les arguments sous forme de tableau. Suivez l'algorithme donné pour appliquer cette méthode.
Étape 1: Créez un script Bash.
Étape 2: Déclarez n'importe quel nom de variable et attribuez sa valeur comme $un sous la forme suivante :
variable_name=('$@')
Où $@ est l'argument par défaut qui est utilisé pour stocker les arguments (que nous passons) sous forme de tableau.
Étape 3: Affichez les arguments en définissant leur index de tableau sous la forme suivante :
${variable_name[i]} Étape 4: Enregistrez et fermez le script.
Étape 5 : Exécutez le script en passant les arguments.
Voir le programme suivant :
Programme:
#!/bin/bash args=('$@') echo ${args[0]} ${args[1]} ${args[2]} ${args[3]} Sur la console Bash :
Sortir:
Remplacement de commande
D'après la documentation officielle de Bash
'La substitution de commande permet à la sortie d'une commande de remplacer la commande elle-même. Bash effectue l'expansion en exécutant la commande dans un environnement de sous-shell et en remplaçant la substitution de commande par la sortie standard de la commande, en supprimant toutes les nouvelles lignes de fin. Les nouvelles lignes intégrées ne sont pas supprimées, mais elles peuvent être supprimées lors du fractionnement des mots.
La substitution de commandes fait référence à une expansion que Bash effectue pour nous. Il prend la sortie de la commande Bash, la stocke dans une variable (généralement) et l'affiche avec écho.
Remplacement de commande offre une flexibilité aux données en ce qui concerne les scripts et l'affectation des variables. Il est simple et facile d’avoir une sortie en ligne de commande unique. Dans le cas où la sortie s'étend sur quelques lignes, les nouvelles lignes de fin sont supprimées et le contenu complet de la sortie se retrouve sur une seule ligne.
Voir la syntaxe à utiliser :
Syntaxe
La forme classique de substitution de commandes dans une variable ou de substitution de commande consiste à utiliser des guillemets inversés (`...`), comme indiqué ci-dessous :
variable_name=`command_name` variable_name=`command_name [option...] argument1 argument2...` variable_name=`/path/to/command`
Maintenant, nous effectuons la substitution de commandes en mettant les commandes entre parenthèses (précédées du signe dollar ($)). Regarde:
variable_name=$(command_name) variable_name=$(command_name [option...] argument1 argument2...) variable_name=$(path/to/command)
Faisons donc une substitution de commande avec un exemple selon la discussion.
Dans cet exemple, nous remplaçons une seule commande ls dans une variable. Voir la borne.
Ligne 1: Sans substitution de commande, la sortie est développée sur plusieurs lignes.
Ligne 2 et 3 : Avec la substitution de commande, la sortie se termine sur une seule ligne (espace économisé en supprimant les lignes nouvellement terminées).
Voici le script Bash pour tester la substitution de commande.
Programme:
#! /bin/bash # command substitution lsResult=$(ls) echo 'My files are:' $lsResult
Voir la console Bash :
Sortir:
