Expressions booléennes (Visual Basic)

  • Article

Une expression booléenne est une expression qui s'évalue à une valeur de type de données booléen : True ou False. expressions Boolean peuvent prendre plusieurs formes. La plus simple est la comparaison directe de la valeur d’une Boolean variable à un Boolean littéral, comme illustré dans l’exemple suivant.

If newCustomer = True Then
    ' Insert code to execute if newCustomer = True.
Else
    ' Insert code to execute if newCustomer = False.
End If

Deux significations de l'opérateur =

Notez que l’instruction newCustomer = True d’affectation ressemble à l’expression de l’exemple précédent, mais qu’elle exécute une fonction différente et est utilisée différemment. Dans l’exemple précédent, l’expression newCustomer = True représente une valeur booléenne et le = signe est interprété comme un opérateur de comparaison. Dans une instruction autonome, le = signe est interprété comme un opérateur d’affectation et affecte la valeur à droite à la variable à gauche. L'exemple suivant illustre ce comportement.

If newCustomer = True Then
    newCustomer = False
End If

Pour plus d’informations, consultez Comparaisons de valeurs et instructions.

Opérateurs de comparaison

Les opérateurs de comparaison tels que =, <, >, <>, <= et >= produisent des expressions booléennes en comparant l'expression du côté gauche de l'opérateur à l'expression du côté droit de l'opérateur et en évaluant le résultat comme True ou False. L'exemple suivant illustre ce comportement.

42 < 81

Étant donné que 42 est inférieur à True81, l’expression booléenne dans l’exemple précédent prend la valeur . Pour plus d’informations sur ce type d’expression, consultez Comparaisons de valeurs.

Opérateurs de comparaison combinés à des opérateurs logiques

Les expressions de comparaison peuvent être combinées à l’aide d’opérateurs logiques pour produire des expressions booléennes plus complexes. L’exemple suivant illustre l’utilisation d’opérateurs de comparaison conjointement avec un opérateur logique.

x > y And x < 1000

Dans l’exemple précédent, la valeur de l’expression globale dépend des valeurs des expressions de chaque côté de l’opérateur And . Si les deux expressions sont True, alors l'expression globale est évaluée à True. Si l'une des expressions est False, alors l'expression entière est évaluée à False.

Opérateur de court-circuit

Les opérateurs logiques AndAlso et OrElse le comportement d’exposition connu sous le nom de court-circuit. Un opérateur de court-circuitage évalue d'abord l'opérande de gauche. Si l’opérande gauche détermine la valeur de l’expression entière, l’exécution du programme se poursuit sans évaluer l’expression droite. L'exemple suivant illustre ce comportement.

If 45 < 12 AndAlso testFunction(3) = 81 Then
    ' Add code to continue execution.
End If

Dans l’exemple précédent, l’opérateur évalue l’expression de gauche, 45 < 12. Étant donné que l’expression de gauche prend Falsela valeur , l’expression logique entière doit prendre la valeur False. L’exécution du programme ignore donc l’exécution du code dans le bloc If sans évaluer l’expression appropriée, testFunction(3). Cet exemple n’appelle pas testFunction(), car l’expression de gauche falsifie l’expression entière.

De même, si l'expression de gauche d'une expression logique utilisant OrElse évalue à True, l'exécution passe à la ligne de code suivante sans évaluer l'expression de droite, car l'expression de gauche a déjà validé l'ensemble de l'expression.

Comparaison avec les opérateurs de non-court-circuit

En revanche, les deux côtés de l’opérateur logique sont évalués lorsque les opérateurs logiques And et Or sont utilisés. L'exemple suivant illustre ce comportement.

If 45 < 12 And testFunction(3) = 81 Then
    ' Add code to continue execution.
End If

L’exemple précédent appelle testFunction() même si l’expression de gauche prend la valeur False.

Expressions entre parenthèses

Vous pouvez utiliser des parenthèses pour contrôler l’ordre d’évaluation des expressions booléennes. Les expressions entourées de parenthèses évaluent d’abord. Pour plusieurs niveaux d’imbrication, la priorité est accordée aux expressions les plus profondément imbriquées. Entre parenthèses, l’évaluation se poursuit selon les règles de précédence de l’opérateur. Pour plus d’informations, consultez Précédence de l’opérateur dans Visual Basic.

Voir aussi