Partager via

Opérateur Mod (Visual Basic)

  • Article

Divise deux nombres et retourne uniquement le reste.

Syntaxe

result = number1 Mod number2

Éléments

result
Obligatoire. Toute variable ou propriété numérique.

number1
Obligatoire. Toute expression numérique.

number2
Obligatoire. Toute expression numérique.

Types pris en charge

tous les types numériques Cela inclut les types non signés et à virgule flottante et Decimal.

Résultats

Le résultat est le reste après la division de number1 par number2. Par exemple, l’expression 14 Mod 4 prend la valeur 2.

Notes

Il existe une différence entre le reste et le modulo en mathématiques, avec des résultats différents pour les nombres négatifs. L’opérateur Mod dans Visual Basic, l’opérateur op_Modulus .NET Framework et l’instruction IL rem sous-jacente effectuent toutes une opération de reste.

Le résultat d’une opération Mod conserve le signe du dividende, number1, et peut donc être positif ou négatif. Le résultat est toujours dans la plage (-number2, number2), exclusif. Par exemple :

Public Module Example
   Public Sub Main()
      Console.WriteLine($" 8 Mod  3 = {8 Mod 3}")
      Console.WriteLine($"-8 Mod  3 = {-8 Mod 3}")
      Console.WriteLine($" 8 Mod -3 = {8 Mod -3}")
      Console.WriteLine($"-8 Mod -3 = {-8 Mod -3}")
   End Sub
End Module
' The example displays the following output:
'       8 Mod  3 = 2
'      -8 Mod  3 = -2
'       8 Mod -3 = 2
'      -8 Mod -3 = -2

Notes

Si number1 ou number2 est une valeur à virgule flottante, le reste à virgule flottante de la division est retourné. Le type de données du résultat est le plus petit type de données qui peut contenir toutes les valeurs possibles résultant de la division avec les types de données de number1 et number2.

Si number1 ou number2 prend la valeur Nothing, il est traité comme zéro.

Les opérateurs connexes sont notamment :

  • L’opérateur \ (Visual Basic) retourne le quotient entier d’une division. Par exemple, l’expression 14 \ 4 prend la valeur 3.

  • L’opérateur / (Visual Basic) retourne le quotient complet, y compris le reste, sous la forme d’un nombre à virgule flottante. Par exemple, l’expression 14 / 4 prend la valeur 3,5.

Tentative de division par zéro

Si number2 est égal à zéro, le comportement de l’opérateur Mod dépend du type de données des opérandes :

  • Une division intégrale lève une exception DivideByZeroException si number2 ne peut pas être déterminé au moment de la compilation et génère une erreur BC30542 Division by zero occurred while evaluating this expression au moment de la compilation si number2 est évalué à zéro au moment de la compilation.
  • Une division à virgule flottante retourne Double.NaN.

Formule équivalente

L’expression a Mod b équivaut à l’une des formules suivantes :

a - (b * (a \ b))

a - (b * Fix(a / b))

Imprécision à virgule flottante

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

Surcharge

L’opérateur Mod peut être surchargé, ce qui signifie qu’une classe ou une structure peut redéfinir son comportement. Si votre code applique Mod à une instance d’une classe ou d’une structure qui inclut une telle surcharge, veillez à comprendre son comportement redéfini. Pour plus d'informations, consultez Operator Procedures.

Exemple 1

L’exemple suivant utilise l’opérateur Mod pour diviser deux nombres et retourner uniquement le reste. Si l’un des nombres est un nombre à virgule flottante, le résultat est un nombre à virgule flottante qui représente le reste.

Debug.WriteLine(10 Mod 5)
' Output: 0
Debug.WriteLine(10 Mod 3)
' Output: 1
Debug.WriteLine(-10 Mod 3)
' Output: -1
Debug.WriteLine(12 Mod 4.3)
' Output: 3.4
Debug.WriteLine(12.6 Mod 5)
' Output: 2.6
Debug.WriteLine(47.9 Mod 9.35)
' Output: 1.15

Exemple 2

L’exemple suivant illustre l’imprécision potentielle des opérandes à virgule flottante. Dans la première instruction, les opérandes sont Double, et 0,2 est une fraction binaire répétée infiniment avec une valeur stockée de 0,20000000000000001. Dans la deuxième instruction, le caractère de type littéral D force les deux opérandes à Decimal, et 0,2 a une représentation précise.

firstResult = 2.0 Mod 0.2
' Double operation returns 0.2, not 0.
secondResult = 2D Mod 0.2D
' Decimal operation returns 0.

Voir aussi