Comment Affecter et Réaffecter des Variables en Bash

ShellShellBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Ce tutoriel vous guidera à travers le processus d'assignation et de réassignation de variables en Bash, le langage de script shell populaire. Les variables sont des éléments de base fondamentaux dans les scripts Bash qui vous permettent de stocker et de manipuler des données. Dans ce laboratoire pratique, vous apprendrez à déclarer des variables, à leur assigner des valeurs et à les utiliser dans des commandes et des scripts. À la fin de ce tutoriel, vous aurez une solide compréhension de la manière de travailler efficacement avec les variables en Bash, ce qui vous permettra d'écrire des scripts plus puissants et flexibles.

Création et Assignation de Variables Bash

En Bash, les variables vous permettent de stocker des données qui peuvent être accédées et modifiées ultérieurement dans votre script. Commençons par créer une variable simple et lui assigner une valeur.

Ouvrez un nouveau terminal dans l'environnement LabEx. Vous devriez être dans le répertoire /home/labex/project.

Pour assigner une valeur à une variable en Bash, utilisez la syntaxe suivante :

variable_name=value

Notez qu'il ne doit pas y avoir d'espaces autour du signe égal.

Créons notre première variable :

  1. Dans le terminal, tapez la commande suivante et appuyez sur Entrée :
name="John"
  1. Pour afficher la valeur de la variable, utilisez la commande echo avec le nom de la variable précédé d'un signe dollar ($) :
echo $name

Vous devriez voir la sortie suivante :

John
  1. Vous pouvez également utiliser des guillemets doubles autour du nom de la variable :
echo "My name is $name"

Sortie :

My name is John
  1. Pour réassigner une nouvelle valeur à la même variable, utilisez simplement l'opérateur d'assignation (=) à nouveau :
name="Alice"
echo "My name is $name"

Sortie :

My name is Alice

Règles de Nommage des Variables

Lors de la création de variables en Bash, suivez ces conventions de nommage :

  • Les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement
  • Les noms de variables doivent commencer par une lettre ou un trait de soulignement
  • Les noms de variables sont sensibles à la casse (case-sensitive)
  • Aucun espace n'est autorisé dans les noms de variables

Créons un fichier pour nous entraîner avec les variables. Dans le WebIDE, créez un nouveau fichier nommé variables.sh dans le répertoire du projet :

  1. Cliquez sur l'icône "New File" dans l'IDE
  2. Nommez le fichier variables.sh
  3. Ajoutez le code suivant au fichier :
#!/bin/bash

## Assigning variables
first_name="John"
last_name="Doe"
age=25

## Displaying variables
echo "First name: $first_name"
echo "Last name: $last_name"
echo "Age: $age"

## Reassigning variables
first_name="Jane"
echo "Updated first name: $first_name"
  1. Enregistrez le fichier en appuyant sur Ctrl+S ou en cliquant sur File → Save

  2. Rendez le script exécutable en exécutant la commande suivante dans le terminal :

chmod +x variables.sh
  1. Exécutez le script avec :
./variables.sh

Vous devriez voir la sortie suivante :

First name: John
Last name: Doe
Age: 25
Updated first name: Jane

Cela démontre comment créer des variables, leur assigner des valeurs et réassigner de nouvelles valeurs.

Travailler avec les Valeurs de Variables et les Opérations sur les Chaînes

Dans cette étape, nous allons explorer différentes façons de travailler avec les valeurs de variables en Bash, y compris les opérations sur les chaînes et les calculs arithmétiques.

Opérations sur les Chaînes

Bash fournit plusieurs façons de manipuler les valeurs de chaînes stockées dans les variables.

  1. Créez un nouveau fichier nommé string_operations.sh dans le répertoire du projet :
#!/bin/bash

## String concatenation
greeting="Hello"
name="World"
message="$greeting $name"
echo $message

