Accès aux données VB.NET
1. Les bases du langage
Nous traitons d'abord comme un langage de programmation classique. Nous aborderons les
objets ultérieurement.
Dans un programme on trouve deux choses
? Des données
? Les instructions qui les manipulent
DONNEES |
INSTRUCTIONS |
On s'efforce généralement de séparer les données des instructions :
1.2 Les données de
utilise les types de données suivants:
1. les nombres entiers, réels et décimaux
2. les caractères et chaînes de caractères
3. les booléens
4. les dates
5. les objets
1.2.1 Les types de données prédéfinis
Type VB Type .NET équivalent Taille Plage de valeurs
Boolean System.Boolean 2 octets True ou False.
Byte 1 octet 0 à 255 (non signés).
Char 2 octets 0 à 65 535 (non signés).
Date System.DateTime 8 octets 0:00:00 le 1er janvier 0001 à 23:59:59 le 31 décembre 9999.
Decimal System.Decimal 16 0 à +/-79 228 162 514 264 337 593 543 950 335 sans
octets décimale ; 0 à +/7,9228162514264337593543950335 avec 28 décimales ; le plus petit nombre
Double System.Double différent de zéro étant +/-0,0000000000000000000000000001
8 octets (+/-1E-28).
Integer System.Int32 -1,79769313486231E+308 à
4 octets -4,94065645841247E-324 pour les valeurs négatives ;
Long System.Int64 4,94065645841247E-324 à
Object System.Object 8 octets 1,79769313486231E+308 pour les valeurs positives. Short System.Int16 4 octets -2 147 483 648 à 2 147 483 647.
2 octets -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807.
Single System.Single
4 octets N'importe quel type peut être stocké dans une variable de type
String System.String Object.
(classe)
Dans le tableau ci-dessus, on découvr-3e2 q 768u'il yà a32d 767.eux types possibles pour un entier sur 32 bits : Integer et System.Int32. Les deux
types sont interchangeables. Il en est de même pour les autres types VB et leurs équivalents dans la plate-forme .NET. Voici un exemple de programme :
Module types
Sub Main()
' nombres entiers
Dim var1 As Integer = 100
Dim var2 As Long = 10000000000L
Dim var3 As Byte = 100
Dim var4 As Short = 4
' nombres réels
Dim var5 As Decimal = 4.56789D
Dim var6 As Double = 3.4
Dim var7 As Single = -0.000103F
' date
Dim var8 As Date = New Date(2003, 1, 1, 12, 8, 4)
' booléen
Dim var9 As Boolean = True
' caractère
Dim var10 As Char = "A"c
' chaîne de caractères
Dim var11 As String = "abcde"
' objet
Dim var12 As Object = New Object
' affichages
.WriteLine("var1=" + var1.ToString)
.WriteLine("var2=" + var2.ToString)
.WriteLine("var3=" + var3.ToString)
.WriteLine("var4=" + var4.ToString)
.WriteLine("var5=" + var5.ToString)
.WriteLine("var6=" + var6.ToString)
.WriteLine("var7=" + var7.ToString)
.WriteLine("var8=" + var8.ToString)
.WriteLine("var9=" + var9.ToString)
.WriteLine("var10=" + var10)
.WriteLine("var11=" + var11)
.WriteLine("var12=" + var12.ToString) End Sub
End Module
L'exécution donne les résultats suivants :
var1=100 var2=10000000000 var3=100 |
var4=4 |
var5=4,56789 |
var6=3,4 var7=-0,000103 var8=01/01/2003 12:08:04 var9=True |
var10=A var11=abcde |
var12=System.Object |
1.2.2 Notation des données littérales
Integer 145, -7, &FF (hexadécimal)
Long 100000L
Double 134.789, -45E-18 (-45 1018) Single 134.789F, -45E-18F (-
45 10-18) Decimal 100000D
Char "A"c
String "aujourd'hui"
Boolean true, false
date New Date(2003, 1, 1) pour le 01/01/2003
On notera les points suivants :
? 100000L, le L pour signifier qu'on considère le nombre comme un entier long
? 134.789F, le F pour signifier qu'on considère le nombre comme un réel simple précision
? 100000D, le D pour signifier qu'on considère le nombre comme un réel décimal
? "A"c, pour transformer la chaîne de caractères "A" en caractère 'A'
? la chaîne de caractères est entouré du caractère ". Si la chaîne doit contenir le caractère ", on double celui-ci comme dans
"abcd""e" pour représenter la chaîne [abcd"e].
1.2.3 Déclaration des données
1.2.3.1 Rôle des déclarations
Un programme manipule des données caractérisées par un nom et un type. Ces données sont stockées en mémoire. Au moment de
la traduction du programme, le compilateur affecte à chaque donnée un emplacement en mémoire caractérisé par une adresse et
une taille. Il le fait en s'aidant des déclarations faites par le programmeur. Par ailleurs celles-ci permettent au compilateur de détecter des erreurs de programmation. Ainsi l'opération x=x*2 sera déclarée erronée si x est une chaîne de caractères par exemple.
1.2.3.2 Déclaration des constantes
La syntaxe de déclaration d'une constante est la suivante :
const identificateur as type=valeur
par exemple [const PI as double=3.141592]. Pourquoi déclarer des constantes ?
1. La lecture du programme sera plus aisée si l'on a donné à la constante un nom significatif : [const taux_tva as single=0.186F]
2. La modification du programme sera plus aisée si la "constante" vient à changer. Ainsi dans le cas précédent, si le taux de tva passe à 33%, la seule modification à faire sera de modifier l'instruction définissant sa valeur : [const taux_tva as single=0.336F]. Si l'on avait utilisé 0.186 explicitement dans le programme, ce serait alors de nombreuses instructions qu'il faudrait modifier.
try appel de la fonction susceptible de générer l'exception |
35 |
1.2.3.3 Déclaration des variables
Une variable est identifiée par un nom et se rapporte à un type de données. ne fait pas la différence entre majuscules et minuscules. Ainsi les variables FIN et fin sont identiques. Les variables peuvent être initialisées lors de leur déclaration. La syntaxe de déclaration d'une ou plusieurs variables est :
dim variable1,variable2, ,variablen as identificateur_de_type
où identificateur_de_type est un type prédéfini ou bien un type défini par le programmeur.
1.2.4 Les conversions entre nombres et chaînes de caractères
nombre -> chaînenombre.ToString ou "" & nombre ou CType(nombre,String) objet -> chaîne objet.ToString chaine -> Integer Integer.Parse(chaine)
ou Int32.Parse chaîne -> Long
Long.Parse(chaine) ou
Int64.Parse chaîne -> Double
Double.Parse(chaîne)
chaîne -> Single Single.Parse(chaîne)
La conversion d'une chaîne vers un nombre peut échouer si la chaîne ne représente pas un nombre valide. Il y a alors génération d'une erreur fatale appelée exception en . Cette erreur peut être gérée par la clause try/catch suivante :
4/
ca tc h e as Ex ce pt io n t r a i t e r
l ' e x c e p t i o n
e
e n d
t r y ins tru cti on sui van te
5/35
Si la fonction ne génère pas d'exception, on passe alors à instruction suivante, sinon on passe dans le corps de la clause catch puis à instruction suivante. Nous reviendrons ultérieurement sur la gestion des exceptions. Voici un programme présentant les principales techniques de conversion entre nombres et chaînes de caractères. Dans cet exemple la fonction affiche écrit à l'écran la valeur de son paramètre. Ainsi affiche(S) écrit la valeur de S à l'écran.
'directives
Option Strict On
' espaces de noms importés Imports System ' le module de test Module Module1
Sub Main()
' procédure principale
' données locales
Dim S As String
Const i As Integer = 10
Const l As Long = 100000
Const f As Single = 45.78F
Dim d As Double = -14.98
' nombre --> chaîne affiche(CType(i, String)) affiche(CType(l, String)) affiche(CType(f, String)) affiche(CType(d, String))
'boolean --> chaîne Const b As Boolean = False affiche(b.ToString)
' chaîne --> int
Dim i1 As Integer = Integer.Parse("10") affiche(i1.ToString)
Try i1 = Integer.Parse("10.67") affiche(i1.ToString)
Catch e As Exception affiche("Erreur [10.67] : " + e.Message)
End Try
' chaîne --> long
Dim l1 As Long = Long.Parse("100") affiche("" + l1.ToString)
Try l1 = Long.Parse("10.675") affiche("" & l1)
Catch e As Exception affiche("Erreur [10.675] : " + e.Message)
End Try
' chaîne --> double
Dim d1 As Double = Double.Parse("100,87") affiche(d1.ToString)
Try d1 = Double.Parse("abcd") affiche("" & d1)
Catch e As Exception affiche("Erreur [abcd] : " + e.Message)
End Try
' chaîne --> single
Dim f1 As Single = Single.Parse("100,87") affiche(f1.ToString)
Try d1 = Single.Parse("abcd") affiche(f1.ToString)
Catch e As Exception affiche("Erreur [abcd] : " + e.Message) End Try
End Sub
' affiche
Public Sub affiche(ByVal S As String) .WriteLine("S=" + S)
End Sub
End Module
Les résultats obtenus sont les suivants :
S=10 |
S=100000 S=45,78 S=-14,98 S=False |
S=10 |
S=Erreur [10.67] : Le format de la chaîne d'entrée est incorrect. S=100 S=Erreur [10.675] : Le format de la chaîne d'entrée est incorrect. |
On remarquera que les nombres réels sous forme de chaîne de caractères doivent utiliser la virgule et
e point | décimal. Ainsi on écrir | a | mais |
non l Dim d As Double = -14.98 Dim d1 As Double =
Double.Parse("100,87")
1.2.5 Les tableaux de données
Un tableau est un objet permettant de rassembler sous un même identificateur des données de même type. Sa déclaration est la suivante :
Dim Tableau(n) as type | ou | Dim Tableau() as type=New type(n) {} |
où n est l'indice du dernier élément de tableau. La syntaxe Tableau(i) désigne la donnée n° i où i appartient à l'intervalle [0,n]. Toute référence à la donnée Tableau(i) où i n'appartient pas à l'intervalle [0,n] provoquera une exception. Un tableau peut être initialisé en même temps que déclaré. Dans ce cas, on n'a pas besoin d'indiquer le n° du dernier élément.
Dim entiers() As Integer = {0, 10, 20, 30}
Les tableaux ont une propriété Length qui est le nombre d'éléments du tableau. Voici un programme exemple :
Module tab0
Sub Main()
' un premier tableau
Dim tab0(5) As Integer
For i As Integer = 0 To UBound(tab0) tab0(i) = i
Next
For i As Integer = 0 To UBound(tab0)
.WriteLine("tab0(" + i.ToString + ")=" + tab0(i).tostring) Next
' un second tableau
Dim tab1() As Integer = New Integer(5) {}
For i As Integer = 0 To tab1.Length - 1 tab1(i) = i * 10
Next
For i As Integer = 0 To tab1.Length - 1
.WriteLine("tab1(" + i.ToString + ")=" + tab1(i).tostring) Next
End Sub
End Module
et son exécution :
tab0(0)=0 |
tab0(1)=1 |
tab0(2)=2 tab0(3)=3 |
tab0(4)=4 |
tab0(5)=5 tab1(0)=0 |
tab1(1)=10 tab1(2)=20 tab1(3)=30 |
tab1(4)=40 tab1(5)=50
Un tableau à deux dimensions pourra être déclaré comme suit :
Dim Tableau(n,m) as Type | ou | Dim Tableau(,) as Type=New Type(n,m) {} |
où n+1 est le nombre de lignes, m+1 le nombre de colonnes. La syntaxe Tableau(i,j) désigne l'élément j de la ligne i de Tableau. Le tableau à deux dimensions peut lui aussi être initialisé en même temps qu'il est déclaré :
Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}
Le nombre d'éléments dans chacune des dimensions peut être obtenue par la méthode GetLenth(i) où i=0 représente la dimension correspondant au 1er indice, i=1 la dimension correspondant au 2ième indice, …Voici un programme d'exemple :
Module Module2
Sub Main()
' un premier tableau
Dim tab0(2, 1) As Integer
For i As Integer = 0 To UBound(tab0)
For j As Integer = 0 To tab0.GetLength(1) - 1 tab0(i, j) = i * 10 + j Next
Next
For i As Integer = 0 To UBound(tab0)
For j As Integer = 0 To tab0.GetLength(1) - 1
.WriteLine("tab0(" + i.ToString + "," + j.ToString + ")=" + tab0(i, j).tostring) Next
Next
' un second tableau
Dim tab1(,) As Integer = New Integer(2, 1) {}
For i As Integer = 0 To tab1.GetLength(0) - 1
For j As Integer = 0 To tab1.GetLength(1) - 1 tab1(i, j) = i * 100 + j
Next
Next
For i As Integer = 0 To tab1.GetLength(0) - 1
For j As Integer = 0 To tab1.GetLength(1) - 1
.WriteLine("tab1(" + i.ToString + "," + j.ToString + ")=" + tab1(i, j).tostring) Next
Next
End Sub
End Module et les résultats de son exécution :
tab0(0)=0 tab0(1)=1 tab0(2)=2 |
tab0(3)=3 |
tab0(4)=4 |
tab0(5)=5 tab1(0)=0 |
tab1(1)=10 tab1(2)=20 |
tab1(3)=30 tab1(4)=40 |
tab1(5)=50 |
Un tableau de tableaux est déclaré comme suit :
Dim Tableau(n)() as Type | ou | Dim Tableau()() as Type=new Type(n)() |
La déclaration ci-dessus crée un tableau de n+1 lignes. Chaque élément Tableau(i) est une référence de tableau à une dimension. Ces tableaux ne sont pas créés lors de la déclaration ci-dessus. L'exemple ci-dessous illustre la création d'un tableau de tableaux :
' un tableau de tableaux
Dim noms()() As String = New String(3)() {}
' initialisation
.WriteLine("réels[" & i & "," & j & "]=" & réels(i,
j)) Next
Next
' un tableau°de tableaux
Dim noms()() As String = New String(3)() {}
' initialisation
For i = 0 To noms.Length°- 1 noms(i) =°New String(i) {}
For j = 0 To noms(i).Length - 1 noms(i)(j) = "nom" & i & j Next Next
' affichage
For i = 0 To noms.Length°- 1
For j = 0 To noms(i).Length - 1
.WriteLine("noms[" & i & "][" & j & "]=" & noms(i)(j)) Next
Next
End Sub
End Module
A l'exécution, nous obtenons les résultats suivants :
1.3 Les instructions élémentaires de
On distingue
1 les instructions élémentaires exécutées par l'ordinateur.
2 les instructions de contrôle du déroulement du programme.
Les instructions élémentaires apparaissent clairement lorsqu'on considère la structure d'un microordinateur et de ses périphériques.
U. C MEMOIRE ECRAN
+-------------------+ +-------+
¦ 2 ¦ 3 ¦ ¦
+-----------+ 1 ¦ ¦ ----+------+-> ¦
¦ CLAVIER +-----------+--------+--> ¦ ¦ ¦
+-----------+ +-------------------+ +-------+
4^
\
\ 5 +-------+
\ ---->¦ ¦
¦ DISQUE¦
+-------+
1. lecture d'informations provenant du clavier
2. traitement d'informations
3. écriture d'informations à l'écran
4. lecture d'informations provenant d'un fichier disque
5. écriture d'informations dans un fichier disque
1.3.1 Ecriture sur écran
Il existe différentes instructions d'écriture à l'écran :
.WriteLine(expression)
Console.WriteLine(expression) Console.Error.WriteLine (expression)
où expression est tout type de donnée qui puisse être converti en chaîne de caractères pour être
affiché à l'écran. Dans les exemples vus jusqu'ici, nous n'avons utilisé que l'instruction .WriteLine(expression).
La classe System.Console donne accès aux opérations d'écriture écran (Write, WriteLine). La classe Console a deux propriétés Out et
Error qui sont des flux d'écriture de type StreamWriter :
• Console.WriteLine() est équivalent à .WriteLine() et écrit sur le flux Out associé habituellement à l'écran.
• Console.Error.WriteLine() écrit sur le flux Error, habituellement associé lui aussi l'écran.
Les flux Out et Error sont associés par défaut l'écran. Mais ils peuvent être redirigés vers des fichiers texte au moment de l'exécution du programme comme nous le verrons prochainement.
1.3.2 Lecture de données tapées au clavier
Le flux de données provenant du clavier est désigné par l'objet de type StreamReader. Ce type d'objets permet de lire une ligne de texte avec la méthode ReadLine :
Dim ligne As String = .ReadLine()
La ligne tapée au clavier est rangée dans la variable ligne et peut ensuite être exploitée par le flux In peut être redirigé vers un fichier comme les flux Out et Error.
1.3.3 Exemple d'entrées-sorties
Voici un court programme d'illustration des opérations d'entrées-sorties clavier/écran :
'options
Option Explicit On Option Strict On
' espaces de noms
Imports System
' module
Module io1
Sub Main()
' écriture sur le flux Out
Dim obj As New Object
.WriteLine(("" & obj.ToString))
' écriture sur le flux Error
Dim i As Integer = 10
Console.Error.WriteLine(("i=" & i))
' lecture d'une ligne saisie au clavier
.Write("Tapez une ligne : ")
Dim ligne As String = .ReadLine()
.WriteLine(("ligne=" + ligne)) End Sub
End Module et les résultats de l'exécution :
System.Object i=10 Tapez une ligne : ceci est un essai ligne=ceci est un essai |
Les instructions
Dim obj As New Object |
.WriteLine(obj.ToString) |
ne sont là que pour montrer que n'importe quel objet peut faire l'objet d'un affichage. Nous ne chercherons pas ici à expliquer la signification de ce qui est affiché.
1.3.4 Redirection des E/S
Il existe sous DOS/Windows trois périphériques standard appelés :
1. périphérique d'entrée standard - désigne par défaut le clavier et porte le n° 0
2. périphérique de sortie standard - désigne par défaut l'écran et porte le n° 1 3. périphérique d'erreur standard - désigne par défaut l'écran et porte le n° 2
suivante :
des fichiers:
le flux d'entrée standard n° 0 est redirigé vers le fichier . Dans le
prendra donc ses données dans le fichier . redirige la sortie n° 1 vers le fichier . Cela entraîne que dans le programme ses données dans le fichier idem, mais les données écrites sont ajoutées au contenu actuel du fichier . 2> redirige la sortie n° 2 vers le fichier . Cela entraîne que dans le programme le flux Console.Error écrira ses données dans le fichier
2>> idem, mais les données écrites sont ajoutées au contenu actuel du fichier . 1> Les périphériques 1 et 2 sont tous les deux redirigés vers des fichiers
2>
On notera que pour rediriger les flux d'E/S du programme pg vers des fichiers, le programme pg n'a pas besoin d'être modifié.
C'est l'OS qui fixe la nature des périphériques 0,1 et 2. Considérons le programme suivant :
'options
Option Explicit On Option Strict On
' espaces de noms Imports System
' redirections
Module console2
Sub Main()
' lecture flux In
Dim data As String = .ReadLine()
' écriture flux Out
.WriteLine(("écriture dans flux Out : " + data))
' écriture flux Error
Console.Error.WriteLine(("écriture dans flux Error : " + data)) End Sub End Module
Compilons ce programme :
dos>vbc |
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4 pour Microsoft (R) .NET Framework version 1.1.4322.573 Copyright (C) Microsoft Corporation 1987-2002. Tous droits réservés. |
dos>dir 24/02/2004 15:39 416 |
11/03/2004 08:20 3 584 |
Faisons une première exécution:
dos> un premier test écriture dans flux Out : un premier test écriture dans flux Error : un premier test |
L'exécution précédente ne redirige aucun des flux d'E/S standard In, Out, Error. Nos allons maintenant rediriger les trois flux. Le flux In sera redirigé vers un fichier , le flux Out vers le fichier , le flux Error vers le fichier . Cette redirection a lieu sur la ligne de commande sous la forme dos> 0 2>
L'exécution donne les résultats suivants :
dos>more |
un second test dos> 0 2> |
dos>more écriture dans flux Out : un second test |
dos>more écriture dans flux Error : un second test |
On voit clairement que les flux Out et Error n'écrivent pas sur les mêmes périphériques.
1.3.5 Affectation de la valeur d'une expression à une variable
variable=expression |
On s'intéresse ici à l'opération . L'expression peut être de type : arithmétique, relationnelle, booléenne, caractères.
1.3.5.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
1.3.5.2 Expression arithmétique
Les opérateurs des expressions arithmétiques sont les suivants :
^, –, *, /, \, 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
.WriteLine(i & "/" & j & "=" & (i / j))
.WriteLine(i & "\" & j & "=" & (i \ j)) .WriteLine(i & " mod " & j & "=" & (i Mod j))
Dim r1, r2 As Double r1 = 4.1 : r2 = 3.6
.WriteLine(r1 & "/" & r2 & "=" & (r1 / r2)) .WriteLine(r1 & "^2=" & (r1 ^ 2)) .WriteLine((3))
End Sub
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 Doublevaleur 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 = (9) r1 = (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. |
Pow Retourne un nombre spécifié élevé à la puissance spécifiée.
Surchargé. Retourne le nombre le plus proche de la valeur spécifiée.
Surchargé. Retourne une valeur indiquant le signe d'un nombre.
Retourne le sinus de l'angle spécifié.
Retourne le sinus hyperbolique de l'angle spécifié.
Retourne la racine carrée d'un nombre spécifié.
Retourne la tangente de l'angle spécifié.
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.
1.3.5.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 ^ +, *, / \ Mod |
Élévation à la puissance | |
Négation unaire | |
- Multiplication | |
Division par un entier | |
Modulo | |
, parenthèses
Addition +, -
1.3.5.4 Expressions relationnelles
Les opérateurs sont les suivants :
=, , , =, Like, Is
= : égal à, : différent de, : 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
.WriteLine("A