Lecture d'entrées en Linux

Introduction

Ce laboratoire vous initie à la lecture d'entrées dans les scripts shell Linux. La lecture d'entrées est une compétence fondamentale pour créer des scripts shell interactifs capables de répondre aux entrées utilisateur. En apprenant à utiliser la commande read, vous pourrez collecter et traiter les données saisies par les utilisateurs, rendant vos scripts plus polyvalents et conviviaux.

Dans ce laboratoire, vous apprendrez à lire les entrées utilisateur, à traiter ces entrées dans vos scripts et à créer des scripts shell interactifs qui peuvent répondre dynamiquement à différentes entrées utilisateur. Ces compétences sont essentielles pour écrire des outils et des scripts de ligne de commande efficaces dans les environnements Linux.

Lecture d'entrée de base

La commande read est une commande intégrée au shell qui lit une ligne d'entrée depuis l'entrée standard (habituellement le clavier) et l'affecte à des variables. Cela permet aux scripts de recevoir et de traiter les entrées utilisateur.

Dans cette étape, vous allez créer un script simple qui lit l'entrée utilisateur et l'affiche de retour à l'utilisateur.

Tout d'abord, assurez-vous d'être dans le répertoire du projet :
```
cd /home/labex/project
```
Créez un nouveau fichier de script nommé input_reader.sh :
```
touch input_reader.sh
```
Rendez le script exécutable :
```
chmod +x input_reader.sh
```
Ouvrez le fichier de script à l'aide de l'éditeur de texte nano :
```
nano input_reader.sh
```
Ajoutez le code suivant au script :
```
#!/bin/bash

## Un simple script pour démontrer la lecture de base des entrées
echo "Veuillez entrer votre nom :"
read name
echo "Bonjour, $name ! Bienvenue dans la lecture des entrées Linux."
```
Ce script :
- Commence par un shebang (#!/bin/bash) qui spécifie que le script doit être exécuté avec bash
- Affiche une invite demandant le nom de l'utilisateur
- Utilise la commande read pour capturer ce que l'utilisateur tape et le stocke dans une variable appelée name
- Affiche un message de bienvenue incluant le nom entré par l'utilisateur
Enregistrez le fichier en appuyant sur Ctrl+O, puis appuyez sur Entrée pour confirmer le nom du fichier, et quittez nano en appuyant sur Ctrl+X.
Exécutez le script pour le tester :
```
./input_reader.sh
```
Vous devriez voir une sortie similaire à celle-ci :
```
Veuillez entrer votre nom :
John
Bonjour, John ! Bienvenue dans la lecture des entrées Linux.
```
La sortie réelle affichera le nom que vous avez entré au lieu de "John".

La commande read attend l'entrée utilisateur et la stocke dans une ou plusieurs variables. Dans cet exemple, l'entrée a été stockée dans une seule variable appelée name. Plus tard, vous apprendrez à capturer plusieurs entrées avec une seule commande read.

Utilisation de read avec des boucles

Dans cette étape, vous allez améliorer votre script pour lire en continu les entrées à l'aide d'une boucle jusqu'à ce qu'une condition de sortie spécifique soit remplie. Ce modèle est couramment utilisé dans les scripts interactifs où vous devez collecter plusieurs informations de l'utilisateur.

Ouvrez votre script pour le modifier :
```
nano input_reader.sh
```
Remplacez le contenu existant par le code suivant :
```
#!/bin/bash

## Script amélioré avec une boucle pour plusieurs entrées
echo "Entrez plusieurs entrées (tapez 'exit' pour quitter) :"

while true; do
  ## Invite pour l'entrée
  echo -n "> "
  read input

  ## Vérifiez si l'utilisateur veut quitter
  if [[ "$input" == "exit" ]]; then
    echo "Sortie du lecteur d'entrées."
    break
  fi

  ## Traitez l'entrée
  echo "Vous avez entré : $input"
done

echo "Merci d'avoir utilisé le lecteur d'entrées !"
```
Ce script :
- Utilise une boucle while true pour créer une boucle infinie qui continuera d'accepter les entrées
- Affiche une invite (>) avant chaque entrée en utilisant echo -n qui empêche un saut de ligne
- Lit l'entrée utilisateur dans la variable input
- Vérifie si l'entrée est "exit" et sort de la boucle si c'est le cas
- Sinon, il renvoie l'entrée à l'utilisateur
- Enfin, affiche un message de remerciement après avoir quitté la boucle
Enregistrez le fichier en appuyant sur Ctrl+O, puis appuyez sur Entrée pour confirmer le nom du fichier, et quittez nano en appuyant sur Ctrl+X.

Exécutez le script amélioré :

./input_reader.sh

Vous devriez voir une sortie similaire à celle-ci :

Entrez plusieurs entrées (tapez 'exit' pour quitter) :
> hello
Vous avez entré : hello
> world
Vous avez entré : world
> exit
Sortie du lecteur d'entrées.
Merci d'avoir utilisé le lecteur d'entrées !

Cette structure de boucle est particulièrement utile lorsque vous devez traiter plusieurs entrées séquentiellement, par exemple lors de la création d'une interface en ligne de commande simple ou d'un outil de saisie de données. L'instruction break est utilisée pour sortir de la boucle lorsque l'utilisateur tape "exit", mais vous pourriez modifier la condition pour quitter en fonction de n'importe quel critère dont vous avez besoin.

Lecture avec invites et valeurs par défaut

Dans cette étape, vous allez apprendre à fournir des valeurs par défaut pour les entrées et à utiliser l'option -p pour créer des invites plus claires. Cela est utile lorsque vous souhaitez offrir aux utilisateurs la possibilité d'appuyer simplement sur Entrée pour accepter une valeur suggérée.

Ouvrez votre script pour le modifier :
```
nano input_reader.sh
```

Remplacez le contenu existant par le code suivant :

#!/bin/bash

## Script démontrant la lecture avec des valeurs par défaut

## Utilisation du flag -p pour l'invite et fourniture d'une valeur par défaut avec l'opérateur ||
read -p "Entrez votre pays (par défaut : USA) : " country
country=${country:-USA}
echo "Pays défini sur : $country"

## Un autre exemple avec une valeur par défaut
read -p "Entrez votre langage de programmation préféré (par défaut : Bash) : " language
language=${language:-Bash}
echo "Langage de programmation défini sur : $language"

## Combinaison avec un délai d'attente en utilisant l'option -t
echo "Réponse rapide requise :"
read -t 5 -p "Quelle est votre couleur préférée ? (Vous avez 5 secondes, par défaut : Blue) : " color
color=${color:-Blue}
echo "Couleur préférée définie sur : $color"

Ce script :

Utilise le flag -p pour afficher une invite dans la même commande read, rendant le code plus concis
Applique la syntaxe ${variable:-default} pour définir une valeur par défaut si l'entrée utilisateur est vide
Démontre l'option -t, qui définit un délai d'attente pour l'entrée (5 secondes dans cet exemple)

Enregistrez le fichier en appuyant sur Ctrl+O, puis appuyez sur Entrée pour confirmer le nom du fichier, et quittez nano en appuyant sur Ctrl+X.
Exécutez le script pour le tester :
```
./input_reader.sh
```
Essayez ces scénarios :
- Entrez un nom de pays lorsque vous y êtes invité, puis appuyez sur Entrée
- Appuyez simplement sur Entrée (sans taper rien) pour accepter la valeur par défaut
- Pour l'exemple avec délai d'attente, essayez d'attendre plus de 5 secondes pour voir ce qui se passe
Exemple de sortie lorsque vous acceptez les valeurs par défaut :
```
Entrez votre pays (par défaut : USA) :
Pays défini sur : USA
Entrez votre langage de programmation préféré (par défaut : Bash) :
Langage de programmation défini sur : Bash
Réponse rapide requise :
Quelle est votre couleur préférée ? (Vous avez 5 secondes, par défaut : Blue) :
Couleur préférée définie sur : Blue
```

L'option -p de la commande read vous permet de fournir une invite dans la même commande, rendant vos scripts plus clairs et plus lisibles. La syntaxe ${variable:-default} est une fonctionnalité puissante du shell qui remplace une variable par une valeur par défaut lorsque celle-ci n'est pas définie ou est vide, ce qui est parfait pour fournir des options par défaut dans les scripts.

Lecture d'entrées sécurisées et de plusieurs variables

Dans cette étape finale, vous allez apprendre deux techniques plus avancées :

Lire des entrées sécurisées (comme des mots de passe) sans afficher les caractères à l'écran
Lire plusieurs variables avec une seule commande read
Ouvrez votre script pour le modifier :
```
nano input_reader.sh
```

Remplacez le contenu existant par le code suivant :

#!/bin/bash

## Script démontrant la lecture d'entrées sécurisées et de plusieurs variables

## Lecture d'entrée sécurisée avec le flag -s (pas d'affichage)
echo "Exemple d'entrée sécurisée :"
read -p "Nom d'utilisateur : " username
read -s -p "Mot de passe : " password
echo ## Ajoute un saut de ligne après l'entrée du mot de passe
echo "Nom d'utilisateur entré : $username"
echo "Longueur du mot de passe : ${#password} caractères"

## Lecture de plusieurs variables en une seule fois
echo -e "\nExemple de plusieurs variables :"
read -p "Entrez le prénom, le nom de famille et l'âge (séparés par des espaces) : " first_name last_name age

echo "Prénom : $first_name"
echo "Nom de famille : $last_name"
echo "Âge : $age"

## Lecture avec un délimiteur personnalisé
echo -e "\nExemple de délimiteur personnalisé :"
read -p "Entrez des valeurs séparées par des virgules : " -d "," value1
echo ## Ajoute un saut de ligne
echo "Première valeur avant la virgule : $value1"

echo -e "\nMerci d'avoir terminé ce lab sur la lecture d'entrées Linux !"

Ce script :

Utilise le flag -s avec la commande read pour masquer l'entrée (utile pour les mots de passe ou autres informations sensibles)
Montre comment lire plusieurs variables à partir d'une seule ligne d'entrée en fournissant plusieurs noms de variables à la commande read
Démontre le flag -d pour spécifier un délimiteur personnalisé (au lieu du caractère de saut de ligne par défaut)

Enregistrez le fichier en appuyant sur Ctrl+O, puis appuyez sur Entrée pour confirmer le nom du fichier, et quittez nano en appuyant sur Ctrl+X.

Exécutez le script pour le tester :

./input_reader.sh

Exemple de sortie (vos entrées seront différentes) :

Exemple d'entrée sécurisée :
Nom d'utilisateur : john_doe
Mot de passe :
Nom d'utilisateur entré : john_doe
Longueur du mot de passe : 8 caractères

Exemple de plusieurs variables :
Entrez le prénom, le nom de famille et l'âge (séparés par des espaces) : John Doe 30
Prénom : John
Nom de famille : Doe
Âge : 30

Exemple de délimiteur personnalisé :
Entrez des valeurs séparées par des virgules : test,
Première valeur avant la virgule : test

Merci d'avoir terminé ce lab sur la lecture d'entrées Linux !

La sécurité est importante lorsqu'il s'agit de gérer des informations sensibles comme les mots de passe. Le flag -s garantit que les caractères tapés ne sont pas affichés à l'écran. Notez que dans l'exemple du mot de passe, le script n'affiche que la longueur du mot de passe pour vérification, pas le mot de passe réel.

La lecture de plusieurs variables en une seule fois peut rendre vos scripts plus efficaces et plus conviviaux. Lorsque la commande read reçoit plusieurs noms de variables, elle divise l'entrée en fonction de la variable d'environnement IFS (Internal Field Separator), qui est par défaut l'espace blanc (espaces, tabulations et sauts de ligne).

Le flag -d vous permet de changer le délimiteur qui indique la fin de l'entrée. Par défaut, read s'arrête à un saut de ligne (lorsque vous appuyez sur Entrée), mais vous pouvez le changer pour n'importe quel caractère, comme une virgule dans l'exemple.

Résumé

Dans ce lab, vous avez appris les techniques clés pour lire et traiter les entrées utilisateur dans les scripts bash Linux :

Lecture d'entrée de base : Utilisation de la commande read pour capturer les entrées utilisateur dans des variables.
Entrée basée sur une boucle : Mise en œuvre de boucles pour lire continuellement les entrées jusqu'à ce qu'une condition spécifique soit remplie.
Valeurs par défaut et invites : Définition de valeurs par défaut pour les entrées et création de scripts plus clairs avec des invites intégrées.
Techniques avancées : Lecture d'entrées sécurisées sans les afficher à l'écran, capture de plusieurs variables en une seule commande et utilisation de délimiteurs personnalisés.

Ces compétences en matière de lecture d'entrées sont fondamentales pour créer des scripts shell interactifs qui peuvent s'adapter aux entrées utilisateur, fournir des valeurs par défaut et gérer différents types de données. Vous pouvez maintenant appliquer ces techniques pour créer des outils et des scripts de ligne de commande plus réactifs et conviviaux.

Au fur et à mesure que vous continuez à développer vos compétences en Linux, envisagez de combiner ces méthodes de lecture d'entrées avec d'autres fonctionnalités bash telles que les instructions conditionnelles, les fonctions et les opérations sur les fichiers pour créer des outils plus complexes et puissants pour l'automatisation et la gestion des systèmes.