QCM : Programmation en shell et Bash (30 questions)

Questions et réponses du QCM

1. Quelle description caractérise un script shell ?

Une commande Unix unique exécutée sans variable ni structure de contrôle
Un programme interprété qui enchaîne des commandes et peut utiliser des variables et des contrôles
Un interpréteur qui lance des commandes sans pouvoir les enchaîner
Un programme compilé qui transforme des commandes en langage machine

Un programme interprété qui enchaîne des commandes et peut utiliser des variables et des contrôles

Explication

Un script shell est interprété par un shell et enchaîne des commandes Unix, avec la possibilité d’utiliser des variables et des structures de contrôle. Le programme compilé confond interprétation et compilation, la commande unique néglige l’enchaînement, et l’absence d’enchaînement contredit la fonction du script.

2. Quel shell est présenté comme le shell par défaut sur Linux et comme une version améliorée de sh ?

sh
Python
bash
zsh

bash

Explication

Le shell utilisé dans le cours est bash, décrit comme une version améliorée de sh et présenté comme le shell par défaut sur Linux. sh est la version de base, zsh n’est pas le shell indiqué, et Python est un langage de plus haut niveau.

3. Une équipe veut un outil rapide et fiable, réutilisable sans modification sur différents systèmes, avec des structures de données élaborées et des graphiques. Quel choix convient le mieux ?

Un script shell enrichi de variables et de boucles
Un script shell fondé sur les commandes Unix
Un script shell accompagné de programmes installés
Un langage de plus haut niveau comme C ou Python

Un langage de plus haut niveau comme C ou Python

Explication

Pour les exigences de rapidité, fiabilité, portabilité, structures de données élaborées ou graphisme, un langage de plus haut niveau comme C ou Python est privilégié. Le shell malgré ses limites ignore les critères du cas; variables, boucles et programmes installés ne changent pas ces limites.

4. Un script doit être exécuté avec bash même si le shell habituel de l’utilisateur est différent. Quelle ligne placer au début du fichier ?

bash
#
#!/bin/bash
#!/bin/sh

#!/bin/bash

Explication

La ligne initiale `#!/bin/bash` indique que bash doit interpréter le script, au lieu de laisser ce choix au shell de l’utilisateur. `#!/bin/sh` désigne un autre interpréteur, `bash` seul n’est pas la ligne de sha-bang, et `#` seul ne précise pas le chemin de l’interpréteur.

5. L’utilisateur possède le fichier `hello.sh`, qui n’a pas le droit d’exécution. Quelle commande permet de le lancer sans modifier ses permissions ?

hello.sh
chmod u+x hello.sh
./hello.sh
bash hello.sh

bash hello.sh

Explication

La commande `bash hello.sh` exécute le fichier avec bash sans exiger le droit d’exécution. `./hello.sh` exige le droit +x, `chmod u+x hello.sh` modifie les permissions au lieu de lancer le script, et `hello.sh` ne précise pas l’interpréteur ni le chemin courant.

6. Dans un script, quelle commande affecte sans erreur la valeur « salut » à la variable message ?

message=salut
salut=message
message = salut
$message=salut

message=salut

Explication

Une affectation shell s’écrit nom=valeur, sans espace autour du signe égal ; le préfixe $ sert à lire la variable. Les espaces rendent ici l’affectation incorrecte, le préfixe $ est déplacé de la lecture à l’écriture, et « salut=message » inverse le nom et la valeur.

7. Quelle caractéristique décrit une variable shell, qu’elle contienne « 7 » ou « salut » ?

Elle associe un nom à une valeur dont le type dépend du contenu.
Elle associe un nom à une valeur qui ne peut pas être modifiée.
Elle associe un nom à une valeur dont les guillemets fixent le type.
Elle associe un nom à une valeur, sans notion de type.

Elle associe un nom à une valeur, sans notion de type.

Explication

Une variable shell se caractérise par un nom et une valeur, sans notion de type. Un contenu numérique ne lui confère pas un type numérique, et ni l’immutabilité ni un type déterminé par les guillemets ne caractérisent la variable.

8. Un script doit attendre que l’utilisateur saisisse son prénom et conserver cette réponse dans la variable prenom. Quelle commande convient ?

read prenom
echo $prenom
echo prenom
prenom=utilisateur

read prenom

Explication

La commande read attend une réponse de l’utilisateur et la stocke dans la variable indiquée. Echo affiche du texte, l’affectation proposée fixe une valeur au lieu de recueillir la saisie, et echo avec $prenom affiche une valeur déjà stockée.

9. Un script affiche « Bonjour... » puis « Comment allez-vous ? » sur la même ligne. Quelle commande permet de supprimer le retour à la ligne après le premier texte ?

echo "Bonjour... "
echo -n "Bonjour... "
echo -s "Bonjour... "
echo -p "Bonjour... "

echo -n "Bonjour... "

Explication

L’option -n de echo supprime le retour à la ligne après le texte affiché, ce qui permet au second texte de suivre sur la même ligne. L’option -p appartient à read pour afficher une invite, -s masque une saisie et echo sans option conserve le retour à la ligne.

10. Un script nommé `rapport.sh` est lancé avec les arguments `rouge`, `bleu` et `vert`. Quelles valeurs donnent respectivement `$0`, `$#` et `$2` ?

`rouge`, `3`, `bleu`
`rapport.sh`, `3`, `bleu`
`rapport.sh`, `3`, `vert`
`rapport.sh`, `2`, `vert`

`rapport.sh`, `3`, `bleu`

Explication

`$0` contient le nom du script, `$#` le nombre d’arguments et `$2` le deuxième argument. `rouge` confond le nom du script avec le premier argument, `2` compte mal les arguments et `vert` désigne le troisième argument.

11. Après l’exécution d’une commande, quelle information la variable spéciale `$?` contient-elle ?

Le code de sortie de la prochaine commande exécutée
Le code de sortie de la dernière commande exécutée
Le nom de la dernière commande exécutée
Le nombre d’arguments transmis au script

Le code de sortie de la dernière commande exécutée

Explication

`$?` mémorise le code de sortie renvoyé par la dernière commande exécutée. Le nombre d’arguments relève de `$#`, le nom du script de `$0`, et le code de la prochaine commande n’est pas encore disponible.

12. Un script exécute une commande qui renvoie le code de sortie `0`. Comment faut-il interpréter ce résultat selon la convention présentée ?

L’exécution s’est déroulée sans erreur
L’exécution a signalé un cas d’erreur
La commande n’a pas été exécutée
La commande a reçu zéro argument

L’exécution s’est déroulée sans erreur

Explication

Par convention, un code de sortie égal à zéro indique une exécution sans erreur, tandis que les valeurs non nulles signalent une erreur. L’interprétation comme erreur inverse cette convention; le nombre d’arguments et l’exécution effective sont des notions distinctes.

13. Dans un script, `let "a = 8"`, `let "b = 3"`, puis `let "c = a + b"` sont exécutés. Quelle valeur est attribuée à `c` ?

5
11
24
38

11

Explication

`let` évalue l’expression arithmétique : ici, 8+3=118 + 3 = 11. Le résultat `5` vient d’une soustraction, `24` d’une multiplication et `38` d’une lecture erronée des opérandes.

14. Un script utilise `let` pour calculer le reste d’une division entière. Quel opérateur doit-il employer ?

`*`
`/`
`%`
`**`

`%`

Explication

Dans les opérations arithmétiques de `let`, `%` désigne le modulo, c’est-à-dire le reste de la division entière. `/` effectue la division entière, `**` la puissance et `*` la multiplication.

15. Dans un test shell, un programme doit vérifier si la valeur numérique de `score` est supérieure ou égale à `10`. Quel opérateur relationnel correspond à cette condition ?

`=`
`-ge`
`-le`
`-gt`

`-ge`

Explication

L’opérateur `-ge` exprime la supériorité ou l’égalité, donc il convient pour une valeur au moins égale à 10. `-gt` exclut l’égalité, `-le` inverse le sens de comparaison et `=` teste l’égalité.

16. Un script doit demander à l’utilisateur de saisir son nom au clavier et placer la saisie dans la variable `nom`. Quelle commande convient ?

`echo nom`
`nom="read"`
`cat nom`
`read nom`

`read nom`

Explication

La commande `read nom` recueille au clavier une valeur et la place dans la variable `nom`. `echo` affiche, l’affectation donne ici une valeur littérale et `cat` lit un fichier.

