Habituellement j'utilise ça If valeur = 0 Then valeur = 1 Else valeur = 0 pour faire passer successivement un integer de 0 à 1 et à 0 ... Existe-t-il autre chose ?
Tu peux par exemple utiliser l'opération modulo, comme ceci:
Private Sub Command1_Click() Static n As Integer
n = (n + 1) Mod 2 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Tu peux aussi utiliser XOR, très pratique pour ça:
Private Sub Command3_Click() Static n As Integer
n = n Xor 1 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Si par contre ce que tu veux fonctionnellement, c'est simplement un changement d'état (que les valeurs 0 et 1 en tant que telles ne t'intéressent pas), il est plus judicieux d'utiliser un boolean, comme ça:
Private Sub Command2_Click() Static b As Boolean
b = Not b Debug.Print b End Sub
Ca produit: True, False, True, False, etc.
Il y en a d'autres, mais bon, en VB, ceux ci me semblent les plus classiques.
Habituellement j'utilise ça
If valeur = 0 Then valeur = 1 Else valeur = 0
pour faire passer successivement un integer de 0 à 1 et à 0 ...
Existe-t-il autre chose ?
Tu peux par exemple utiliser l'opération modulo,
comme ceci:
Private Sub Command1_Click()
Static n As Integer
n = (n + 1) Mod 2
Debug.Print n
End Sub
Ca produit : 1,0,1,0,1,0,etc.
Tu peux aussi utiliser XOR, très pratique pour ça:
Private Sub Command3_Click()
Static n As Integer
n = n Xor 1
Debug.Print n
End Sub
Ca produit : 1,0,1,0,1,0,etc.
Si par contre ce que tu veux fonctionnellement, c'est simplement
un changement d'état (que les valeurs 0 et 1 en tant que telles
ne t'intéressent pas), il est plus judicieux d'utiliser un
boolean, comme ça:
Private Sub Command2_Click()
Static b As Boolean
b = Not b
Debug.Print b
End Sub
Ca produit: True, False, True, False, etc.
Il y en a d'autres, mais bon, en VB, ceux ci me semblent
les plus classiques.
Habituellement j'utilise ça If valeur = 0 Then valeur = 1 Else valeur = 0 pour faire passer successivement un integer de 0 à 1 et à 0 ... Existe-t-il autre chose ?
Tu peux par exemple utiliser l'opération modulo, comme ceci:
Private Sub Command1_Click() Static n As Integer
n = (n + 1) Mod 2 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Tu peux aussi utiliser XOR, très pratique pour ça:
Private Sub Command3_Click() Static n As Integer
n = n Xor 1 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Si par contre ce que tu veux fonctionnellement, c'est simplement un changement d'état (que les valeurs 0 et 1 en tant que telles ne t'intéressent pas), il est plus judicieux d'utiliser un boolean, comme ça:
Private Sub Command2_Click() Static b As Boolean
b = Not b Debug.Print b End Sub
Ca produit: True, False, True, False, etc.
Il y en a d'autres, mais bon, en VB, ceux ci me semblent les plus classiques.
-- Romans, logiciels, email, site personnel http://irolog.free.fr/joe.htm ------------------------------------------------------------------------------------ "bahn po" a écrit dans le message de news:
| Hello, | | Habituellement j'utilise ça | | If valeur = 0 Then valeur = 1 Else valeur = 0 | | pour faire passer successivement un integer de 0 à 1 et à 0 ... | | Existe-t-il autre chose ? | | Merci. | |
Bonjour,
dim etat as boolean
etat = Not etat
--
Romans, logiciels, email, site personnel
http://irolog.free.fr/joe.htm
------------------------------------------------------------------------------------
"bahn po" <bahnpo@vrotiska.net> a écrit dans le message de news:
mn.34be7d8aa365aeae.68335@vrotiska.net...
| Hello,
|
| Habituellement j'utilise ça
|
| If valeur = 0 Then valeur = 1 Else valeur = 0
|
| pour faire passer successivement un integer de 0 à 1 et à 0 ...
|
| Existe-t-il autre chose ?
|
| Merci.
|
|
-- Romans, logiciels, email, site personnel http://irolog.free.fr/joe.htm ------------------------------------------------------------------------------------ "bahn po" a écrit dans le message de news:
| Hello, | | Habituellement j'utilise ça | | If valeur = 0 Then valeur = 1 Else valeur = 0 | | pour faire passer successivement un integer de 0 à 1 et à 0 ... | | Existe-t-il autre chose ? | | Merci. | |
bahn po
Jean-marc a pensé très fort :
Tu peux par exemple utiliser l'opération modulo, comme ceci:
Private Sub Command1_Click() Static n As Integer
n = (n + 1) Mod 2 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Tu peux aussi utiliser XOR, très pratique pour ça:
Private Sub Command3_Click() Static n As Integer
n = n Xor 1 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Si par contre ce que tu veux fonctionnellement, c'est simplement un changement d'état (que les valeurs 0 et 1 en tant que telles ne t'intéressent pas), il est plus judicieux d'utiliser un boolean, comme ça:
Private Sub Command2_Click() Static b As Boolean
b = Not b Debug.Print b End Sub
Ca produit: True, False, True, False, etc.
Il y en a d'autres, mais bon, en VB, ceux ci me semblent les plus classiques.
Cordialement;
Merci Jean Marc, Static b correspond exactement :)
Jean-marc a pensé très fort :
Tu peux par exemple utiliser l'opération modulo,
comme ceci:
Private Sub Command1_Click()
Static n As Integer
n = (n + 1) Mod 2
Debug.Print n
End Sub
Ca produit : 1,0,1,0,1,0,etc.
Tu peux aussi utiliser XOR, très pratique pour ça:
Private Sub Command3_Click()
Static n As Integer
n = n Xor 1
Debug.Print n
End Sub
Ca produit : 1,0,1,0,1,0,etc.
Si par contre ce que tu veux fonctionnellement, c'est simplement
un changement d'état (que les valeurs 0 et 1 en tant que telles
ne t'intéressent pas), il est plus judicieux d'utiliser un
boolean, comme ça:
Private Sub Command2_Click()
Static b As Boolean
b = Not b
Debug.Print b
End Sub
Ca produit: True, False, True, False, etc.
Il y en a d'autres, mais bon, en VB, ceux ci me semblent
les plus classiques.
Cordialement;
Merci Jean Marc, Static b correspond exactement :)
Tu peux par exemple utiliser l'opération modulo, comme ceci:
Private Sub Command1_Click() Static n As Integer
n = (n + 1) Mod 2 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Tu peux aussi utiliser XOR, très pratique pour ça:
Private Sub Command3_Click() Static n As Integer
n = n Xor 1 Debug.Print n End Sub
Ca produit : 1,0,1,0,1,0,etc.
Si par contre ce que tu veux fonctionnellement, c'est simplement un changement d'état (que les valeurs 0 et 1 en tant que telles ne t'intéressent pas), il est plus judicieux d'utiliser un boolean, comme ça:
Private Sub Command2_Click() Static b As Boolean
b = Not b Debug.Print b End Sub
Ca produit: True, False, True, False, etc.
Il y en a d'autres, mais bon, en VB, ceux ci me semblent les plus classiques.
Cordialement;
Merci Jean Marc, Static b correspond exactement :)
La valeur boolean, je crois justement que c'est de l'integer, mais avec les processeur actuels en 32 bits, normalement c'est du long qu'on utilise , alors lui filer plus court ne devrait pas le faire aller plus vite, et question RAM, sauf exception, on n'en manque plus.
Alors boolean peut répondre true ou false comme 0 ou 1 "selon" l'interrogatoire, enfin, il me semble grandement...
0 = false, 0 = false et 1 = true, true = 1
Sinon, ben tu fais ce que tu faisais si tu veux, ça ne devrait pas changer grand chose, ni en temps, ni en espace... D'ailleurs je ne vois pas pourquoi tu prends un integer dans ce cas, un byte devrait suffire, et même 1/8eme de byte...
if x = 0 then x = 1 : goto fin if x = 1 then x = 0 fin:
------ Romans, logiciels, email, site personnel http://irolog.free.fr/joe.htm ------------------------------------------------------------------------------------ "bahn po" a écrit dans le message de news:
| LE TROLL a émis l'idée suivante : | > Bonjour, | > | > dim etat as boolean | > | > etat = Not etat | | Remarque que etat = vrai ou faux , si je fais | | if etat = 0 then | | ne marchera pas avec ce boolean | |
Ben si,
dim e as boolean: e = not e
Si tu fais :
If etat = 0 Then MsgBox "est à 0"
Tu auras "est à 0"
La valeur boolean, je crois justement que c'est de l'integer, mais avec les
processeur actuels en 32 bits, normalement c'est du long qu'on utilise ,
alors lui filer plus court ne devrait pas le faire aller plus vite, et
question RAM, sauf exception, on n'en manque plus.
Alors boolean peut répondre true ou false comme 0 ou 1 "selon"
l'interrogatoire, enfin, il me semble grandement...
0 = false, 0 = false et 1 = true, true = 1
Sinon, ben tu fais ce que tu faisais si tu veux, ça ne devrait pas changer
grand chose, ni en temps, ni en espace...
D'ailleurs je ne vois pas pourquoi tu prends un integer dans ce cas, un byte
devrait suffire, et même 1/8eme de byte...
if x = 0 then x = 1 : goto fin
if x = 1 then x = 0
fin:
------
Romans, logiciels, email, site personnel
http://irolog.free.fr/joe.htm
------------------------------------------------------------------------------------
"bahn po" <bahnpo@vrotiska.net> a écrit dans le message de news:
mn.35027d8ac75b3a49.68335@vrotiska.net...
| LE TROLL a émis l'idée suivante :
| > Bonjour,
| >
| > dim etat as boolean
| >
| > etat = Not etat
|
| Remarque que etat = vrai ou faux , si je fais
|
| if etat = 0 then
|
| ne marchera pas avec ce boolean
|
|
La valeur boolean, je crois justement que c'est de l'integer, mais avec les processeur actuels en 32 bits, normalement c'est du long qu'on utilise , alors lui filer plus court ne devrait pas le faire aller plus vite, et question RAM, sauf exception, on n'en manque plus.
Alors boolean peut répondre true ou false comme 0 ou 1 "selon" l'interrogatoire, enfin, il me semble grandement...
0 = false, 0 = false et 1 = true, true = 1
Sinon, ben tu fais ce que tu faisais si tu veux, ça ne devrait pas changer grand chose, ni en temps, ni en espace... D'ailleurs je ne vois pas pourquoi tu prends un integer dans ce cas, un byte devrait suffire, et même 1/8eme de byte...
if x = 0 then x = 1 : goto fin if x = 1 then x = 0 fin:
------ Romans, logiciels, email, site personnel http://irolog.free.fr/joe.htm ------------------------------------------------------------------------------------ "bahn po" a écrit dans le message de news:
| LE TROLL a émis l'idée suivante : | > Bonjour, | > | > dim etat as boolean | > | > etat = Not etat | | Remarque que etat = vrai ou faux , si je fais | | if etat = 0 then | | ne marchera pas avec ce boolean | |
Jean-marc
LE TROLL wrote:
Ben si,
Ben non.
dim e as boolean: e = not e
Si tu fais : If etat = 0 Then MsgBox "est à 0" Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS un numérique. Le fait que VB représente ça dans un int, un short, un long, etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then ' ...
si on veut tester le fait que "b" est VRAI, on écrit If b Then ' ...
Si on veut tester que b est faux, on écrit : If Not b Then ' ...
Toute autre écriture est soit fausse, soit consitutue un pléonasme.
Ainsi, écrire : If b = True Then
serait la même chose que de dire en français : "Si demain il fait beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans ce cas, on le simule (ou l'émule) par un int, en faisant des choses comme ça:
Si tu fais :
If etat = 0 Then MsgBox "est à 0"
Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS
un numérique. Le fait que VB représente ça dans un int, un short, un long,
etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur
logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then
' ...
si on veut tester le fait que "b" est VRAI, on écrit
If b Then
' ...
Si on veut tester que b est faux, on écrit :
If Not b Then
' ...
Toute autre écriture est soit fausse, soit consitutue un
pléonasme.
Ainsi, écrire :
If b = True Then
serait la même chose que de dire en français : "Si demain il fait
beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire
qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc
s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans
ce cas, on le simule (ou l'émule) par un int, en faisant des
choses comme ça:
Si tu fais : If etat = 0 Then MsgBox "est à 0" Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS un numérique. Le fait que VB représente ça dans un int, un short, un long, etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then ' ...
si on veut tester le fait que "b" est VRAI, on écrit If b Then ' ...
Si on veut tester que b est faux, on écrit : If Not b Then ' ...
Toute autre écriture est soit fausse, soit consitutue un pléonasme.
Ainsi, écrire : If b = True Then
serait la même chose que de dire en français : "Si demain il fait beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans ce cas, on le simule (ou l'émule) par un int, en faisant des choses comme ça:
Si tu fais : If etat = 0 Then MsgBox "est à 0" Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS un numérique. Le fait que VB représente ça dans un int, un short, un long, etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then ' ...
si on veut tester le fait que "b" est VRAI, on écrit If b Then ' ...
Si on veut tester que b est faux, on écrit : If Not b Then ' ...
Toute autre écriture est soit fausse, soit consitutue un pléonasme.
Ainsi, écrire : If b = True Then
serait la même chose que de dire en français : "Si demain il fait beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans ce cas, on le simule (ou l'émule) par un int, en faisant des choses comme ça:
' ----------------------------------------------- ' - Programme à exécuter avant d'aller dormir - ' -----------------------------------------------
Dim b As Boolean
While True If b Then Debug.Print "Bonne "; Else Debug.Print "Nuit !" End If b = Not b Wend
' -----------------------------------------------
Whaou, c'est fort. Respect.
Dans son message précédent, Jean-marc a écrit :
LE TROLL wrote:
Ben si,
Ben non.
dim e as boolean: e = not e
Si tu fais :
If etat = 0 Then MsgBox "est à 0"
Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS
un numérique. Le fait que VB représente ça dans un int, un short, un long,
etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur
logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then
' ...
si on veut tester le fait que "b" est VRAI, on écrit
If b Then
' ...
Si on veut tester que b est faux, on écrit :
If Not b Then
' ...
Toute autre écriture est soit fausse, soit consitutue un
pléonasme.
Ainsi, écrire :
If b = True Then
serait la même chose que de dire en français : "Si demain il fait
beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire
qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc
s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans
ce cas, on le simule (ou l'émule) par un int, en faisant des
choses comme ça:
Si tu fais : If etat = 0 Then MsgBox "est à 0" Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS un numérique. Le fait que VB représente ça dans un int, un short, un long, etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then ' ...
si on veut tester le fait que "b" est VRAI, on écrit If b Then ' ...
Si on veut tester que b est faux, on écrit : If Not b Then ' ...
Toute autre écriture est soit fausse, soit consitutue un pléonasme.
Ainsi, écrire : If b = True Then
serait la même chose que de dire en français : "Si demain il fait beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans ce cas, on le simule (ou l'émule) par un int, en faisant des choses comme ça:
' ----------------------------------------------- ' - Programme à exécuter avant d'aller dormir - ' -----------------------------------------------
Dim b As Boolean
While True If b Then Debug.Print "Bonne "; Else Debug.Print "Nuit !" End If b = Not b Wend
' -----------------------------------------------
Whaou, c'est fort. Respect.
Patrice Henrio
bahn po a écrit :
Dans son message précédent, Jean-marc a écrit :
LE TROLL wrote:
Ben si,
Ben non.
dim e as boolean: e = not e
Si tu fais : If etat = 0 Then MsgBox "est à 0" Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS un numérique. Le fait que VB représente ça dans un int, un short, un long, etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then ' ...
si on veut tester le fait que "b" est VRAI, on écrit If b Then ' ...
Si on veut tester que b est faux, on écrit : If Not b Then ' ...
Toute autre écriture est soit fausse, soit consitutue un pléonasme.
Ainsi, écrire : If b = True Then
serait la même chose que de dire en français : "Si demain il fait beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans ce cas, on le simule (ou l'émule) par un int, en faisant des choses comme ça:
' ----------------------------------------------- ' - Programme à exécuter avant d'aller dormir - ' -----------------------------------------------
Dim b As Boolean
While True If b Then Debug.Print "Bonne "; Else Debug.Print "Nuit !" End If b = Not b Wend
' -----------------------------------------------
Whaou, c'est fort. Respect.
On peut même rajouter que
if b=true then
revient à dire : s'il est est vrai que b est vrai alors
ce que l'on peut bien sûr écrire
if (b=true)=true then
ce qui revient à calculer s'il est vrai que "b est vrai" est vrai alors
c'est à dire
if ((b=true)=true)=true then
etc ...
bahn po a écrit :
Dans son message précédent, Jean-marc a écrit :
LE TROLL wrote:
Ben si,
Ben non.
dim e as boolean: e = not e
Si tu fais :
If etat = 0 Then MsgBox "est à 0"
Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS
un numérique. Le fait que VB représente ça dans un int, un short, un
long,
etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur
logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then
' ...
si on veut tester le fait que "b" est VRAI, on écrit
If b Then
' ...
Si on veut tester que b est faux, on écrit :
If Not b Then
' ...
Toute autre écriture est soit fausse, soit consitutue un
pléonasme.
Ainsi, écrire :
If b = True Then
serait la même chose que de dire en français : "Si demain il fait
beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire
qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc
s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans
ce cas, on le simule (ou l'émule) par un int, en faisant des
choses comme ça:
Si tu fais : If etat = 0 Then MsgBox "est à 0" Tu auras "est à 0"
Oui, mais uniquement par hasard.
La valeur boolean, je crois justement que c'est de l'integer, mais
NON.
Une variable Booleéenne, ce n'est pas un type scalaire: ce n'est PAS un numérique. Le fait que VB représente ça dans un int, un short, un long, etc. n'a aucune importance et n'est de toute façon pas intéressant ici.
Un Booléen, c'est un type bien particulier qui représente une valeur logique, représentant "VRAI" ou"FAUX".
Il est *sémantiquement* FAUX et archifaux d'écrire :
Dim b As Boolean
If b = 0 Then ' ...
si on veut tester le fait que "b" est VRAI, on écrit If b Then ' ...
Si on veut tester que b est faux, on écrit : If Not b Then ' ...
Toute autre écriture est soit fausse, soit consitutue un pléonasme.
Ainsi, écrire : If b = True Then
serait la même chose que de dire en français : "Si demain il fait beau est vrai, alors je vais me promener".
Il faut être conscient des types que l'on manipule. Il est faux de croire qu'un booléen est une sorte de petit entier. Ce n'est pas le cas.
C'est une chance que VB implémente un vrai type Booléen, il faut donc s'en servir à bon escient !
Dans d'autres langages, tel que le C, le type Booléen n'existe pas. Dans ce cas, on le simule (ou l'émule) par un int, en faisant des choses comme ça:
