Voici un exemple de script shell qui affiche les paramètres passés sur la ligne de commande, retourne

leur nombre et utilise la variable du shell pour stocker la valeur de retour :

```bash

# !/bin/bash

# Afficher les paramètres passés

Echo « Paramètres passés : »

For arg in « $@ » ; do

Echo « $arg »

Done

# Récupérer le nombre de paramètres

Num_params=$#

# Afficher le nombre de paramètres

Echo « Nombre de paramètres : $num_params »

# Retourner le nombre de paramètres comme valeur de retour

Exit $num_params

```

Vous pouvez enregistrer ce script dans un fichier, par exemple `parametres.sh`, puis le rendre
exécutable avec la commande `chmod +x parametres.sh`. Ensuite, vous pouvez l’exécuter depuis la
ligne de commande en passant des arguments. Par exemple :

```

$ ./parametres.sh arg1 arg2 arg3

```

Le script affichera les paramètres passés (arg1, arg2, arg3 dans cet exemple) et le nombre total de
paramètres. La valeur de retour sera stockée dans la variable du shell correspondante (utilisez `$ ?`
pour afficher la valeur de retour en bash ou `$status` en csh). Vous pouvez vérifier la valeur de retour
en utilisant :

```

$ echo $ ?

```

Cela affichera la valeur de retour du script, qui est égale au nombre de paramètres passés.

Exo2 :

Voici un exemple de script shell qui additionne les nombres placés sur la ligne de commande et
affiche le résultat :

```bash

# !/bin/bash

# Initialiser la variable de résultat à 0

Result=0

# Parcourir les arguments passés sur la ligne de commande

For arg in « $@ » ; do

# Vérifier si l’argument est un nombre entier

If [[ $arg =~ ^[0-9]+$ ]] ; then

# Additionner l’argument au résultat actuel

Result=$((result + arg))

Fi

Done

# Afficher le résultat
Echo « Résultat de l’addition : $result »

```

Vous pouvez enregistrer ce script dans un fichier, par exemple `addition.sh`, puis le rendre
exécutable en utilisant la commande `chmod +x addition.sh`. Ensuite, vous pouvez l’exécuter depuis
la ligne de commande en passant les nombres à additionner. Par exemple :

```

$ ./addition.sh 10 20 30

```

Le script additionnera les nombres (10, 20 et 30 dans cet exemple) et affichera le résultat (60 dans
cet exemple).

Voici la modification du script shell « addition.sh » pour qu’il prenne les nombres à additionner à
partir d’un fichier dont le nom est précisé sur la ligne de commande. Le fichier doit contenir un
nombre par ligne :

```bash

# !/bin/bash

# Vérifier si le nom de fichier est précisé en argument

If [ $# -eq 0 ] ; then

Echo « Erreur : Veuillez spécifier le nom du fichier contenant les nombres à additionner. »

Exit 1

Fi

# Récupérer le nom du fichier à partir des arguments

Filename=$1

# Vérifier si le fichier existe

If [ ! -f « $filename » ] ; then
 Echo « Erreur : Le fichier ‘$filename’ n’existe pas. »

Exit 1

Fi

# Initialiser la variable de résultat à 0

Result=0

# Lire le fichier ligne par ligne

While IFS= read -r number ; do

# Vérifier si la ligne est un nombre entier

If [[ $number =~ ^[0-9]+$ ]] ; then

# Additionner le nombre au résultat actuel

Result=$((result + number))

Fi

Done < « $filename »

# Afficher le résultat

Echo « Résultat de l’addition : $result »

```

Vous pouvez enregistrer ce script dans un fichier, par exemple `addition.sh`, puis le rendre
exécutable en utilisant la commande `chmod +x addition.sh`. Ensuite, vous pouvez l’exécuter depuis
la ligne de commande en passant le nom du fichier contenant les nombres à additionner. Par
exemple :

```

$ ./addition.sh nombres.txt

```

Assurez-vous de créer un fichier `nombres.txt` contenant les nombres à additionner, un nombre par
ligne.
Le script lira les nombres à partir du fichier, les additionnera et affichera le résultat. Si le fichier
spécifié n’existe pas, une erreur sera affichée. Si aucun nom de fichier n’est précisé en argument, une
autre erreur sera affichée.

