Menu paramétrable suivant les étapes réalisées

Version imprimable

Bonjour,

Je cherche à faire un menu paramétrable pour que celui-ci n'affiche plus les étapes/questions déjà réalisées.
Voici ce que je fais :
- le script va chercher la valeur de variables E1, E2, E3.... correspondant à une action réalisée dans un fichier de configuration action_realisees.txt

Cela fonctionne mais je me demande s'il y a moyen de faire plus simple.

Fred M

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
#!/bin/bash
 
#Fichier de configuration qui stocke les actions réalisées. Exemple :  E1="Oui" alors l'Etape 1 n'est plus proposée.
source action_realisees.txt
 
#Etape 1
Etape1()
{
echo "Etape 1 réalisée"
}
 
#Etape 2
Etape2()
{
echo "Etape 2 réalisée"
}
 
#Etape 3
Etape3()
{
echo "Etape 3 réalisée"
}
 
echo "========================================================================================================"
echo "Voulez-vous réinitialiser le menu ? (o/N)"
echo "========================================================================================================"
read -r ETP0
: "${ETP0:="N"}"
if [[ ${ETP0} == [YyOo] ]]; then
        echo "Menu réinitialisé"
        echo>action_realisees.txt
        unset E1 E2 E3
fi
 
#Test si Etape réalisée
if [[ ${E1} == "" ]]; then
        echo "========================================================================================================"
        echo "Etape 1 : Voulez-vous faire l'étape 1 ? (o/N)"
        echo "========================================================================================================"
        read -r ETP1
        : "${ETP1:="N"}"
        if [[ ${ETP1} == [YyOo] ]]; then
                Etape1
                #Etape réalisée
                echo "E1=\"Oui\"">action_realisees.txt
        fi
fi
 
 
#Test si Etape réalisée
if [[ ${E2} == "" ]]; then
        echo "========================================================================================================"
        echo "Etape 2 : Voulez-vous faire l'étape 2 ? (o/N)"
        echo "========================================================================================================"
        read -r ETP2
        : "${ETP2:="N"}"
        if [[ ${ETP2} == [YyOo] ]]; then
                Etape2
                #Etape réalisée
                echo "E2=\"Oui\"">>action_realisees.txt
        fi
fi
 
#Test si Etape réalisée
if [[ ${E3} == "" ]]; then
        echo "========================================================================================================"
        echo "Etape 3 : Voulez-vous faire l'étape 3 ? (o/N)"
        echo "========================================================================================================"
        read -r ETP3
        : "${ETP1:="N"}"
        if [[ ${ETP3} == [YyOo] ]]; then
                Etape3
                #Etape réalisée
                echo "E3=\"Oui\"">>action_realisees.txt
        fi
fi

17/02/2024, 15h44
Sve@r

Bonjour

Citation:

Envoyé par Fred01

Cela fonctionne mais je me demande s'il y a moyen de faire plus simple.

Plus simple je ne sais pas (le shell ce ne sera jamais que du shell quoi). Mais il y a quand-même moyen de faire plus propre que ce fichier se comportant à la fois comme mémoire de ce qui a été fait et à la fois comme code shell obligé alors d'être "sourcé" pour être pris en considération.
Il existe des fichiers spécialement dédiés à garder des infos de configuration. Je pense par exemple aux fichiers ".ini" qui peuvent se diviser en chapitres individuels et dont certains langages, comme Python, possèdent des librairies dédiées à leur manipulation.
17/02/2024, 16h11
N_BaH

pour faire plus propre, tu peux déjà enlever toutes les accolades inutiles. :furax:

je ferais un bête compteur, parce que je n'imagine pas qu'on puisse exécuter l'étape 2 sans avoir préalablement exécuté l'étape 1 ! :mrgreen:
le fichier serais lu au début du script, et on passe directement à l'étape suivante...
17/02/2024, 16h32
Sve@r

Citation:

Envoyé par N_BaH

pour faire plus propre, tu peux déjà enlever toutes les accolades inutiles. :furax:

J'ai pensé au début que tu parlais des accolades des fonctions et là je me disais "mais on ne peut pas les enlever"... :question:
Ensuite j'ai compris que tu parlais des accolades des variables :lol:
Oui souvent le débutant pense que ce sera plus "professionnel" si on les met tout le temps (en tout cas c'est ce que j'ai pensé moi quand je commençais le shell :aie:) mais finalement il se rend compte que c'est juste plus... chiant

Pour les fonctions moi je remplacerais les accolades (puisque tu en as parlé) par des parenthèses. Ca rend la fonction "isolée" du reste du code (pas de conflit/collision entre les variables dans les fonctions et les variables du code).
17/02/2024, 19h04
N_BaH
oui, je parle des variables. :)