## String length
text="Welcome to Bash scripting"
length=${#text}
echo "The length of '$text' is $length characters"

## Extracting substrings
substring=${text:0:7}
echo "Substring: $substring"

## Converting to uppercase and lowercase
uppercase=${text^^}
lowercase=${text,,}
echo "Uppercase: $uppercase"
echo "Lowercase: $lowercase"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x string_operations.sh
  1. Exécutez le script :
./string_operations.sh

Vous devriez voir une sortie similaire à :

Hello World
The length of 'Welcome to Bash scripting' is 25 characters
Substring: Welcome
Uppercase: WELCOME TO BASH SCRIPTING
Lowercase: welcome to bash scripting

Opérations Arithmétiques

Bash vous permet également d'effectuer des opérations arithmétiques avec des variables.

  1. Créez un nouveau fichier nommé arithmetic_operations.sh dans le répertoire du projet :
#!/bin/bash

## Assigning numeric values
x=5
y=3

## Basic arithmetic operations
sum=$((x + y))
difference=$((x - y))
product=$((x * y))
quotient=$((x / y))
remainder=$((x % y))

## Display results
echo "x = $x, y = $y"
echo "Sum: $x + $y = $sum"
echo "Difference: $x - $y = $difference"
echo "Product: $x * $y = $product"
echo "Quotient: $x / $y = $quotient"
echo "Remainder: $x % $y = $remainder"

## Increment and decrement
echo "Initial value of x: $x"
x=$((x + 1))
echo "After increment: $x"
x=$((x - 1))
echo "After decrement: $x"

## Compound assignment operators
x+=5
echo "After x+=5: $x"
x-=2
echo "After x-=2: $x"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x arithmetic_operations.sh
  1. Exécutez le script :
./arithmetic_operations.sh

Vous devriez voir une sortie similaire à :

x = 5, y = 3
Sum: 5 + 3 = 8
Difference: 5 - 3 = 2
Product: 5 * 3 = 15
Quotient: 5 / 3 = 1
Remainder: 5 % 3 = 2
Initial value of x: 5
After increment: 6
After decrement: 5
After x+=5: 10
After x-=2: 8

Lecture des Entrées Utilisateur dans les Variables

Les variables peuvent également stocker les entrées fournies par les utilisateurs. Créons un script qui invite l'utilisateur à saisir des informations :

  1. Créez un fichier nommé user_input.sh :
#!/bin/bash

## Prompt the user for their name
echo "What is your name?"
read user_name

## Prompt the user for their age
echo "How old are you?"
read user_age

## Display the information
echo "Hello, $user_name! You are $user_age years old."

## Calculate birth year (approximate)
current_year=$(date +%Y)
birth_year=$((current_year - user_age))
echo "You were likely born in $birth_year."
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x user_input.sh
  1. Exécutez le script :
./user_input.sh
  1. Lorsque vous y êtes invité, entrez votre nom et votre âge. Le script affichera une salutation et calculera votre année de naissance approximative.

Cette étape vous a montré comment effectuer diverses opérations avec des variables, y compris la manipulation de chaînes, les calculs arithmétiques et la lecture des entrées utilisateur.

Utilisation des Variables dans les Scripts et les Commandes

Dans cette étape, nous allons explorer comment utiliser efficacement les variables dans les scripts et les commandes Bash. Nous allons créer un script pratique qui démontre l'utilisation des variables dans divers scénarios.

Création d'un Script de Base avec des Variables

Créons un script qui calcule le coût total des articles dans un panier d'achat :

  1. Créez un nouveau fichier nommé shopping_cart.sh dans le répertoire du projet :
#!/bin/bash

## Initialize variables for items and their prices
item1="Laptop"
price1=999
item2="Headphones"
price2=149
item3="Mouse"
price3=25

## Calculate the total price
total=$((price1 + price2 + price3))

## Display the shopping cart
echo "Shopping Cart:"
echo "-------------"
echo "$item1: \$$price1"
echo "$item2: \$$price2"
echo "$item3: \$$price3"
echo "-------------"
echo "Total: \$$total"

## Apply a discount if the total is over $1000
discount_threshold=1000
discount_rate=10

if [ $total -gt $discount_threshold ]; then
  discount_amount=$((total * discount_rate / 100))
  discounted_total=$((total - discount_amount))
  echo "Discount (${discount_rate}%): -\$$discount_amount"
  echo "Final Total: \$$discounted_total"
fi
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x shopping_cart.sh
  1. Exécutez le script :
./shopping_cart.sh

Vous devriez voir la sortie suivante :

Shopping Cart:
-------------
Laptop: $999
Headphones: $149
Mouse: $25
-------------
Total: $1173
Discount (10%): -$117
Final Total: $1056

Utilisation des Variables avec la Substitution de Commande

La substitution de commande vous permet de capturer la sortie d'une commande et de la stocker dans une variable. Créons un script qui le démontre :

  1. Créez un nouveau fichier nommé system_info.sh :
#!/bin/bash

## Get current date and time
current_date=$(date +"%Y-%m-%d")
current_time=$(date +"%H:%M:%S")

## Get system information
hostname=$(hostname)
os_type=$(uname -s)
kernel_version=$(uname -r)
uptime_info=$(uptime -p)
memory_free=$(free -h | awk '/^Mem:/ {print $4}')
disk_free=$(df -h / | awk 'NR==2 {print $4}')

## Display the information
echo "System Information Report"
echo "========================="
echo "Date: $current_date"
echo "Time: $current_time"
echo "Hostname: $hostname"
echo "OS Type: $os_type"
echo "Kernel Version: $kernel_version"
echo "Uptime: $uptime_info"
echo "Free Memory: $memory_free"
echo "Free Disk Space: $disk_free"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x system_info.sh
  1. Exécutez le script :
./system_info.sh

Vous devriez voir une sortie similaire à la suivante (avec des valeurs spécifiques à votre système) :

System Information Report
=========================
Date: 2023-11-20
Time: 14:30:25
Hostname: labex
OS Type: Linux
Kernel Version: 5.15.0-1015-aws
Uptime: up 2 hours, 15 minutes
Free Memory: 1.2Gi
Free Disk Space: 15G

Utilisation des Variables dans les Boucles

Les variables sont particulièrement utiles dans les boucles. Créons un script qui le démontre :

  1. Créez un nouveau fichier nommé countdown.sh :
#!/bin/bash

## Get countdown start value from user
echo "Enter a number to start countdown:"
read count

## Validate that input is a number
if [[ ! $count =~ ^[0-9]+$ ]]; then
  echo "Error: Please enter a valid number"
  exit 1
fi

## Perform countdown
echo "Starting countdown from $count:"
while [ $count -gt 0 ]; do
  echo $count
  count=$((count - 1))
  sleep 1
done

echo "Blast off!"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x countdown.sh
  1. Exécutez le script :
./countdown.sh
  1. Entrez un petit nombre (comme 5) lorsque vous y êtes invité.

Le script comptera à rebours à partir du nombre que vous avez entré, en imprimant chaque nombre, puis "Blast off!" à la fin.

Ces exemples démontrent comment les variables peuvent être utilisées dans différents contextes au sein des scripts Bash, les rendant plus dynamiques et flexibles.

Portée des Variables et Variables Spéciales

Dans cette dernière étape, nous allons explorer la portée des variables en Bash et découvrir les variables spéciales que Bash fournit.

Comprendre la Portée des Variables

En Bash, les variables peuvent avoir différentes portées, qui déterminent où elles peuvent être accessibles :

  1. Variables globales : Celles-ci sont accessibles dans tout le script.
  2. Variables locales : Celles-ci ne sont accessibles qu'à l'intérieur d'une fonction ou d'un bloc spécifique.

Créons un script pour démontrer la portée des variables :

  1. Créez un nouveau fichier nommé variable_scope.sh :
#!/bin/bash

## Global variable
global_var="I am a global variable"

## Function that demonstrates variable scope
demo_scope() {
  ## Local variable
  local local_var="I am a local variable"

  ## Access global variable
  echo "Inside function: global_var = $global_var"

  ## Access local variable
  echo "Inside function: local_var = $local_var"

  ## Modify global variable
  global_var="Global variable modified"
}

## Main script
echo "Before function call: global_var = $global_var"

## This will fail because local_var doesn't exist yet
echo "Before function call: local_var = $local_var"

## Call the function
demo_scope

## After function call
echo "After function call: global_var = $global_var"

## This will fail because local_var is only accessible within the function
echo "After function call: local_var = $local_var"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x variable_scope.sh
  1. Exécutez le script :
./variable_scope.sh

Vous devriez voir une sortie similaire à :

Before function call: global_var = I am a global variable
Before function call: local_var =
Inside function: global_var = I am a global variable
Inside function: local_var = I am a local variable
After function call: global_var = Global variable modified
After function call: local_var =

Remarquez que :

  • La variable globale global_var est accessible à l'intérieur et à l'extérieur de la fonction.
  • La variable locale local_var n'est accessible qu'à l'intérieur de la fonction.
  • Les modifications apportées à la variable globale persistent après la fin de la fonction.

Travailler avec des Variables Spéciales

Bash fournit plusieurs variables spéciales qui contiennent des informations spécifiques. Explorons-en quelques-unes :

  1. Créez un nouveau fichier nommé special_variables.sh :
#!/bin/bash

## Special variables demonstration
echo "Script name: $0"
echo "Process ID: $$"
echo "Number of arguments: $#"
echo "All arguments: $@"
echo "Exit status of last command: $?"
echo "Current user: $USER"
echo "Current hostname: $HOSTNAME"
echo "Random number: $RANDOM"

## Function to demonstrate positional parameters
show_params() {
  echo "Function received $## parameters"
  echo "Parameter 1: $1"
  echo "Parameter 2: $2"
  echo "Parameter 3: $3"
}

## Call the function with parameters
echo -e "\nCalling function with parameters:"
show_params apple banana cherry

## Demonstrate positional parameters to the script
echo -e "\nScript positional parameters:"
echo "Parameter 1: $1"
echo "Parameter 2: $2"
echo "Parameter 3: $3"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x special_variables.sh
  1. Exécutez le script avec des arguments :
./special_variables.sh arg1 arg2 arg3

Vous devriez voir une sortie similaire à :

Script name: ./special_variables.sh
Process ID: 12345
Number of arguments: 3
All arguments: arg1 arg2 arg3
Exit status of last command: 0
Current user: labex
Current hostname: labex
Random number: 23456

Calling function with parameters:
Function received 3 parameters
Parameter 1: apple
Parameter 2: banana
Parameter 3: cherry

Script positional parameters:
Parameter 1: arg1
Parameter 2: arg2
Parameter 3: arg3

Variables d'Environnement

Les variables d'environnement sont des variables spéciales qui affectent le comportement du shell et des programmes. Créons un script pour les explorer :

  1. Créez un nouveau fichier nommé environment_variables.sh :
#!/bin/bash

## Display common environment variables
echo "HOME directory: $HOME"
echo "Current user: $USER"
echo "Shell: $SHELL"
echo "Path: $PATH"
echo "Current working directory: $PWD"
echo "Terminal: $TERM"
echo "Language: $LANG"

## Creating and exporting a new environment variable
echo -e "\nCreating a new environment variable:"
MY_VAR="Hello from environment variable"
export MY_VAR
echo "MY_VAR = $MY_VAR"

## Demonstrate that child processes inherit environment variables
echo -e "\nAccessing environment variable from a child process:"
bash -c 'echo "Child process sees MY_VAR = $MY_VAR"'

## Remove the environment variable
echo -e "\nRemoving the environment variable:"
unset MY_VAR
echo "MY_VAR = $MY_VAR (should be empty)"
  1. Enregistrez le fichier et rendez-le exécutable :
chmod +x environment_variables.sh
  1. Exécutez le script :
./environment_variables.sh

Vous devriez voir une sortie montrant diverses variables d'environnement et démontrant comment elles peuvent être créées, consultées et supprimées.

Cette étape vous a montré comment la portée des variables fonctionne en Bash et vous a présenté les variables spéciales qui fournissent des informations utiles dans vos scripts.

Résumé

Dans ce lab, vous avez appris les bases de l'utilisation des variables dans les scripts Bash. Vous avez acquis une expérience pratique avec :

  • La création et l'affectation de valeurs aux variables
  • Le travail avec les opérations de chaînes de caractères et les calculs arithmétiques
  • L'utilisation des variables dans les scripts et les commandes
  • La compréhension de la portée des variables et le travail avec les variables spéciales

Ces compétences constituent les fondements des scripts Bash et vous permettront d'écrire des scripts plus sophistiqués et puissants. Les variables sont un outil essentiel pour rendre vos scripts dynamiques et réutilisables, leur permettant de s'adapter à différentes entrées et scénarios.

Au fur et à mesure que vous poursuivez votre parcours dans les scripts Bash, rappelez-vous ces points clés :

  • Choisissez toujours des noms de variables descriptifs
  • Soyez attentif à la portée des variables lors de l'écriture de fonctions
  • Utilisez des variables spéciales pour accéder à des informations utiles dans vos scripts
  • Tirez parti des variables d'environnement pour la configuration et la personnalisation

Grâce à ces compétences, vous êtes désormais bien équipé pour créer des scripts Bash plus complexes pour automatiser les tâches et gérer votre système.