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 ?
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 ?
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 ?
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;
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;
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;
Bonjour,
dim etat as boolean
etat = Not etat
Bonjour,
dim etat as boolean
etat = Not etat
Bonjour,
dim etat as boolean
etat = Not etat
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
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
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
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:
#include<stdio.h>
#include<ctype.h>
typedef int Boolean;
#define TRUE (0==0)
#define FALSE (1==0)
Boolean IsAlpha(int c)
{
if(isalpha(c))
return TRUE;
else
return FALSE;
}
int main(void)
{
Boolean b = TRUE;
b = IsAlpha('1');
if(b)
puts("result : True");
else
puts("result : False");
return 0;
}
' -----------------------------------------------
' - 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
' -----------------------------------------------
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:
#include<stdio.h>
#include<ctype.h>
typedef int Boolean;
#define TRUE (0==0)
#define FALSE (1==0)
Boolean IsAlpha(int c)
{
if(isalpha(c))
return TRUE;
else
return FALSE;
}
int main(void)
{
Boolean b = TRUE;
b = IsAlpha('1');
if(b)
puts("result : True");
else
puts("result : False");
return 0;
}
' -----------------------------------------------
' - 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
' -----------------------------------------------
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:
#include<stdio.h>
#include<ctype.h>
typedef int Boolean;
#define TRUE (0==0)
#define FALSE (1==0)
Boolean IsAlpha(int c)
{
if(isalpha(c))
return TRUE;
else
return FALSE;
}
int main(void)
{
Boolean b = TRUE;
b = IsAlpha('1');
if(b)
puts("result : True");
else
puts("result : False");
return 0;
}
' -----------------------------------------------
' - 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
' -----------------------------------------------
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:
#include<stdio.h>
#include<ctype.h>
typedef int Boolean;
#define TRUE (0==0)
#define FALSE (1==0)
Boolean IsAlpha(int c)
{
if(isalpha(c))
return TRUE;
else
return FALSE;
}
int main(void)
{
Boolean b = TRUE;
b = IsAlpha('1');
if(b)
puts("result : True");
else
puts("result : False");
return 0;
}
' -----------------------------------------------
' - 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:
#include<stdio.h>
#include<ctype.h>
typedef int Boolean;
#define TRUE (0==0)
#define FALSE (1==0)
Boolean IsAlpha(int c)
{
if(isalpha(c))
return TRUE;
else
return FALSE;
}
int main(void)
{
Boolean b = TRUE;
b = IsAlpha('1');
if(b)
puts("result : True");
else
puts("result : False");
return 0;
}
' -----------------------------------------------
' - 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:
#include<stdio.h>
#include<ctype.h>
typedef int Boolean;
#define TRUE (0==0)
#define FALSE (1==0)
Boolean IsAlpha(int c)
{
if(isalpha(c))
return TRUE;
else
return FALSE;
}
int main(void)
{
Boolean b = TRUE;
b = IsAlpha('1');
if(b)
puts("result : True");
else
puts("result : False");
return 0;
}
' -----------------------------------------------
' - 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.
Habituellement j'utilise ça
If valeur = 0 Then valeur = 1 Else valeur = 0
pour faire passer successivement un integer de 0 à 1 et à 0 ...
Habituellement j'utilise ça
If valeur = 0 Then valeur = 1 Else valeur = 0
pour faire passer successivement un integer de 0 à 1 et à 0 ...
Habituellement j'utilise ça
If valeur = 0 Then valeur = 1 Else valeur = 0
pour faire passer successivement un integer de 0 à 1 et à 0 ...
>
Whaou, c'est fort. Respect.
>
Whaou, c'est fort. Respect.
>
Whaou, c'est fort. Respect.