17. La variable `chaine` contient `abcdef`. Quelle expression affiche exactement `cd` si les positions commencent à zéro ?

`${chaine:0:2}`
`${chaine:3:2}`
`${chaine:2:2}`
`${chaine:2}`

`${chaine:2:2}`

Explication

`${chaine:pos:n}` commence à la position `pos` et limite l’affichage à `n` caractères : ici, la position 2 et deux caractères donnent `cd`. `${chaine:2}` affiche toute la suite, tandis que les autres expressions choisissent une autre position.

18. Dans un script, `condition1` est fausse et `condition2` est vraie. Quel bloc une instruction `if` avec `elif` et `else` exécute-t-elle ?

Les instructions associées à `condition1`
Les instructions du bloc `else`
Les instructions des deux conditions
Les instructions associées à `condition2`

Les instructions associées à `condition2`

Explication

L’instruction teste la seconde condition lorsque la première est fausse et exécute son bloc si elle est vraie. Le bloc de `condition1` suppose cette condition vraie, `else` intervient si aucune condition ne l’est, et les blocs conditionnels ne s’exécutent pas successivement.

19. Un script doit vérifier qu’un chemin désigne un lien symbolique et que ce lien est lisible. Quelles options de test de fichier correspondent à ces vérifications ?

`-L` et `-r`
`-e` et `-r`
`-d` et `-r`
`-f` et `-r`

`-L` et `-r`

Explication

L’option `-L` teste si le chemin est un lien symbolique et `-r` s’il est lisible. `-f` vise un fichier ordinaire, `-e` son existence et `-d` un répertoire.

20. Vous écrivez une condition de test Bash sous la forme `if [ condition ]; then`. Quelle règle d’espacement faut-il respecter ?

Écrire `[condition]` sans espace autour de la condition
Séparer les crochets et la condition par des espaces
Écrire `[condition ]` avec un espace après la condition
Écrire `[ condition]` avec un espace avant le crochet fermant

Séparer les crochets et la condition par des espaces

Explication

Dans cette syntaxe, des espaces doivent séparer les crochets de la condition, comme dans `[ condition ]`. Les formes collées aux crochets ne respectent pas cette règle.

21. Dans un script, une instruction `case` compare `mode` à `lecture` et `écriture`, puis doit traiter toute autre valeur par défaut. Quel motif permet d’exécuter ces commandes de repli avant `esac` ?

`""`
`esac`
`;;`
`*`

`*`

Explication

Le motif `*` peut servir de cas par défaut et ses commandes s’exécutent lorsque les autres valeurs ne correspondent pas. `;;` termine une branche, `esac` ferme l’instruction et `""` désigne une chaîne vide.

22. Un script applique un `case` à `$1` avec les motifs `""`, `-*` et `*`. Si le premier argument est `-v`, quel traitement est choisi ?

Il est traité comme une option.
Il est traité comme un argument ordinaire.
Il signale l’absence d’option.
Il est traité comme une valeur par défaut sans catégorie.

Il est traité comme une option.

Explication

Le motif `-*` reconnaît un argument dont le premier caractère est un tiret et le traite comme une option. Le motif `*` concerne les autres arguments, tandis que `""` correspond à une chaîne vide.

23. Une boucle `for couleur in rouge vert bleu` contient des instructions entre `do` et `done`. Quel comportement doit-on attendre ?

Elle affecte successivement chaque valeur à `couleur` et exécute les instructions.
Elle affecte toute la liste à `couleur` et exécute les instructions une fois.
Elle affecte successivement chaque valeur à `couleur` sans exécuter les instructions.
Elle exécute les instructions, puis affecte successivement les valeurs à `couleur`.

Elle affecte successivement chaque valeur à `couleur` et exécute les instructions.

Explication

Une boucle `for` parcourt les valeurs de la liste, affecte chacune à la variable, puis exécute les instructions délimitées par `do` et `done`. Traiter la liste comme une valeur unique ou inverser l’ordre des opérations ne correspond pas à ce fonctionnement.

24. Un script doit répéter des instructions tant que la condition `fichier_prêt` est fausse, puis s’arrêter quand elle devient vraie. Quelle boucle correspond à ce comportement ?

Une boucle `for fichier_prêt`.
Une boucle `while fichier_prêt`.
Une boucle `case fichier_prêt`.
Une boucle `until fichier_prêt`.

