Opérateurs de comparaison (Visual Basic)

Article
06/23/2022
5 minutes de lecture

Voici les opérateurs de comparaison définis dans Visual Basic.

Opérateur <

Opérateur <=

Opérateur >

Opérateur >=

Opérateur =

Opérateur <>

Is, opérateur

IsNot, opérateur

Comme l’opérateur

Ces opérateurs comparent deux expressions pour déterminer si elles sont égales ou non, et si ce n’est pas le cas, comment elles diffèrent. Is, et IsNotLike sont abordés en détail sur les pages d’aide distinctes. Les opérateurs de comparaison relationnelle sont abordés en détail sur cette page.

Syntaxe

result = expression1 comparisonoperator expression2  
result = object1 [Is | IsNot] object2  
result = string Like pattern

Éléments

result
Obligatoire. Valeur Boolean représentant le résultat de la comparaison.

expression1, expression2
Obligatoire. Toute expression.

comparisonoperator
Obligatoire. N’importe quel opérateur de comparaison relationnelle.

object1, object2
Obligatoire. Tous les noms d’objets de référence.

string
Obligatoire. Toute expression String .

pattern
Obligatoire. Toute String expression ou plage de caractères.

Remarques

Le tableau suivant contient une liste des opérateurs de comparaison relationnelle et des conditions qui déterminent s’il result s’agit True ou Falsenon.

Opérateur	`True` si	`False` si
`<` (Inférieur à)	`expression1` < `expression2`	`expression1`>= `expression2`
`<=` (Inférieur ou égal à)	`expression1`<= `expression2`	`expression1` > `expression2`
`>` (Supérieur à)	`expression1` > `expression2`	`expression1`<= `expression2`
`>=` (Supérieur ou égal à)	`expression1`>= `expression2`	`expression1` < `expression2`
`=` (Égal à)	`expression1` = `expression2`	`expression1` <> `expression2`
`<>` (Non égal à)	`expression1` <> `expression2`	`expression1` = `expression2`

Notes

L’opérateur = est également utilisé comme opérateur d’affectation.

L’opérateur Is , l’opérateur IsNot et l’opérateur Like ont des fonctionnalités de comparaison spécifiques qui diffèrent des opérateurs du tableau précédent.

Comparaison des nombres

Lorsque vous comparez une expression de type Single à un de type Double, l’expression Single est convertie en Double. Ce comportement est opposé au comportement trouvé dans Visual Basic 6.

De même, lorsque vous comparez une expression de type Decimal à une expression de type Single ou Double, l’expression Decimal est convertie en Single ou Double. Pour Decimal les expressions, toute valeur fractionnée inférieure à 1E-28 peut être perdue. Une telle perte de valeur fractionnelle peut entraîner une comparaison entre deux valeurs comme égales lorsqu’elles ne le sont pas. Pour cette raison, vous devez prendre soin d’utiliser l’égalité (=) pour comparer deux variables à virgule flottante. Il est plus sûr de vérifier si la valeur absolue de la différence entre les deux nombres est inférieure à une petite tolérance acceptable.

Imprecision à virgule flottante

Lorsque vous travaillez avec des nombres à virgule flottante, gardez à l’esprit qu’ils n’ont pas toujours une représentation précise en mémoire. Cela peut entraîner des résultats inattendus à partir de certaines opérations, telles que la comparaison des valeurs et l’opérateur Mod. Pour plus d’informations, consultez Résolution des problèmes liés aux types de données.

Comparaison de chaînes

Lorsque vous comparez des chaînes, les expressions de chaîne sont évaluées en fonction de leur ordre alphabétique de tri, qui dépend du Option Compare paramètre.

Option Compare Binary base les comparaisons de chaînes sur un ordre de tri dérivé des représentations binaires internes des caractères. L’ordre de tri est déterminé par la page de code. L’exemple suivant montre un ordre de tri binaire classique.

A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø

Option Compare Text base les comparaisons de chaînes sur un ordre de tri textuel respectant la casse déterminé par les paramètres régionaux de votre application. Lorsque vous définissez et triez Option Compare Text les caractères dans l’exemple précédent, l’ordre de tri de texte suivant s’applique :

(A=a) < (À= à) < (B=b) < (E=e) < (Ê= ê) < (Ø = ø) < (Z=z)

Dépendance des paramètres régionaux

Lorsque vous définissez Option Compare Text, le résultat d’une comparaison de chaînes peut dépendre des paramètres régionaux dans lesquels l’application est en cours d’exécution. Deux caractères peuvent être comparés comme égaux dans un paramètre régional, mais pas dans un autre. Si vous utilisez une comparaison de chaînes pour prendre des décisions importantes, telles que s’il faut accepter une tentative de connexion, vous devez être averti de la sensibilité des paramètres régionaux. Envisagez de définir Option Compare Binary ou d’appeler le StrCompparamètre , qui prend en compte les paramètres régionaux.

Programmation sans type avec des opérateurs de comparaison relationnelle

L’utilisation d’opérateurs de comparaison relationnelle avec Object des expressions n’est pas autorisée sous Option Strict On. Quand Option Strict c’est Off, et soit expression1expression2 une Object expression, les types d’exécution déterminent comment ils sont comparés. Le tableau suivant montre comment les expressions sont comparées et le résultat de la comparaison, en fonction du type d’exécution des opérandes.

Si les opérandes sont	La comparaison est
Les deux `String`	Comparaison de tri en fonction des caractéristiques de tri des chaînes.
À la fois numérique	Objets convertis en `Double`comparaison numérique.
Un numérique et un `String`	La `String` conversion en comparaison `Double` numérique est effectuée. Si la `String` valeur ne peut pas être convertie `Double`en , une InvalidCastException levée est levée.
Les deux sont des types de référence autres que ceux-ci `String`	Un objet InvalidCastException est levé.

Les comparaisons numériques sont traitées Nothing comme 0. Les comparaisons de chaînes sont traitées Nothing comme "" (chaîne vide).

Surcharge

Les opérateurs de comparaison relationnelle (<. <=, , >=>=, , <>) peuvent être surchargés, ce qui signifie qu’une classe ou une structure peut redéfinir leur comportement lorsqu’un opérande a le type de cette classe ou structure. Si votre code utilise l’un de ces opérateurs sur une telle classe ou structure, veillez à comprendre le comportement redéfini. Pour plus d'informations, consultez Operator Procedures.

Notez que l’opérateur = peut être surchargé uniquement comme opérateur de comparaison relationnelle, et non comme opérateur d’affectation.

Exemple

L’exemple suivant montre différentes utilisations des opérateurs de comparaison relationnelle, que vous utilisez pour comparer des expressions. Les opérateurs de comparaison relationnelle retournent un Boolean résultat qui indique si l’expression indiquée est évaluée à True. Lorsque vous appliquez les > chaînes et < les opérateurs, la comparaison est effectuée à l’aide de l’ordre alphabétique normal des chaînes. Cette commande peut dépendre de votre paramètre de paramètres régionaux. Si le tri respecte la casse ou non dépend du paramètre Comparaison d’options .

Dim x As testClass
Dim y As New testClass()
x = y
If x Is y Then
    ' Insert code to run if x and y point to the same instance.
End If

Dans l’exemple précédent, la première comparaison retourne False et les comparaisons restantes retournent True.