on peut aussi restreindre leur portée à la seule fonction en les déclarant avec local.

dans certains cas, les accolades des fonctions sont facultatives :
Code:

1 2 3 4 5 6 7 8 9 10 11 $ maFonc() for i in {1..5}; do echo $i; done $ maFonc 1 2 3 4 5 $ maFonc ((1>2?1:0)) $ maFonc; echo $? 1 $
etc.
puisque la syntaxe d'une fonction est
Code:

1 2 3 fname () commande-composée [redirection] ou function fname [()] commande-composée[redirection]
cf. man bash /commandes composées

Merci de vos retours.
J'ai viré des accolades dans mes variables et mis des parenthèses à mes fonctions !
J'ai aussi tenté de mettre une boucle sachant que les étapes ne se font pas forcément dans l'ordre...
Mon test sur la variable ne fonctionne pas !
Dans un IF, je veux tester la valeur de E1, E2, E3... en utilisant la variable incrémentée $cpt. Il me faut donc ajouter un "E3 mais je n'ai pas la bonne syntaxe à priori :
if [[ ${E($cpt)} == "" ]]; then.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#!/bin/bash
 
#Fichier de configuration qui stocke les actions réalisées. Exemple :  E1="Oui" alors l'Etape 1 n'est plus proposée.
source action_realisees.txt
 
#Etape 1
Etape1()
(
echo "========================================================================================================"
echo "Etape 1 : Voulez-vous faire l'étape 1 ? (o/N)"
echo "========================================================================================================"
read -r ETP1
: "${ETP1:="N"}"
if [[ $ETP1 == [YyOo] ]]; then
 
      echo "Etape 1 réalisée"
 
      #Etape réalisée
      echo "E1=\"Oui\"">>action_realisees.txt
fi
)
 
#Etape 2
Etape2()
(
echo "========================================================================================================"
echo "Etape 2 : Voulez-vous faire l'étape 2 ? (o/N)"
echo "========================================================================================================"
read -r ETP2
: "${ETP2:="N"}"
if [[ $ETP2 == [YyOo] ]]; then
 
      echo "Etape 2 réalisée"
 
      #Etape réalisée
      echo "E2=\"Oui\"">>action_realisees.txt
fi
)
 
#Etape 3
Etape3()
(
echo "========================================================================================================"
echo "Etape 3 : Voulez-vous faire l'étape 3 ? (o/N)"
echo "========================================================================================================"
read -r ETP3
: "${ETP3:="N"}"
if [[ $ETP3 == [YyOo] ]]; then
 
      echo "Etape 3 réalisée"
 
      #Etape réalisée
      echo "E3=\"Oui\"">>action_realisees.txt
fi
)
 
echo "========================================================================================================"
echo "Voulez-vous réinitialiser le menu ? (o/N)"
echo "========================================================================================================"
read -r ETP0
: "${ETP0:="N"}"
if [[ $ETP0 == [YyOo] ]]; then
        echo "Menu réinitialisé"
        echo>action_realisees.txt
        unset E1 E2 E3
fi
 
 
#Boucle d'appel des différentes étapes
cpt=0
while [[ "$cpt" < 3 ]]
   do
     ((cpt=cpt+1))
     #Mon test sur la variable ne fonctionne pas ! Je veux tester sur E1, E2, E3... en utilisant $cpt
     if [[ ${E($cpt)} == "" ]]; then
     Etape$cpt
    fi
    done
   exit 0

17/02/2024, 20h59
Sve@r

Citation:

Envoyé par Fred01

Dans un IF, je veux tester la valeur de E1, E2, E3... en utilisant la variable incrémentée $cpt. Il me faut donc ajouter un "E3 mais je n'ai pas la bonne syntaxe à priori :
if [[ ${E($cpt)} == "" ]]; then.