Une boucle `until fichier_prêt`.

Explication

`until` répète les instructions jusqu’à ce que sa condition devienne vraie; la boucle s’exécute donc pendant que `fichier_prêt` est fausse. `while` continue au contraire tant que sa condition est vraie, et `for` sert à parcourir une liste.

25. Un script utilise `for element` sans fournir de liste après le nom de la variable. Sur quelles valeurs la boucle parcourt-elle alors ?

Les noms des fichiers du répertoire courant.
Aucune valeur, car une liste explicite est requise.
Les variables d’environnement du processus.
Les arguments transmis au script.

Les arguments transmis au script.

Explication

Sans liste fournie à `for`, la boucle parcourt les arguments du script. Les variables d’environnement et les fichiers du répertoire ne remplacent pas cette liste implicite.

26. Dans une boucle Bash, un script doit sauter le reste du corps pour l’itération courante, puis reprendre la boucle à l’itération suivante. Quel mot-clé faut-il utiliser ?

break
return
continue
read

continue

Explication

`continue` ignore les commandes restantes de l’itération en cours et passe à la suivante. `break` sort de la boucle, `read` sert à lire une entrée et `return` termine une fonction.

27. Un script doit traiter un fichier ligne par ligne, y compris lorsque certaines lignes contiennent des espaces ou des caractères jokers. Quelle méthode convient le mieux ?

Une boucle `for` alimentée par la sortie de `cat`
Une boucle `while read -r ligne` avec le fichier redirigé en entrée
Une boucle `for` alimentée par la sortie de `ls`
Une boucle `while read ligne` sans option ni redirection

Une boucle `while read -r ligne` avec le fichier redirigé en entrée

Explication

La boucle `while read -r` avec le fichier redirigé en entrée permet de traiter les lignes en évitant les problèmes liés aux espaces et aux jokers rencontrés avec `cat` ou `ls` dans une boucle `for`. La sortie de `cat` peut découper le contenu, `ls` ne lit pas les lignes du fichier, et l’absence de `-r` modifie le traitement des antislashs.

28. Un tableau indexé Bash nommé `Unix` contient plusieurs distributions. Quelle expression affiche son nombre d’éléments ?

`${Unix[@]}`
`${#Unix[1]}`
`${#Unix[@]}`
`${Unix[1]}`

`${#Unix[@]}`

Explication

La forme `${#Unix[@]}` donne le nombre d’éléments du tableau. `${Unix[1]}` accède à un élément, `${Unix[@]}` développe son contenu complet et `${#Unix[1]}` donne la longueur de l’élément d’indice 1.

29. Quelle syntaxe est valide pour définir une fonction Bash nommée `saluer` ?

`saluer() { commandes; }`
`saluer=('commandes')`
`saluer { commandes; }`
`saluer function { commandes; }`

`saluer() { commandes; }`

Explication

Une fonction Bash peut être définie sous la forme `nom() { expressions; }`, ou avec le mot-clé `function` placé avant le nom. La forme avec `function` après le nom est incorrecte, la liste entre parenthèses déclare ici un tableau et la forme sans parenthèses ne respecte pas la syntaxe de fonction.

30. Une fonction Bash exécute `return 42`, puis le script appelle cette fonction. Quelle variable implicite permet de récupérer la valeur de retour ?

`$PATH`
`$?`
`$#`
`$(cat)`

`$?`

Explication

`return` termine la fonction et sa valeur de retour est récupérée dans la variable implicite `$?`. `$#` indique le nombre d’arguments, `$PATH` contient des chemins de recherche et `$(cat)` exécute une substitution de commande.

Révisez avec les flashcards

Mémorisez les réponses avec 87 flashcards sur Programmation en shell et Bash.

Qu’est-ce qu’un script Shell ?

Un programme interprété par un shell qui enchaîne des commandes Unix.

Quelles structures un script Shell peut-il utiliser ?

Des structures de contrôle et des variables.

Quel shell le cours utilise-t-il ?

Bash, une version améliorée de sh présentée comme le shell par défaut sur Linux.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Programmation en shell et Bash.

Voir la fiche →

Cours similaires

Crée tes propres QCM

Importe ton cours et l'IA génère des QCM avec corrections en 30 secondes.

Générateur de QCM