Introduction
Le scripting shell est un outil puissant pour automatiser les tâches dans les environnements Linux. L'une des compétences fondamentales en programmation shell est de travailler avec les variables - des emplacements de stockage temporaires qui contiennent des données. Ce tutoriel vous guidera à travers le processus de création de variables et d'impression de leurs valeurs dans les scripts shell. À la fin de ce lab, vous comprendrez comment déclarer des variables, accéder à leurs valeurs et les intégrer dans des scripts shell pratiques.
Création de votre premier script shell avec des variables
Commençons par créer un script shell simple qui démontre comment déclarer et utiliser des variables.
Que sont les variables shell ?
Les variables shell sont des emplacements de stockage nommés qui peuvent contenir des valeurs dans les scripts shell. Elles vous permettent de stocker et de récupérer des données telles que des chaînes de texte, des nombres, des chemins de fichiers et les sorties de commandes. Les variables rendent vos scripts plus flexibles et réutilisables.
Création de votre premier script
Créons un fichier de script shell :
- Ouvrez le terminal WebIDE
- Naviguez vers le répertoire du projet (si vous n'y êtes pas déjà) :
cd ~/project - Créez un nouveau fichier nommé
myscript.shen utilisant l'éditeur WebIDE :- Cliquez sur l'icône "New File" dans le WebIDE
- Nommez-le
myscript.sh - Ajoutez le contenu suivant au fichier :
#!/bin/bash
## This is my first shell script with variables
## Declaring a variable
name="LabEx User"
## Printing the variable
echo "Hello, $name!"
## Printing the current date using a variable
current_date=$(date)
echo "Today is: $current_date"
Enregistrez le fichier en appuyant sur Ctrl+S ou en cliquant sur File > Save
Rendez le script exécutable avec la commande suivante :
chmod +x myscript.shExécutez votre script :
./myscript.sh
Vous devriez voir une sortie similaire à celle-ci :
Hello, LabEx User!
Today is: Thu Jul 13 10:30:45 UTC 2023
Comprendre le script
Décomposons ce qui s'est passé dans notre script :
- La première ligne
#!/bin/bash(appelée shebang) indique au système d'utiliser le shell Bash pour exécuter le script. - Nous avons créé une variable nommée
nameet lui avons assigné la valeur "LabEx User" en utilisantname="LabEx User". - Nous avons imprimé la valeur de la variable en utilisant
echo "Hello, $name!". Le symbole$devant le nom de la variable indique au shell de substituer la valeur de la variable. - Nous avons créé une autre variable
current_dateet lui avons assigné la sortie de la commandedateen utilisant$(date). - Nous avons imprimé la valeur de la variable
current_date.
Règles de nommage des variables
Lors de la création de variables dans les scripts shell, suivez ces conventions de nommage :
- Les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement
- Ils doivent commencer par une lettre ou un trait de soulignement
- Aucun espace n'est autorisé autour du signe égal lors de l'assignation de valeurs
- Les noms de variables sont sensibles à la casse (NAME, name et Name sont trois variables différentes)
Essayez de modifier le script pour inclure vos propres variables et exécutez-le à nouveau pour voir les résultats.
Différentes façons d'imprimer les valeurs des variables
Maintenant que vous comprenez les bases de la création de variables, explorons différentes méthodes pour imprimer leurs valeurs dans les scripts shell.
Utilisation des guillemets doubles
La façon la plus courante d'imprimer des variables est d'utiliser des guillemets doubles avec la commande echo. Les guillemets doubles permettent au shell d'interpréter les noms de variables et de substituer leurs valeurs.
Créez un nouveau fichier nommé print_variables.sh :
- Cliquez sur l'icône "New File" dans le WebIDE
- Nommez-le
print_variables.sh - Ajoutez le contenu suivant :
#!/bin/bash
## Declaring variables
name="LabEx"
version=1.0
is_active=true
## Printing variables with double quotes
echo "Application name: $name"
echo "Version: $version"
echo "Active status: $is_active"
## Printing multiple variables in one statement
echo "The $name application version $version is $is_active"
- Enregistrez le fichier (Ctrl+S ou File > Save)
- Rendez-le exécutable :
chmod +x print_variables.sh - Exécutez le script :
./print_variables.sh
Vous devriez voir une sortie similaire à :
Application name: LabEx
Version: 1.0
Active status: true
The LabEx application version 1.0 is true
Utilisation des accolades
Parfois, vous devez être plus précis sur l'endroit où un nom de variable commence et se termine. Les accolades aident à cela en délimitant clairement le nom de la variable.
Ajoutez les lignes suivantes à votre script print_variables.sh :
## Using curly braces to clearly define variable boundaries
app="${name}App"
echo "Application full name: $app"
## This avoids confusion when you want to append text directly to a variable's value
echo "Application name with text: ${name}Text"
Enregistrez et exécutez à nouveau le script :
./print_variables.sh
La sortie supplémentaire devrait afficher :
Application full name: LabExApp
Application name with text: LabExText
Utilisation des guillemets simples
Contrairement aux guillemets doubles, les guillemets simples empêchent la substitution de variables et impriment le texte littéral.
Ajoutez ces lignes à votre script :
## Using single quotes (no variable substitution)
echo 'With single quotes: $name is not replaced'
## Mixing quote types for complex output
echo "This is the variable value: '$name'"
Enregistrez et exécutez à nouveau le script. Vous devriez voir :
With single quotes: $name is not replaced
This is the variable value: 'LabEx'
Utilisation de printf pour une sortie formatée
La commande printf offre plus de contrôle sur le formatage de votre sortie :
## Using printf for formatted output
printf "Name: %s\nVersion: %.1f\n" "$name" "$version"
## Formatting numbers with printf
number=42.5678
printf "Formatted number: %.2f\n" $number
Enregistrez et exécutez à nouveau le script. La sortie supplémentaire affichera :
Name: LabEx
Version: 1.0
Formatted number: 42.57
Essayez d'expérimenter avec les différentes méthodes d'impression pour voir celles qui fonctionnent le mieux pour vos besoins.
Création d'un script shell pratique avec l'entrée utilisateur
Créons maintenant un script shell plus pratique qui prend en compte l'entrée utilisateur, la stocke dans des variables et affiche les résultats.
Lecture de l'entrée utilisateur
La commande read permet à votre script d'accepter les entrées des utilisateurs. Créons un simple script de salutation :
- Créez un nouveau fichier nommé
greeting.sh:- Cliquez sur l'icône "New File" dans le WebIDE
- Nommez-le
greeting.sh - Ajoutez le contenu suivant :
#!/bin/bash
## Simple greeting script that takes user input
## Prompt the user for their name
echo "What is your name?"
read username
## Prompt for age
echo "How old are you?"
read age
## Display a greeting with the provided information
echo "Hello, $username! You are $age years old."
## Calculate birth year (approximately)
current_year=$(date +%Y)
birth_year=$((current_year - age))
echo "You were born around the year $birth_year."
## Adding a personalized message based on age
if [ $age -lt 18 ]; then
echo "You are a minor."
elif [ $age -ge 18 ] && [ $age -lt 65 ]; then
echo "You are an adult."
else
echo "You are a senior."
fi
Enregistrez le fichier (Ctrl+S ou File > Save)
Rendez-le exécutable :
chmod +x greeting.shExécutez le script :
./greeting.shLorsque vous y êtes invité, entrez votre nom et votre âge. Vous devriez voir une sortie personnalisée basée sur votre entrée.
Comprendre les composants du script
Décomposons les parties clés de ce script :
- La commande
readstocke l'entrée utilisateur dans des variables (usernameetage). - Nous utilisons les variables dans les instructions echo pour créer une sortie personnalisée.
- Nous effectuons des opérations arithmétiques en utilisant la syntaxe
$((expression))pour calculer l'année de naissance. - Nous utilisons des instructions conditionnelles (
if,elif,else) pour fournir différents messages en fonction de la valeur de l'âge. - Nous utilisons la commande
dateavec des options de formatage pour obtenir l'année en cours.
Rendre le script plus interactif
Améliorons notre script pour le rendre plus interactif et utile. Ajoutez ce qui suit à votre fichier greeting.sh :
## Ask if the user wants to see the current system information
echo "Would you like to see some system information? (yes/no)"
read response
## Convert the response to lowercase for easier comparison
response_lower=$(echo "$response" | tr '[:upper:]' '[:lower:]')
if [ "$response_lower" = "yes" ] || [ "$response_lower" = "y" ]; then
echo "System information for user $username:"
echo "-------------------------------------"
echo "Hostname: $(hostname)"
echo "Kernel version: $(uname -r)"
echo "System uptime: $(uptime -p)"
echo "CPU information: $(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^[ \t]*//')"
echo "Memory available: $(free -h | grep Mem | awk '{print $7}')"
echo "-------------------------------------"
else
echo "No problem, $username. Have a great day!"
fi
Enregistrez le fichier et exécutez-le à nouveau :
./greeting.sh
Suivez les invites et entrez "yes" lorsqu'on vous demande si vous souhaitez voir les informations système. Vous devriez voir des informations détaillées sur le système.
Ce script démontre comment :
- Lire et traiter l'entrée utilisateur
- Stocker et manipuler des variables
- Effectuer des calculs
- Prendre des décisions basées sur les valeurs des variables
- Exécuter des commandes système et stocker leurs sorties dans des variables
- Afficher une sortie formatée à l'utilisateur
Essayez de modifier le script pour ajouter plus de fonctionnalités interactives ou différents types d'informations système.
Création d'un script shell pour les opérations sur les fichiers
Appliquons nos connaissances des variables shell pour créer un script utile qui effectue des opérations sur les fichiers. Ce script démontrera comment les variables peuvent aider à automatiser les tâches de gestion de fichiers.
Création d'un script de sauvegarde
Créons un script qui effectue une sauvegarde des fichiers dans un répertoire spécifié :
Tout d'abord, créons un répertoire de test et quelques exemples de fichiers avec lesquels travailler :
mkdir -p ~/project/test_files echo "This is file 1" > ~/project/test_files/file1.txt echo "This is file 2" > ~/project/test_files/file2.txt echo "This is file 3" > ~/project/test_files/file3.txtMaintenant, créez un nouveau fichier nommé
backup.sh:- Cliquez sur l'icône "New File" dans le WebIDE
- Nommez-le
backup.sh - Ajoutez le contenu suivant :
#!/bin/bash
## A script to backup files from a source directory to a backup directory
## Define variables for directories
source_dir="$HOME/project/test_files"
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"
## Print the script's purpose
echo "File Backup Script"
echo "==================="
echo "Source directory: $source_dir"
echo "Backup directory: $backup_dir/$backup_name"
## Create the backup directory if it doesn't exist
if [ ! -d "$backup_dir" ]; then
echo "Creating backup directory: $backup_dir"
mkdir -p "$backup_dir"
fi
## Create a timestamped backup directory
mkdir -p "$backup_dir/$backup_name"
## Check if source directory exists
if [ ! -d "$source_dir" ]; then
echo "Error: Source directory $source_dir does not exist!"
exit 1
fi
## Count the number of files in the source directory
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Found $file_count files in the source directory."
## Copy the files to the backup directory
echo "Copying files to backup location..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"
## Verify the copy operation
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copied $copied_count files to the backup directory."
## Check if all files were copied successfully
if [ "$file_count" -eq "$copied_count" ]; then
echo "Backup completed successfully!"
else
echo "Warning: Not all files were copied. Please check for errors."
fi
## List the contents of the backup directory
echo "Contents of the backup directory:"
ls -la "$backup_dir/$backup_name"
## Display the total size of the backup
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Total backup size: $backup_size"
- Enregistrez le fichier (Ctrl+S ou File > Save)
- Rendez-le exécutable :
chmod +x backup.sh - Exécutez le script :
./backup.sh
Vous devriez voir une sortie montrant le processus de sauvegarde, comprenant :
- Les répertoires source et de sauvegarde
- Le nombre de fichiers trouvés
- La confirmation de l'opération de copie
- Le contenu du répertoire de sauvegarde
- La taille totale de la sauvegarde
Comprendre le script
Ce script de sauvegarde démontre plusieurs concepts importants :
- Utilisation des variables : Nous utilisons des variables pour stocker les chemins des répertoires, les horodatages et les décomptes.
- Substitution de commande : Nous utilisons la syntaxe
$(command)pour capturer la sortie de la commande dans des variables. - Instructions conditionnelles : Nous utilisons les instructions
ifpour vérifier si les répertoires existent. - Manipulation de chaînes : Nous créons un nom de sauvegarde unique en utilisant l'horodatage.
- Variables de chemin : Nous utilisons
$HOMEpour référencer le répertoire personnel de l'utilisateur. - Exécution de commandes : Nous utilisons des commandes shell comme
mkdir,cpetlsdans notre script. - Codes de sortie : Nous utilisons
exit 1pour terminer le script avec un statut d'erreur.
Améliorer le script de sauvegarde
Modifions notre script pour accepter un répertoire source personnalisé de l'utilisateur :
- Ouvrez
backup.shdans l'éditeur - Remplacez le contenu par ce qui suit :
#!/bin/bash
## A script to backup files from a source directory to a backup directory
## Check if a source directory was provided
if [ $## -eq 0 ]; then
## No argument provided, use default directory
source_dir="$HOME/project/test_files"
echo "No source directory specified, using default: $source_dir"
else
## Use the provided directory
source_dir="$1"
echo "Using specified source directory: $source_dir"
fi
## Define variables for directories
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"
## Print the script's purpose
echo "File Backup Script"
echo "==================="
echo "Source directory: $source_dir"
echo "Backup directory: $backup_dir/$backup_name"
## Create the backup directory if it doesn't exist
if [ ! -d "$backup_dir" ]; then
echo "Creating backup directory: $backup_dir"
mkdir -p "$backup_dir"
fi
## Create a timestamped backup directory
mkdir -p "$backup_dir/$backup_name"
## Check if source directory exists
if [ ! -d "$source_dir" ]; then
echo "Error: Source directory $source_dir does not exist!"
exit 1
fi
## Count the number of files in the source directory
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Found $file_count files in the source directory."
## Copy the files to the backup directory
echo "Copying files to backup location..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"
## Verify the copy operation
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copied $copied_count files to the backup directory."
## Check if all files were copied successfully
if [ "$file_count" -eq "$copied_count" ]; then
echo "Backup completed successfully!"
else
echo "Warning: Not all files were copied. Please check for errors."
fi
## List the contents of the backup directory
echo "Contents of the backup directory:"
ls -la "$backup_dir/$backup_name"
## Display the total size of the backup
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Total backup size: $backup_size"
- Enregistrez le fichier
- Exécutez le script avec un répertoire personnalisé :
./backup.sh ~/project
Le script amélioré démontre maintenant :
- Les arguments de ligne de commande en utilisant
$1(le premier argument passé au script) - Les valeurs par défaut lorsqu'aucun argument n'est fourni
- La vérification des paramètres avec
$#(le nombre d'arguments)
Ce script de sauvegarde est un exemple pratique de la façon dont les variables shell peuvent être utilisées pour créer des outils utiles et flexibles pour automatiser les tâches de gestion de fichiers.
Résumé
Dans ce lab, vous avez appris les compétences essentielles pour travailler avec les variables dans les scripts shell :
- Création et déclaration de variables shell
- Différentes façons d'afficher les valeurs des variables en utilisant echo, printf et les guillemets
- Lecture et traitement des entrées utilisateur
- Effectuer des calculs avec des variables shell
- Utiliser des variables pour les opérations sur les fichiers et les tâches de sauvegarde
- Gérer les arguments de ligne de commande
Ces compétences constituent une base solide pour le scripting shell et vous permettront de créer des scripts plus dynamiques et flexibles pour automatiser diverses tâches dans un environnement Linux. Au fur et à mesure que vous poursuivrez votre parcours de scripting shell, vous pourrez vous appuyer sur ces concepts pour développer des scripts plus complexes pour l'administration système, la gestion de fichiers et les tâches de traitement des données.
