Syntaxe :
resultat& = exprA {AND | &&} exprB
Description :
Les expressions exprA et exprB sont interprétées comme des quantités sur des entiers de 32 bits. L’opérateur AND effectue une “comparaison de bits” entre chaque bit de exprA avec le bit correspondant de exprB. Le résultat est une autre valeur sur 32 bits; chaque bit du résultat est déterminé comme suit :
L’opérateur AND peut aussi être utilisé pour joindre des “clauses conditionnelles” pour les commandes telles que IF, WHILE et UNTIL. Par exemple :
| Valeur bit dans exprA |
Valeur bit dans exprB |
Valeur bit dans resultat& |
| 0 | 0 | 0 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
L’opérateur AND peut aussi être utilisé pour joindre des “clauses conditionnelles” pour les commandes telles que IF, WHILE et UNTIL. Par exemple :
IF n > 17 AND monNom$ <> "Dupuis" THEN BEEP
Cette commande produit un bip sonore si et seulement si n > 17 et monNom$ <> "Dupuis" sont tous les deux vrais à la fois.
Même lorsqu’il est utilisé pour joindre des clauses conditionnelles, l’opérateur AND effectue toujours une “comparaison de bits.” En effet, cela se produit parce que FB^3 assigne une valeur numérique à chaque clause conditionnelle, selon que la clause est vraie ou fausse. Par exemple, la clause n > 17 est évaluée à –1 si elle est vraie, ou à 0 si elle est fausse. Réciproquement, une expression numérique est considérée comme “vraie” si elle est différente de zéro, ou bien “fausse” si elle est égale à zéro.
Exemple :
Dans l’exemple suivant, les expressions sont évaluées comme vraies ou fausses avant qu’une décision de branchement ne soit prise. L’expression logique heure > 7 est vraie, et elle est par conséquent évaluée à –1. L’expression heure < 8.5 est fausse, et elle donc évaluée à 0. Ensuite, la comparaison de bits (–1)AND(0) est effectuée, et elle donne comme résultat zéro. Finalement, la commande LONG IF interprète ce résultat de zéro comme signifiant “faux”, et par conséquent la première commande PRINT n’est pas exécutée.
heure = 9.5
LONG IF heure > 7 AND heure < 8.5
PRINT "C’est l’heure du petit-déjeuner !"
XELSE
PRINT "On doit attendre midi pour manger !"
END IF
LONG IF heure > 7 AND heure < 8.5
PRINT "C’est l’heure du petit-déjeuner !"
XELSE
PRINT "On doit attendre midi pour manger !"
END IF
L’exemple ci-dessous montre comment les bits sont manipulés par l’opérateur AND :
DEFSTR LONG
PRINT BIN$(923)
PRINT BIN$(123)
PRINT "--------------------------------"
PRINT BIN$(923 AND 123)
PRINT BIN$(923)
PRINT BIN$(123)
PRINT "--------------------------------"
PRINT BIN$(923 AND 123)
Affichage du programme :
00000000000000000000001110011011
00000000000000000000000001111011
--------------------------------
00000000000000000000000000011011
00000000000000000000000001111011
--------------------------------
00000000000000000000000000011011
Note :
Dans une instruction comme IF expr1 AND expr2 THEN…, il est possible que l’expression “expr1 AND expr2” soit évaluée à “faux”, même si chaque expr est évaluée individuellement à “vrai”. Examinez cet exemple :
JoeEstIci = 16
FredEstIci = 2
IF JoeEstIci THEN PRINT "Joe est ici" ELSE PRINT "Joe est parti"
IF FredEstIci THEN PRINT "Fred est ici" ELSE PRINT "Fred est parti"
LONG IF JoeEstIci AND FredEstIci
PRINT "Ils sont tous les deux ici !"
XELSE
PRINT "Aucun des deux n’est ici !"
END IF
Affichage du programme :
Joe est ici
Fred est ici
Aucun des deux n’est ici !
Ce résultat étrange survient parce que l’expression “16 AND 2” est évaluée à 0, ce qui est interprété ensuite comme “faux” par la commande LONG IF. Cela ne serait pas arrivé si nous avions attribué la valeur -1 à JoeEstIci et la valeur -1 à FredEstIci, parce que l’expression “–1 AND –1” aurait été évaluée à –1.