Affectation de la valeur d'une expression à une variable

1 Liste des opérateurs

Action Élément du langage
Arithmétique ^, –, *, /, \, Mod, +, =
Assignation =, ^=, *=, /=, \=, +=, -=, &=
Comparaison =, <>, <, >, <=, >=, Like, Is
Concaténation &, +
Opérations logiques/de bits Not, And, Or, Xor, AndAlso, OrElse
Opérations diverses AddressOf, GetType

2. Expression arithmétique

Les opérateurs des expressions arithmétiques sont les suivants :
Arithmétique ^, –, *, /, \, Mod, +, =
+ : addition, - : soustraction, * : multiplication, / : division réelle, \ : quotient de division entière, Mod : reste de la divion entière, ^:
élévation à la puissance. Ainsi le programme suivant :
' opérateurs arithmétiques
Module operateursarithmetiques
Sub Main()
Dim i, j As Integer
i = 4 : j = 3
Console.Out.WriteLine(i & "/" & j & "=" & (i / j))
Console.Out.WriteLine(i & "\" & j & "=" & (i \ j))
Console.Out.WriteLine(i & " mod " & j & "=" & (i Mod j))
Dim r1, r2 As Double
r1 = 4.1 : r2 = 3.6
Console.Out.WriteLine(r1 & "/" & r2 & "=" & (r1 / r2))
Console.Out.WriteLine(r1 & "^2=" & (r1 ^ 2))
Console.Out.WriteLine(Math.Cos(3))
End Sub
Les bases de VB.NET 16
End Module
donne les résultats suivants :
4/3=1,33333333333333
4\3=1
4 mod 3=1
4,1/3,6=1,13888888888889
4,1^2=16,81
-0,989992496600445
Il existe diverses fonctions mathématiques. En voici quelques-unes :
Public Shared Function Sqrt(ByVal d As Double ) As Double racine carrée
Public Shared Function Cos(ByVal d As Double ) As Double Cosinus
Public Shared Function Sin(ByVal a As Double) As Double Sinus
Public Shared Function Tan(ByVal a As Double) As Double Tangente
Public Shared Function Pow(ByVal x As Double,ByVal y As Double) As Double x à la puissance y (x>0)
Public Shared Function Exp(ByVal d As Double) As Double Exponentielle
Overloads Public Shared Function Log( ByVal d As Double ) As Double Logarithme népérien
Overloads Public Shared Function Abs(ByVal value As Double ) As Double valeur absolue
....
Toutes ces fonctions sont définies dans une classe .NET appelée Math. Lorsqu'on les utilise, il faut les préfixer avec le nom de la
classe où elles sont définies. Ainsi on écrira :
Dim r1, r2 As Double
r2 = Math.Sqrt(9)
r1 = Math.Cos(3)
La définition complète de la classe Math est la suivante :
E Représente la base de logarithme naturelle spécifiée par la constante e.
PI Représente le rapport de la circonférence d'un cercle à son diamètre, spécifié par la constante π.
Abs Surchargé. Retourne la valeur absolue d'un nombre spécifié.
Acos Retourne l'angle dont le cosinus est le nombre spécifié.
Asin Retourne l'angle dont le sinus est le nombre spécifié.
Atan Retourne l'angle dont la tangente est le nombre spécifié.
Atan2 Retourne l'angle dont la tangente est le quotient de deux nombres spécifiés.
BigMul Génère le produit intégral de deux nombres 32 bits.
Ceiling Retourne le plus petit nombre entier supérieur ou égal au nombre spécifié.
Cos Retourne le cosinus de l'angle spécifié.
Cosh Retourne le cosinus hyperbolique de l'angle spécifié.
DivRem Surchargé. Retourne le quotient de deux nombres, en passant le reste en tant que paramètre de sortie.
Exp Retourne e élevé à la puissance spécifiée.
Floor Retourne le plus grand nombre entier inférieur ou égal au nombre spécifié.
IEEERemainder Retourne le reste de la division d'un nombre spécifié par un autre.
Log Surchargé. Retourne le logarithme d'un nombre spécifié.
Log10 Retourne le logarithme de base 10 d'un nombre spécifié.
Max Surchargé. Retourne le plus grand de deux nombres spécifiés.
Min Surchargé. Retourne le plus petit de deux nombres.
Les bases de VB.NET 17
Pow Retourne un nombre spécifié élevé à la puissance spécifiée.
Round Surchargé. Retourne le nombre le plus proche de la valeur spécifiée.
Sign Surchargé. Retourne une valeur indiquant le signe d'un nombre.
Sin Retourne le sinus de l'angle spécifié.
Sinh Retourne le sinus hyperbolique de l'angle spécifié.
Sqrt Retourne la racine carrée d'un nombre spécifié.
Tan Retourne la tangente de l'angle spécifié.
Tanh Retourne la tangente hyperbolique de l'angle spécifié.
Lorsqu'une fonction est déclarée "surchargée", c'est qu'elle existe pour divers type de paramètres. Par exemple, la fonction Abs(x)
existe pour x de type Integer, Long, Decimal, Single, Float. Pour chacun de ces types existe une définition séparée de la fonction
Abs. On dit alors qu'elle est surchargée.

3.Priorités dans l'évaluation des expressions arithmétiques

La priorité des opérateurs lors de l'évaluation d'une expression arithmétique est la suivante (du plus prioritaire au moins prioritaire) :
Catégorie Opérateurs
Primaire Toutes les expressions sans opérateur : fonctions, parenthèses
Élévation à la puissance ^
Négation unaire +, -
Multiplication *, /
Division par un entier \
Modulo Mod
Addition +, -

4. Expressions relationnelles

Les opérateurs sont les suivants :
Comparaison =, <>, <, >, <=, >=, Like, Is
= : égal à, <> : différent de, < : plus petit que (strictement), > : plus grand que (strictement), <= : inférieur ou égal, >= : supérieur
ou égal, Like : correspond à un modèle, Is : identité d'objets. Tous ces opérateurs ont la même priorité. Ils sont évalués de la gauche
vers la droite. Le résultat d'une expression relationnelle un booléen.
Comparaison de chaînes de caractères : considérons le programme suivant :
' espaces de noms
Imports System
Module string1
Sub main()
Dim ch1 As Char = "A"c
Dim ch2 As Char = "B"c
Dim ch3 As Char = "a"c
Console.Out.WriteLine("A<B=" & (ch1 < ch2))
Console.Out.WriteLine("A<a=" & (ch1 < ch3))
Dim chat As String = "chat"
Dim chien As String = "chien"
Dim chaton As String = "chaton"
Dim chat2 As String = "CHAT"
Console.Out.WriteLine("chat<chien=" & (chat < chien))
Console.Out.WriteLine("chat<chaton=" & (chat < chaton))
Console.Out.WriteLine("chat<CHAT=" & (chat < chat2))
Console.Out.WriteLine("chaton like chat*=" & ("chaton" Like "chat*"))
End Sub
End Module
et le résultat de son exécution :
A<B=True
Les bases de VB.NET 18
A<a=True
chat<chien=True
chat<chaton=True
chat<CHAT=False
chaton like chat*=True
Soient deux caractères C1 et C2. Il est possible de les comparer avec les opérateurs : <, <=, =, <>, >, >=. Ce sont alors leurs
valeurs Unicode des caractères, qui sont des nombres, qui sont comparées. Selon l'ordre Unicode, on a les relations suivantes :
espace < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. <'z'
Les chaînes de caractères sont comparées caractère par caractère. La première inégalité rencontrée entre deux caractères induit une
inégalité de même sens sur les chaînes. Avec ces explications, le lecteur est invité à étudier les résultats du programme précédent.

5.Expressions booléennes

Les opérateurs sont les suivants :
Opérations logiques/de bits Not, And, Or, Xor, AndAlso, OrElse
Not : et logique, Or : ou logique, Not : négation, Xor : ou exclusif.
op1 AndAlso op2 : si op1 est faux, op2 n'est pas évalué et le résultat est faux.
op1 OrElse op2 : si op1 est vrai, op2 n'est pas évalué et le résultat est vrai.
La priorité de ces opérateurs entre-eux est la suivante :
NOT logique Not
AND logique And, AndAlso
OR logique Or, OrElse
XOR logique Xor
Le résultat d'une expression booléenne est un booléen.

6.Traitement de bits

On retrouve d'une part les mêmes opérateurs que les opérateurs booléens avec la même priorité. On trouve également deux
opérateurs de déplacement : << et >>. Soient i et j deux entiers.
i<<n décale i de n bits sur la gauche. Les bits entrants sont des zéros.
i>>n décale i de n bits sur la droite. Si i est un entier signé (signed char, int, long) le bit de signe est préservé.
i & j fait le ET logique de i et j bit à bit.
i | j fait le OU logique de i et j bit à bit.
~i complémente i à 1
i^j fait le OU EXCLUSIF de i et j
Soit le programme suivant :
Module operationsbit
Sub main()
' manipulation de bits
Dim i As Short = &H123F
Dim k As Short = &H7123
Console.Out.WriteLine("i<<4=" & (i << 4).ToString("X"))
Console.Out.WriteLine("i>>4=" & (i >> 4).ToString("X"))
Console.Out.WriteLine("k>>4=" & (k >> 4).ToString("X"))
Console.Out.WriteLine("i and 4=" & (i And 4).ToString("X"))
Console.Out.WriteLine("i or 4 =" & (i Or 4).ToString("X"))
Console.Out.WriteLine("not i=" & (Not i).ToString("X"))
End Sub
End Module
Son exécution donne les résultats suivants :
i<<4=23F0
i>>4=123
k>>4=712
i and 4=4
Les bases de VB.NET 19
i or k =123F
not i=EDC0

7. Opérateur associé à une affectation

Il est possible d'écrire a+=b qui signifie a=a+b. La liste des opérateurs pouvant se comniner avec l'opération d'affectation est la
suivante :
combinaison d'opérateurs ^=, *=, /=, \=, +=, -=, &=

8.Priorité générale des opérateurs

Catégorie Opérateurs
Primaire Toutes les expressions sans opérateur
Élévation à la puissance ^
Négation unaire +, -
Multiplication *, /
Division par un entier \
Modulo Mod
Addition +, -
Concaténation &
Déplacement <<, >>
Relationnel =, <>, <, >, <=, >=, Like, Is, TypeOf...Is
NOT logique Not
AND logique And, AndAlso
OR logique Or, OrElse
XOR logique Xor
Lorsqu'un opérande est placé entre deux opérateurs de même priorité, l'associativité des opérateurs régit l'ordre dans lequel les
opérations sont effectuées. Tous les opérateurs sont associatifs à gauche, ce qui signifie que les opérations sont exécutées de gauche
à droite. La priorité et l'associativité peuvent être contrôlées à l'aide d'expressions entre parenthèses.

je comprens rien la dans mais je vois que c'est un travail exelent que ta fais bravo ........

merci mon ami