Déjà tu as l'option "-z" qui permet de vérifier qu'une chaine est/n'est pas vide (et son inverse "-n").
Mais surtout cette façon de faire (qui dans d'autres langages passent par une notion nommée "pointeur") se fait traditionnellement avec des tableaux. On ne peut pas associer un "a" et un "b" pour en faire une variable "ab". Les tableaux sont l'outil justement faits pour aligner des éléments similaires dans une variable générique à laquelle se rajoute une notion de décalage (plus prosaïquement un "indice") qui elle-même peut être récupérée à partir d'une autre variable. Ainsi si "tab" est un tableau de plusieurs éléments, et que "i" vaut 2, alors ${tab[$i]} récupère l'élément d'indice 2. Et là (double effet cool) les accolades sont obligatoires :mouarf:

bonjour

Citation:

Envoyé par Fred01

Dans un IF, je veux tester la valeur de E1, E2, E3... je n'ai pas la bonne syntaxe à priori :
if [[ ${E($cpt)} == "" ]]; then.

Tu as fait des unset, donc il faut juste tester si la variable est déclarée ((variable)).

note: Pourquoi avoir écrit : "${ETP1:="N"}", puisque pas utilisé ?

Ce que tu souhaites faire ? (dans une boucle)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 echo -n "Voulez-vous faire l'étape 1 ? (o/N)" read -r entree if [[ ${entree^^} == [YO] ]]; then source etape1.sh run1 && ETP1=1 fi ... if ((ETP1)); then echo -n "Voulez-vous faire l'étape 2 ? (o/N)" read -r entree if [[ ${entree^^} == [YO] ]]; then source etape2.sh run2 && ETP2=1 fi fii

Je corrige mon code petit à petit avec vos remarques (je débute en shell).
Par contre, je n'arrive toujours pas à voir comment gérer mes variables stockées dans un fichier pour que mon script aille les récupérer.
Chaque fois qu'une étape est réalisée, j'ajoute dans le fichier une variable avec la valeur "Oui"
E1 = "Oui"
E3 = "Oui"
Je lance le script et si la variable n'est pas déclarée, l'étape est proposée. Les étapes ne se font pas forcément dans l'ordre.
Je n'arrive pas à voir comment tester la déclaration ou non de la variable ayant comme nom E$cpt dans boucle while...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#!/bin/bash
 
#Fichier de configuration qui stocke les actions réalisées. Exemple :  E1="Oui" alors l'Etape 1 n'est plus proposée.
source action_realisees.txt
 
#Etape 1
Etape1()
(
echo "========================================================================================================"
echo "Etape 1 : Voulez-vous faire l'étape 1 ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
      echo "Etape 1 réalisée"
      #Etape réalisée
      echo "E1=\"Oui\"">>action_realisees.txt
fi
)
 
#Etape 2
Etape2()
(
echo "========================================================================================================"
echo "Etape 2 : Voulez-vous faire l'étape 2 ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
 
      echo "Etape 2 réalisée"
 
      #Etape réalisée
      echo "E2=\"Oui\"">>action_realisees.txt
fi
)
 
#Etape 3
Etape3()
(
echo "========================================================================================================"
echo "Etape 3 : Voulez-vous faire l'étape 3 ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
 
      echo "Etape 3 réalisée"
 
      #Etape réalisée
      echo "E3=\"Oui\"">>action_realisees.txt
fi
)
 
echo "========================================================================================================"
echo "Voulez-vous réinitialiser le menu ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
        echo "Menu réinitialisé"
        echo>action_realisees.txt
        unset E1 E2 E3
fi
 
 
#Boucle d'appel des différentes étapes
cpt=0
while [[ "$cpt" < 3 ]]
   do
     ((cpt=cpt+1))
     if [[ -z ????????????????????? ]] ; then  #Quel test faire pour tester la déclaration ou non de la variable ayant comme nom E$cpt
     Etape$cpt
 
    fi
    done

18/02/2024, 18h33
Sve@r
Citation:

Envoyé par Fred01

Par contre, je n'arrive toujours pas à voir comment gérer mes variables stockées dans un fichier pour que mon script aille les récupérer.

Parce qu'il ne faut pas voir cela comme des "variables" mais comme des valeurs. Et Linux te donne plein d'outils dédiés à la gestion des fichiers et à la récupération de ses valeurs. Il ne faut pas prendre le shell comme un langage permettant de tout faire, mais comme un langage permettant de tout récupérer depuis l'existant.
Exemple: un fichier "toto" contenant
Code:

1 2 3 etape_1:O etape_2:O etape_3:N
Tape donc ce code...
Code:

1 2 3 4 for i in $(seq 30); do etape="$(grep "^etape_$i:N$" toto)" [ -n "$etape" ] && break done
A la fin de la boucle tu auras la variable "$etape" qui contiendra la première ligne du fichier qui a un "N". Ce n'est pas le shell qui me l'a récupérée cette ligne, mais la commande "grep". Le shell lui il s'est contenté de tester si la ligne était ou n'était pas récupérée.

C'est parfait. Grep était effectivement une solution simple.
Merci, mon script fonctionne !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
#!/bin/bash
 
#Fichier de configuration qui stocke les actions réalisées : action_realisees
 
#Etape 1
Etape1()
(
echo "========================================================================================================"
echo "Etape 1 : Voulez-vous faire l'étape 1 ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
      echo "Etape 1 réalisée"
      #Etape réalisée
      echo "Etape1">>action_realisees
fi
)
 
#Etape 2
Etape2()
(
echo "========================================================================================================"
echo "Etape 2 : Voulez-vous faire l'étape 2 ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
 
      echo "Etape 2 réalisée"
 
      #Etape réalisée
      echo "Etape2">>action_realisees
fi
)
 
#Etape 3
Etape3()
(
echo "========================================================================================================"
echo "Etape 3 : Voulez-vous faire l'étape 3 ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
 
      echo "Etape 3 réalisée"
 
      #Etape réalisée
      echo "Etape3">>action_realisees
fi
)
 
echo "========================================================================================================"
echo "Voulez-vous réinitialiser le menu ? (o/N)"
echo "========================================================================================================"
read -r ENTREE
if [[ ${ENTREE^^} == [YO] ]]; then
        echo "Menu réinitialisé"
        echo>action_realisees
fi
 
 
#Boucle d'appel des différentes étapes
cpt=0
while [[ "$cpt" < 3 ]]
   do
     ((cpt=cpt+1))
     #Recherche dans le fichier action_realisees.txt si la ligne E$cpt existe
     action="$(grep "^Etape$cpt$" action_realisees)"
     #Si la variable $action est vide, on lance la fonction de l'Etape
     if [[ -z "$action" ]] ; then
     Etape$cpt
     fi
   done
   exit 0

Puisque tu t'en sors côté fonction, pourquoi ne pas optimiser un peu plus en factorisant la question...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#!/bin/bash
 
#Fichier de configuration qui stocke les actions réalisées : action_realisees
 
# Question
ouinon() (
	while true; do
		echo "========================================================================================================"
		echo "$1? (o/N)"
		echo "========================================================================================================"
		read -r rep
		case "$rep" in
			[oO]|[oO][uU][iI]) return 0;;
			[nN]|[nN][oO][nN]) return 1;;
			*) echo "Réponse incorrecte - Recommencez"
		esac
	done
)
 