Voici la modification du script shell « addition.sh » pour qu’il prenne les nombres à additionner à
partir de l’entrée standard si aucun nom de fichier n’a été donné sur la ligne de commande :

```bash

# !/bin/bash

# Vérifier si un nom de fichier est précisé en argument

If [ $# -eq 1 ] ; then

Filename=$1

# Vérifier si le fichier existe

If [ ! -f « $filename » ] ; then

Echo « Erreur : Le fichier ‘$filename’ n’existe pas. »

Exit 1

Fi

# Lire le fichier ligne par ligne

While IFS= read -r number ; do

# Vérifier si la ligne est un nombre entier

If [[ $number =~ ^[0-9]+$ ]] ; then

# Additionner le nombre au résultat actuel

Result=$((result + number))

Fi

Done < « $filename »

Else

# Lire l’entrée standard ligne par ligne

While IFS= read -r number ; do

 # Vérifier si la ligne est un nombre entier

If [[ $number =~ ^[0-9]+$ ]] ; then

# Additionner le nombre au résultat actuel

Result=$((result + number))

Fi

Done

Fi

# Afficher le résultat

Echo « Résultat de l’addition : $result »

```

Maintenant, si un nom de fichier est précisé en argument, le script lira les nombres à partir de ce
fichier. Sinon, il lira les nombres depuis l’entrée standard.

Vous pouvez enregistrer ce script dans un fichier, par exemple `addition.sh`, puis le rendre
exécutable en utilisant la commande `chmod +x addition.sh`. Ensuite, vous pouvez l’exécuter depuis
la ligne de commande de deux manières :

1. Avec un fichier contenant les nombres à additionner :

````

$ ./addition.sh nombres.txt

```

Assurez-vous de créer un fichier `nombres.txt` contenant les nombres à additionner, un nombre

par ligne.

2. En entrant les nombres directement depuis l’entrée standard :

````

$ ./addition.sh
 10

20

30

<Ctrl+D>

```

Dans cet exemple, vous entrez les nombres 10, 20 et 30 sur des lignes séparées, puis vous appuyez
sur `<Ctrl+D>` pour indiquer la fin de l’entrée.

Le script additionnera les nombres fournis et affichera le résultat. Si le fichier spécifié n’existe pas et
aucun nom de fichier n’est donné en argument, le script lira les nombres depuis l’entrée standard.

Exo3 :

Voici un exemple de script shell nommé « identite.sh » qui affiche son PID (Process ID) et celui de son
parent (PPID – Parent Process ID) :

```bash

# !/bin/bash

# Afficher le PID du script

Echo « PID du script : $$ »

# Afficher le PPID du script (PID du parent)

Echo « PID du parent : $PPID »

```

Vous pouvez enregistrer ce script dans un fichier, par exemple `identite.sh`, puis le rendre exécutable
en utilisant la commande `chmod +x identite.sh`. Ensuite, vous pouvez l’exécuter depuis la ligne de
commande :

```
$ ./identite.sh

```

Le script affichera le PID du script (c’est-à-dire son propre PID) et le PPID du script (c’est-à-dire le PID
de son parent).

Notez que le PID est un identifiant unique attribué à chaque processus en cours d’exécution dans le
système d’exploitation. Le PPID représente le PID du parent du processus en question.

Voici la version modifiée du script shell « identite.sh » qui ajoute un appel à la fonction `sleep()` pour
attendre 10 secondes avant d’exécuter les appels à `getpid()` et `getppid()` :

```bash

# !/bin/bash

# Attendre 10 secondes

Sleep 10

# Afficher le PID du script

Echo « PID du script : $$ »

# Afficher le PPID du script (PID du parent)

Echo « PID du parent : $PPID »

```

Dans ce script, la fonction `sleep` est utilisée pour suspendre l’exécution du programme pendant 10
secondes avant d’afficher les PID du script et du parent.

Vous pouvez enregistrer ce script dans un fichier, par exemple `identite.sh`, puis le rendre exécutable
en utilisant la commande `chmod +x identite.sh`. Ensuite, vous pouvez l’exécuter depuis la ligne de
commande :
```

$ ./identite.sh

```

Le script attendra pendant 10 secondes, puis affichera le PID du script (son propre PID) et le PPID du
script (le PID de son parent).

