Discussion :

[N_BaH]

ce sujet est une digression de : ce script qui n'en fait qu'à sa tête où la question de l'existence d'une variable a été soulevée.
:

c'est toujours une bonne idée d'initialiser les variables...

la déclaration préalable des variables n'est pas indispensable,[...]

...

[jack-ft]

c'est toujours une bonne idée d'initialiser les variables...

la déclaration préalable des variables n'est pas indispensable,[...]

Généralement pas indispensable, effectivement.

Mais je n'aime pas laisser à l'implémentation (ou aux spécifications) du langage la responsabilité d'initialiser les variables.

Un débutant ne sait pas toujours quelle est la valeur par défaut d'une variable qui n'est pas explicitement initialisée.

Du coup, lorsqu'un débutant lit du code (non pondu par lui) où une variable est explicitement initialisée (même à ce qui serait sa valeur par défaut si elle n'était pas initialisée), je trouve que c'est plus clair pour lui.

Sans compter les prudents (dont j'ai pu faire partie...):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
% cat ./test.sh
#!/bin/bash
if test "$a" = ""; then echo "a vide (ou non initialisée)"; else echo "a pas vide"; fi
set -u
if test "$a" = ""; then echo "a vide (ou non initialisée)"; else echo "a pas vide"; fi
 
% ./test.sh        
a vide (ou non initialisée)
./test.sh: line 4: a: unbound variable

Bien fait ! T'avais qu'à initialiser ta variable !

Attention! Le set -u n'est pas nécessairement du masochisme volontaire !

J'ai eu vu des environnements où les scripts étaient lancés avec des trucs comme bash -u ou où les .profile imposaient le set -u...

[N_BaH]

Bien fait ! T'avais qu'à initialiser ta variable !

ou ne pas utiliser set -u quand tu sais que tes variables ne sont pas toutes initialisées !
bin oui ! on ne laisse pas son doigt entre un clou et un marteau.

[Sve@r]

Un débutant ne sait pas toujours quelle est la valeur par défaut d'une variable qui n'est pas explicitement initialisée.

Déjà en shell la question ne se pose même pas: une variable qui n'est pas initialisée n'existe tout simplement pas (et donc elle n'a même pas de valeur par défaut). C'est d'ailleurs pour ça qu'on écrit toujours des guillemets quand on compare une variable avec une chaine (ex [ "$str" = "toto" ]) => au cas où $str n'existerait pas.
Et pour les langages qui acceptent des variables sans initialisation (ex le C) alors ça n'a pas vraiment d'importance non plus grace au principe de précaution qui est de ne jamais lire une variable qui n'a pas été préalablement remplie. Si on applique ce principe, on n'aura aucun souci quelle que soit la politique d'initialisation par défaut du langage (et on n'a même pas besoin de la connaitre)

où les .profile imposaient le set -u...

Ca rassure en effet de savoir qu'une variable sera toujours créée avant d'être utilisée (en plus ça rejoint le principe de précaution dont j'ai parlé)

[Flodelarab]

Bonjour

Bien fait ! T'avais qu'à initialiser ta variable !

M'sieur ! M'sieur ! pourquoi vous dites "bien fait" ? Regardez mon écran. Tout marche bien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$ a=7 ./test.sh 
a pas vide
a pas vide

une variable qui n'est pas initialisée n'existe tout simplement pas

Je me crispe. Une variable peut être testée sans être initialisée. Donc elle existe.

au cas où $str n'existerait pas.

Pas au cas où elle n'existerait pas, mais au cas où elle serait vide. Elle peut être initialisée et être devenue vide. Cas inverse du précédent.

Ca rassure en effet de savoir qu'une variable sera toujours créée avant d'être utilisée

Mais non ! C'est faux ! J'ai des scripts avec des modes cachés que j'active avec la technique montrée ci-dessus. Et je teste des variables jamais créées par défaut. Et le comportement du script change en fonction de variables inconnues auxquelles je fixe des valeurs connues de moi seul.

[Sve@r]

Je me crispe. Une variable peut être testée sans être initialisée. Donc elle existe.

Non. Tester (de même qu'afficher) une variable qui n'existe pas fonctionne (pour peu que le test soit correctement écrit)... mais ne la fait pas exister pour autant (d'ailleurs si cela la faisait exister je ne vois pas à quoi servirait l'option set -u).

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ maVariable=123
$ set |grep maVariable
maVariable=123				# Là elle existe
$ echo "${maVariable:-toto}"
123
$ unset maVariable
$ set |grep maVariable
$					# Là elle n'existe plus
 
$ echo "${maVariable:-toto}"
toto
$ [ -z "$mavariable" ] && echo "le test se fait bien"
le test se fait bien
$ set |grep maVariable
$					# Elle n'existe toujours pas

D'ailleurs le shell fait bien la différence entre "ne pas exister/exister à vide/exister à non vide" car il y a ${var-texte} (qui renvoie "$var" si celle-ci existe ; et sinon renvoie le texte "texte") et ${var:-texte} (qui renvoie "$var" si celle-ci existe et qu'elle est non vide ; et sinon renvoie le texte "texte")

Pas au cas où elle n'existerait pas, mais au cas où elle serait vide. Elle peut être initialisée et être devenue vide. Cas inverse du précédent.

Non, je dis bien "si la variable n'existe pas". On peut tester une variable inexistante, encore une fois si on veille bien à positionner des éléments permettant de ne pas avoir de test bancal

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ maVariable=toto
$ set |grep maVariable
maVariable=toto
$ test $maVariable = toto && echo "oui toto" || echo "non toto"
oui toto
$ unset maVariable
$ test $maVariable = toto && echo "oui toto" || echo "non toto"
bash: test: = : opérateur unaire attendu
non toto
$ test _$maVariable = _toto && echo "oui toto" || echo "non toto"
non toto
$ test "$maVariable" = "toto" && echo "oui toto" || echo "non toto"
non toto
$ set |grep maVariable
$

Et ces précautions de mettre des éléments en plus de chaque côté de l'égalité (l'underscore, les guillemets) s'appliquent aussi dans le cas que tu cites d'une variable existante mais vide (qui est un cas assez ressemblant au premier pour qu'on s'autorise à ne pas faire de distinction lors des tests)

Mais non ! C'est faux ! J'ai des scripts avec des modes cachés que j'active avec la technique montrée ci-dessus. Et je teste des variables jamais créées par défaut. Et le comportement du script change en fonction de variables inconnues auxquelles je fixe des valeurs connues de moi seul.

Tu n'as pas compris ma phrase. Je disais "ça rassure de mettre set -u car on sait que ainsi, on l'on ne pourra pas utiliser (afficher, tester) des variables inexistantes (c'est une barrière facultative que l'on s'impose volontairement)".
Mais bien évidemment, si tu utilises des variables qui seront remplies (créées) uniquement dans certains cas particuliers (style "si la variable est remplie je fais telle action en plus") tu ne peux plus mettre set -u car au premier test de ta variable, si celle-ci n'existe pas le script plantera. Mais t'es pas obligé de mettre set -u si tu ne le veux pas. Cette phrase était destinée à jack-ft pour expliquer pourquoi certains admins imposent un set -u dans le .profile => pour se protéger contre les erreurs style "j'utilise mavariable alors qu'elle se nomme en réalité maVariable" (mais dans ce cas j'y rajouterais aussi set -e pour planter le script si erreur).

[N_BaH]

je voudrais que nous puissions formaliser(?) tout ça. sereinement;

les états d'une variable

avant son utilisation, il existe plusieurs états possibles pour une variable :

1. "non état" : elle n'existe pas (pas déclarée, ou supprimée unset v)
2. déclarée (declare v)
3. assignée
   1. sans valeur (v='')
   2. avec une valeur (v='V')

plusieurs tests sont possibles :
1.et 2.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

declare -p v &>/dev/null

3a.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test -v v

3b.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test -n "$v"

[jack-ft]

Tout à fait d'accord avec les états d'âme d'une variable...
mais peut-on distinguer les deux premiers cas (unset et déclarée), c'est-à-dire avoir l'information qu'une variable est déclarée ?

Comme je ne connaissais pas test -v, j'avais produit il y a quelque temps le tableau suivant (auquel je me réfère en cas de doute (et de flemme)):

Code x :

Sélectionner tout - Visualiser dans une fenêtre à part

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
+=======================+=========+=========+=========+
| Instruction           | unset V |  V=''   |  V='X'  |
+-----------------------+---------+---------+---------+
| State of V            | unset   |  empty  |  set    |
+=======================+=========+=========+=========+
| "${V-D}"              |   'D'   |    ''   |   'X'   |
+-----------------------+---------+---------+---------+
| "${V:-D}"             |   'D'   |   'D'   |   'X'   |
+-----------------------+---------+---------+---------+
| "${V+D}"              |    ''   |   'D'   |   'D'   |
+-----------------------+---------+---------+---------+
| "${V:+D}"             |    ''   |    ''   |   'D'   |
+=======================+=========+=========+=========+
| test -z "${V+D}"      |   true  |    F    |    F    | unset
+-----------------------+---------+---------+---------+
| test -z "${V-D}"      |    F    |   true  |    F    | empty (set to empty)
+-----------------------+---------+---------+---------+
| test -n "${V:+D}"     |    F    |    F    |   true  | set (but not empty)
+=======================+=========+=========+=========+
| test -n "${V+D}"      |    F    |   true  |   true  | not unset (set or empty)
+-----------------------+---------+---------+---------+
| test -n "${V-D}"      |   true  |    F    |   true  | not empty (unset or set)
+-----------------------+---------+---------+---------+
| test -z "${V:+D}"     |   true  |   true  |    F    | not set (unset or empty)
+=======================+=========+=========+=========+
| "${V-A}${V-B}" = "AB" |   true  |    F    |    F    | unset
+=======================+=========+=========+=========+

Et ça marche même avec le set -u:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
% cat test.sh 
#!/bin/bash
 
if test "$a" = ""; then echo "a vide (ou non initialisée)"; else echo "a pas vide"; fi
 
set -u
 
if test -z "${a+D}"; then echo "Attention: 'a' n'est pas initialisée"; fi
 
if test "$a" = ""; then echo "a vide (ou non initialisée)"; else echo "a pas vide"; fi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
% ./test.sh  
a vide (ou non initialisée)
Attention: 'a' n'est pas initialisée
./test.sh: line 9: a: unbound variable

[N_BaH]

peut-on distinguer les deux premiers cas (unset et déclarée), c'est-à-dire avoir l'information qu'une variable est déclarée ?

c'est ce que je montre avec &>/dev/null declare -p, cette commande à qui on fournit une variable déclarée retourne 0 (vrai).

[disedorgue]

1. "non état" : elle n'existe pas (pas déclarée, ou supprimée unset v)
2. déclarée (declare v)
3. assignée
   1. sans valeur (v='')
   2. avec une valeur (v='V')

plusieurs tests sont possibles :

3a.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test -v v

hmmm

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
$ unset foo
$ test -v foo
$ echo $?
1
$ foo=''
$ test -v foo
$ echo $?
0
$ foo='bar'
$ test -v foo
$ echo $?
0

[N_BaH]

et ?
la variable est assignée; avec ou sans valeur : "quoi! quoiquoi", ou null.
si tu veux savoir si une variable a une valeur nonnull, utilise -n

[disedorgue]

donc pas le cas de 3a mais 3 tout court

[N_BaH]

test -v teste si une variable est assignée, pas si cette assignation a une valeur.

c'est ce que j'ai dit : une valeur null ne vaut pas pas une valeur text/int

tout n'est limpide pour moi (je suis un utilisateur) ; pour faire vraiment bien il faudrait savoir entrer dans les entrailles du shell.
il paraît que c'est tout con : ce serait une boucle qui attend des instructions...

[Sve@r]

donc pas le cas de 3a mais 3 tout court

Si, le cas 3 (variable existante) se subdivise en 3a (variable existante vide) et 3b (variable existante non vide) parce que le shell, comme je l'ai dit, fait lui-même cette distinction. Déjà avec test -n/test -z mais aussi avec ${var-toto} qui se contente d'agir selon l'existence de $var ; versus ${var:-toto} qui, lui, checke l'existence $var mais aussi qu'elle soit non vide.

Moi non plus je ne connaissais pas test -v mais en plus j'ai remarqué que ce test doit s'appliquer à la variable elle-même et non pas à son contenu (pas de "$" devant le nom de la variable).
Pour l'instant j'essaye de réfléchir s'il peut me servir (c'est à dire dans quelle configuration il peut remplacer un test -z)...

[N_BaH]

test -v est un "bashisme".

je voudrais aussi qu'on n'extrapole pas sur le développement potentiel de variable : on pourrait aussi lui faire dire leur contraire de ce qu'on veut tester.
une variable
n'existe pas
existe
a une valeur
...

le B-A-BA

[disedorgue]

Je reste sur ma position, une variable vide est un element de comme un autre d'une variable avec une valeur.

Pour moi, ce qui fait loi , c'est la table de vérité et donc le test -v répond vrai pour les 2 cas (qui n'en est qu'un dans la réalité).

Là, j'ai l'impression que l'on mélange des pommes et des bananes

[chrtophe]

Une variable inexistante ou vide ne peut pas retourner de valeur, c'est la même chose contrairement à une variable positionnée. Si on fait une comparaison devant tester si la variable est égale à 1 ou 2 que celle-ci soit existante ou vide la variable ne sera ni égal à 1 ni à 2. Si par contre mon test doit vérifier si ma variable est supérieure ou égale à 1, c’est pas forcément la même chose. Il faut connaitre le comportement du système utilisé, dans notre cas Bash et faire une algorithmie cohérente par rapport à celui-ci.

Ne maitrisant pas forcément Bash, j'opterais pour positionner une variable à 0 (ou à "" pour une chaine), ce qu'un utilisateur avancé pourra trouver inutile.

[Sve@r]

Je reste sur ma position, une variable vide est un element de comme un autre d'une variable avec une valeur.

"vide" (NULL en C, None en Python, null dans les bases de données) peut-il être considé comme une valeur?
Les bases de données, par exemple, disent clairement que non. Une colonne qui possède une contrainte d'unicité (interdit d'avoir plusieurs fois la même valeur dans cette colonne pour l'ensemble des lignes de la table) accepte que cette colonne soit null pour plusieurs lignes. La notion de "null" (en bdd) n'est donc pas une valeur au sens propre du terme. A tel point que dans les requêtes avec jointure, il faut préciser l'action si une ligne de la table A n'a pas de correspondance (pas de valeur) en table B via inner join/outer join
De façon plus philosophique, imaginons une table de personnes avec nom, prénom, ville de naissance (null possible). On veut toutes les personne nées à Lyon. Que faire si l'info "ville" n'a pas de valeur pour telle personne? Doit-elle apparaitre aussi au résultat (peut-être qu'elle est quand-même née à Lyon)? Admettons mais si on cherche les personnes nées à Paris avec la même requête, cette même personne sortira aussi au résultat.
Non, de mon point de vue la notion "pas de valeur" n'a pas la même signification que la notion "telle ou telle valeur".

Pour moi, ce qui fait loi , c'est la table de vérité et donc le test -v répond vrai pour les 2 cas
Là, j'ai l'impression que l'on mélange des pommes et des bananes

C'est le cas justement avec ton test -v qui demande en réalité "est-ce que ceci est une variable" sans se préoccuper de sa valeur. Tu compares pommes et bananes pour dire "oui ce sont des fruits". Peut-on dire pour autant que c'est la même chose?
Tu as pris un exemple particulier de test mais il y a plein de contre-exemples possibles. Que fais-tu de echo ${var-toto} vs echo ${var:-toto} qui ne sortent pas la même chose dans les 2 cas? Que fais-tu de test $var = Luke_je_suis_ton_pere qui réussira dans un cas et plantera lamentablement dans l'autre?? Que fais-tu de set -u qui fera en sorte que le shell te renvoie une erreur à chaque fois que tu feras echo $var jusqu'à ce que tu écrives enfin une instruction var=valeur???

[disedorgue]

Je persiste, faire des sous ensemble 3a et 3b pour un ensemble 3 n'est pas claire et contre intuitif vis à vis de la table de vérité du test -v.
Ce test est une notion meta vis à vis de l'ensemble, il ne teste pas une propriété d'un objet, il teste l'existance de celui-ci.

[N_BaH]

test -v indique si une variable est assignée (3). Ce test ne dit pas si la variable a une valeur.
test -n indique si une variable a une valeur (3b).

je ne sais pas comment le présenter : "a une valeur" est un sous-ensemble "est assignée".
ce ne sont pas des éléments "parallèles" comme le suggère la dichotomie 3a 3b.
serait-ce :

1. "non état" : elle n'existe pas (pas déclarée, ou supprimée (unset v))
2. déclarée (declare v)
3. assignée (v='', ou v='Val')
   1. avec une valeur (v='Val')

et donc :
3.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test -v v

3a.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test -n "$v"