#Etape 1
Etape1() (
	ouinon "Etape 1 : Voulez-vous faire l'étape 1"; ENTREE=$?
	if [ $ENTREE -eq 0 ]; then
		echo "Etape 1 réalisée"
		#Etape réalisée
		echo "Etape1">>action_realisees
	fi
)
 
#Etape 2
Etape2() (
	ouinon "Etape 2 : Voulez-vous faire l'étape 2"; ENTREE=$?
	if [ $ENTREE -eq 0 ]; then
		echo "Etape 2 réalisée"
		#Etape réalisée
		echo "Etape2">>action_realisees
	fi
)
 
#Etape 3
Etape3() (
	ouinon "Etape 3 : Voulez-vous faire l'étape 3"; ENTREE=$?
	if [ $ENTREE -eq 0 ]; then
		echo "Etape 3 réalisée"
		#Etape réalisée
		echo "Etape3">>action_realisees
	fi
)
 
ouinon "Voulez-vous réinitialiser le menu"; ENTREE=$?
if [ $ENTREE -eq 0 ]; then
	echo "Menu réinitialisé"
	echo>action_realisees
fi
 
#Boucle d'appel des différentes étapes
cpt=0
while [[ "$cpt" < 3 ]]; do
	((cpt=cpt+1))
	#Recherche dans le fichier action_realisees.txt si la ligne E$cpt existe
	action="$(grep "^Etape$cpt$" action_realisees)"
	#Si la variable $action est vide, on lance la fonction de l'Etape
	[[ -z "$action" ]] && Etape$cpt
done
exit 0

Je ne l'ai pas fait pour les étapes car je me doute que dans la réalité elles sont réellement toutes très différentes...

PS: j'ai bien aimé Etape$cpt pour appeler une ou l'autre fonction...

01/03/2024, 16h28
jack-ft

Citation:

Envoyé par Sve@r

PS: j'ai bien aimé Etape$cpt pour appeler une ou l'autre fonction...

Humm...

un appel dynamique...

Pas sûr que ShellCheck (ou autre lint) apprécie !
01/03/2024, 17h03
Sve@r

Citation:

Envoyé par jack-ft

un appel dynamique...

Pointeur sur fonction en shell :bravo:
Je me demande si on pourrait le faire évoluer sur un tableau de fonctions qui seraient ainsi appelées séquentiellement via une boucle :idea:

Citation:

Envoyé par jack-ft

Pas sûr que ShellCheck (ou autre lint) apprécie !

Moi l'avis de ces grands prêtres de l'inquisition shellique je m'en... :oops:
03/03/2024, 19h47
jack-ft

[CHIPOTAGE]

Citation:

Envoyé par Fred01

Code:

#Fichier de configuration qui stocke les actions réalisées : action_realisees

Trouvez l'erreur !

Indice: il s'agit d'une erreur orthographique...

[/CHIPOTAGE]