Voici un exemple de script shell qui crée un processus fils. Le processus père affichera son identité
ainsi que celle de son fils, et le processus fils affichera son identité ainsi que celle de son père :

```bash

# !/bin/bash

# Créer un processus fils

Echo « Création du processus fils… »

./fils.sh &

# Attendre un court instant pour laisser le processus fils s’exécuter

Sleep 1

# Afficher l’identité du processus père

Echo « Identité du processus père : »

Echo « PID : $$ »

Echo « PPID : $PPID »

# Afficher l’identité du processus fils

Echo « Identité du processus fils : »

Cat fils_identity.txt

```
Ce script crée un processus fils en exécutant le script `fils.sh` en arrière-plan avec l’opérateur `&`. Le
processus père attend ensuite un court instant pour laisser le processus fils s’exécuter. Ensuite, le
processus père affiche son identité (PID et PPID) et lit le contenu du fichier `fils_identity.txt` pour
afficher l’identité du processus fils. Le fichier `fils_identity.txt` sera créé et rempli par le script `fils.sh`.

Vous devez créer un autre script appelé `fils.sh` avec le contenu suivant :

```bash

# !/bin/bash

# Afficher l’identité du processus fils

Echo « Identité du processus fils : »

Echo « PID : $$ »

Echo « PPID : $PPID »

# Enregistrer l’identité du processus fils dans un fichier

Echo « PID : $$ » > fils_identity.txt

Echo « PPID : $PPID » >> fils_identity.txt

```

Ce script affiche l’identité du processus fils (PID et PPID) et enregistre ces informations dans le fichier
`fils_identity.txt`.

Assurez-vous de rendre les deux scripts exécutables en utilisant la commande `chmod +x identite.sh
fils.sh`. Ensuite, vous pouvez exécuter le script `identite.sh` :

```

$ ./identite.sh

```

Le processus père affichera son identité ainsi que celle du processus fils, tandis que le processus fils
affichera son identité ainsi que celle du processus père.
Pour reproduire le phénomène d’« adoption » des processus, où le père se termine avant que le fils
n’appelle `getppid()`, vous pouvez modifier le script `fils.sh` pour ajouter un délai avant l’appel à
`getppid()`. Voici le script modifié :

```bash

# !/bin/bash

# Attendre un court instant pour que le processus père se termine

Sleep 1

# Afficher l’identité du processus fils

Echo « Identité du processus fils : »

Echo « PID : $$ »

Echo « PPID : $PPID »

```

En ajoutant la ligne `sleep 1`, le script fils attendra pendant 1 seconde avant d’appeler `getppid()`.
Cela permettra au processus père de se terminer avant que le fils n’exécute cette instruction.

Assurez-vous de rendre le script `fils.sh` exécutable en utilisant la commande `chmod +x fils.sh`.

Ensuite, vous pouvez exécuter le script `identite.sh` comme précédemment :

```

$ ./identite.sh

```

Cette fois, le processus père terminera son exécution avant que le processus fils n’appelle `getppid()`,
ce qui donnera l’impression que le processus fils a été « adopté » par le processus père.
Pour éviter que le processus père ne se termine avant le processus fils, vous pouvez ajouter un appel
à la fonction `wait(NULL)` dans le script `identite.sh`. Voici le script modifié :

```bash

# !/bin/bash

# Créer un processus fils

Echo « Création du processus fils… »

./fils.sh &

# Attendre que le processus fils se termine

Wait $ !

# Afficher l’identité du processus père

Echo « Identité du processus père : »

Echo « PID : $$ »

Echo « PPID : $PPID »

```

En ajoutant la ligne `wait $ !`, le processus père attendra que le processus fils se termine avant de
continuer son exécution. L’argument `$ !` représente le PID du dernier processus en arrière-plan
créé.

Le script `fils.sh` reste inchangé :

```bash

# !/bin/bash

# Attendre un court instant pour que le processus père se termine

Sleep 1
# Afficher l’identité du processus fils

Echo « Identité du processus fils : »

Echo « PID : $$ »

Echo « PPID : $PPID »

```

Assurez-vous de rendre les deux scripts `identite.sh` et `fils.sh` exécutables en utilisant la commande
`chmod +x identite.sh fils.sh`. Ensuite, vous pouvez exécuter le script `identite.sh` :

```

$ ./identite.sh

```

Cette fois, le processus père attendra que le processus fils se termine avant d’afficher son identité.
Cela garantit que le processus père ne se termine pas avant que le fils n’ait terminé son exécution.

Pour obtenir le code de retour du processus fils à l’aide de la fonction `wait()`, vous pouvez modifier
le script `identite.sh` comme suit :

```bash

# !/bin/bash

# Créer un processus fils

Echo « Création du processus fils… »

./fils.sh &

# Attendre que le processus fils se termine et récupérer son code de retour

Wait $ !

Return_code=$ ?
# Afficher l’identité du processus père

Echo « Identité du processus père : »

Echo « PID : $$ »

Echo « PPID : $PPID »

# Afficher le code de retour du processus fils

Echo « Code de retour du processus fils : $return_code »

```

La fonction `wait $ !` attend que le processus fils se termine et récupère son code de retour. Ensuite,
le code de retour est stocké dans la variable `return_code`. Enfin, le script affiche l’identité du
processus père et le code de retour du processus fils.

Le script `fils.sh` reste identique :

```bash

# !/bin/bash

# Attendre un court instant pour que le processus père se termine

Sleep 1

# Afficher l’identité du processus fils

Echo « Identité du processus fils : »

Echo « PID : $$ »

Echo « PPID : $PPID »

# Code de retour du processus fils

Exit 42

```

Assurez-vous de rendre les deux scripts `identite.sh` et `fils.sh` exécutables en utilisant la commande
`chmod +x identite.sh fils.sh`. Ensuite, vous pouvez exécuter le script `identite.sh` :
```

$ ./identite.sh

```

Le processus père attendra que le processus fils se termine, puis affichera son identité ainsi que le
code de retour du processus fils. Dans cet exemple, le code de retour du processus fils est 42, mais
vous pouvez le modifier dans le script `fils.sh` selon vos besoins.

Pour créer trois processus fils et les faire se terminer dans un ordre différent de celui dans lequel ils
ont été créés, vous pouvez utiliser une combinaison de la fonction `sleep()` et de la fonction `wait()`.
Voici un exemple de script shell qui réalise cette tâche :

```bash

# !/bin/bash

# Créer le premier processus fils

Echo « Création du premier processus fils… »

Sleep 3 # attendre 3 secondes

./fils.sh 1 &

# Créer le deuxième processus fils

Echo « Création du deuxième processus fils… »

Sleep 2 # attendre 2 secondes

./fils.sh 2 &

# Créer le troisième processus fils

Echo « Création du troisième processus fils… »

Sleep 1 # attendre 1 seconde

./fils.sh 3 &
# Attendre la fin des trois fils et afficher l’ordre de terminaison

Echo « Attente de la fin des processus fils… »

Wait %1

Echo « Le premier fils s’est terminé. »

Wait %2

Echo « Le deuxième fils s’est terminé. »

Wait %3

Echo « Le troisième fils s’est terminé. »

Echo « Tous les fils se sont terminés. »

```

Dans ce script, nous créons trois processus fils avec des délais différents entre eux en utilisant la
fonction `sleep()`. Ensuite, nous utilisons la fonction `wait` avec les identifiants de tâche (`%1`, `%2`, `
%3`) pour attendre la fin de chaque fils dans l’ordre souhaité. Après chaque appel à `wait`, nous
affichons un message indiquant l’ordre de terminaison du fils correspondant. Enfin, nous affichons un
message pour indiquer que tous les fils se sont terminés.

Le script `fils.sh` est un exemple fictif qui peut être personnalisé selon vos besoins. Voici un exemple
minimal :

```bash

# !/bin/bash

Echo « Je suis le processus fils $1. »

# Temps d’exécution aléatoire

Sleep $((RANDOM % 5))

Exit 0

```

Ce script affiche simplement un message indiquant son identité (numéro du fils) et attend un temps
d’exécution aléatoire avant de se terminer.

Assurez-vous de rendre les deux scripts `identite.sh` et `fils.sh` exécutables en utilisant la commande
`chmod +x identite.sh fils.sh`. Ensuite, vous pouvez exécuter le script `identite.sh` :

```

$ ./identite.sh

```

Le script attendra la fin des trois fils et affichera l’ordre de terminaison. L’ordre peut varier à chaque
exécution en raison des délais aléatoires introduits dans le script `fils.sh`.