Cours VB.NETDate de mise à jour : 05/12/2010
V-D. Les variables : généralités
V-D-1. Nom des variables
V-D-2. Déclaration, initialisation
V-D-3. En pratique : Exemple
V-D-4. Les différents types de variables
V-D-5. Les Boolean
V-D-6. Variable entière
V-D-7. Variable réelle
V-D-8. String, Char
V-D-9. Place occupée en mémoire
V-D-10. Type primitif, littéral
V-D-11. Nullable
V-D-12. Choix des noms de variables
V-E. Variables 'String' et 'Char'
V-E-1. Variables 'String'
V-E-1-a. La Classe System.String
V-E-1-b. Les instructions 'Visual Basic'
V-E-1-c. Un exemple
V-E-1-d. Comparaison de caractères (Option Compare)
V-E-1-e. Comparaison avec Equals et String.Compare
V-E-1-f. Unicode
V-E-2. Variables 'Char'
V-E-3. Et les Chaînes de longueur fixe
V-E-4. Regex, expressions régulières.
V-E-4-a. Principe du regex
V-E-4-b. Caractères pour modèle regex
V-E-4-c. Exemples
V-E-4-d. Divers utilisations de Regex
V-E-5. StringBuilder
V-F. Variables Numériques.
V-F-1. La Classe Math du Framework
V-F-2. Les instructions du langage VisualBasic
V-F-3. Dépassement de capacité, 'Non Nombre'
V-F-4. Problème de précision
V-F-5. BigInteger
V-F-6. Nombre Complexe
V-G. Conversion, séparateur décimal
V-G-1. Conversion numérique vers String
V-G-2. Conversion String vers numérique
V-G-3. Tous les modes de conversion
V-G-4. Pour résumer et faire très simple, retenir
V-G-5. Conversion Explicite et Implicite
V-G-6. Conversion restrictive, erreur
V-G-7. Erreur de dépassement de capacité dans les calculs
V-G-8. Séparateur décimal : le point, la virgule, Culture
V-G-9. IsNumeric
V-G-10. Lexique anglais=>Français
V-D. Les variables : généralités
C'est le même sens qu'en mathématique.
Une variable sert à stocker un nombre, du texte (chaîne de caractères), une date, un objet..
Une variable a un nom et un type qui indique ce que l'on peut y mettre( Elle a aussi une 'portée': où et quand sera t-elle visible et utilisable?).
Si myString est une variable de type chaîne de caractère (ou String): je peux y mettre une chaîne de caractère (« TOTO » par exemple)
myString="TOTO"
Si age est une autre variable de type numérique, je peux y stocker un nombre (45,2 par exemple).
age=45,2
V-D-1. Nom des variables
On peut utiliser dans les noms de variable des majuscules ou des minuscules mais pour VB il n'y a pas de différence.
Exemple :
On ne peut pas déclarer une variable VB et une variable vb.
Si on déclare une variable nommée 'VB' et si ultérieurement on tape 'vb', le logiciel le transforme automatiquement en 'VB'.
Il est conseillé de donner des noms explicites qui rappellent ce que contient la variable:
nom_Utilisateur est explicite, pas NU.
Parfois on indique en début de nom, par une lettre, le type de variable ou sa portée (la zone de code où la variable existe).
s_Nom 'Le s indique qu'il s'agit d'une variable String (Chaîne de caractères)
iIndex 'Le i indique qu'il s'agit d'une variable Integer (Entier)
gNomUtilisateur 'g indique que la variable est globale
Il est possible de 'forcer' le type de la variable en ajoutant un caractère spécial à la fin du nom de la variable.
Dim c$ = "aa" ' $ force c à être une variable String.
De même % force les Integer, & les long..
Cette notation est moins utilisée et non recommandée.
Voir en annexe, en bas de page des recommandations supplémentaires.
Nommage:
 |
On conseille, quand le nom d'une variable est composé de plusieurs mots, de mettre la première lettre de chaque mot en majuscule, sauf pour le premier mot.
|
Exemple:
nom_Utilisateur
V-D-2. Déclaration, initialisation
Avant d'utiliser une variable, il faut la déclarer, la créer, pour cela on utilise l'instruction Dim:
Avant la ligne, a n'existait pas, après le DIM, a existe et contient 0.
L'instruction Dim crée la variable et lui alloue un espace de stockage.
Il faut aussi parfois l'initialiser, c'est à dire lui donner une valeur de départ : a=3
On peut déclarer et initialiser en même temps:
Rien n'empêche d'utiliser une expression, une fonction pour initialiser.
Dim a As Integer = CalculMaVariable (4,3)
|
Ici pour initialiser la variable, on appelle une fonction CalculMaVariable qui retourne une valeur pour a.
 |
Il est toujours préférable d'initialiser rapidement une variable.
|
On peut déclarer plusieurs variables en même temps; il faut les séparer par des virgules:
Bien sur, on ne peut pas déclarer plusieurs fois un même nom de variable:
Dim a As Integer
Dim a As String
|
On peut affecter à une variable une valeur de même type que le type de la variable:
Dim a As Integer
a= 2
a= " Philippe "
|
V-D-3. En pratique : Exemple
Les variables après avoir été déclarées, vont servir à stocker des données, à effectuer des calculs, on peut afficher ensuite leur valeur.
Exemple simpliste d'utilisation de variables:
Dim varA As Integer
Dim varB As Integer
Dim total As Integer
varA= 3
varB= 2
total= varA + varB
LabelTotal. Text = total. ToString
|
Un label est une zone permettant d'afficher du texte, pour afficher dans un label il faut transformer la variable total qui est un entier en chaîne de caractères (à l'aide de ToString) puis mettre la string dans le texte du label.
Noter bien la différence entre :
total= 123 'Total est une variable numérique (Integer ou Entier) contenant le nombre 123
et
total2= "123" 'Total2 est une variable string contenant la chaîne de caractère "123" c'est à dire les caractères "1" , "2" et "3"
 |
On peut afficher les chaînes de caractères (ou String), pas les variables numériques.
On fait des calculs avec les variables numériques.
|
Il faudra donc parfois convertir le contenu d'une variable d'un type dans un autre type ( convertir une variable numérique en String pour l'afficher par exemple ou convertir une variable String en numérique pour faire un calcul). On apprendra cela plus loin.
L'exemple simpliste juste au-dessus le montre: il faut convertir total qui est un entier en string pour l'afficher.
Concernant les variables numériques:
Les variables numériques peuvent être signées (accepter les valeurs négatives ou positives) ou non signées ( Comme le Type 'Byte' qui ne contient que des valeurs positives).
Les variables numériques peuvent contenir des entiers(comme les Integer) ou des réels (comme les Single). Pour les réels dans le code, le séparateur est le point:
V-D-4. Les différents types de variables
En Visual Basic:
Nom : |
Contient : |
Boolean |
Contient une valeur Booléenne (logique): True ou False.
|
Byte |
Contient les nombres entiers de 0 à 255 (sans signe)
|
Short |
Entier signé sur 16 bits (-32768 à 32768)
|
Integer |
Entier signé sur 32 bits (-2147483648 à 2147483647)
|
Long |
Entier signé sur 64 bits (-9223372036854775808 à 9223372036854775807)
|
BigInteger |
Entier signé très grand (sans limite supérieure ou inférieure) (VB2010)
|
Single |
Nombre réel en virgule flottante (-1,401298 *10^-45 à 1,401298 10^45)
|
Double |
Nombre réel en virgule flottante double précision. (..puissance 324)
|
Decimal |
Nombre réel en virgule fixe grande précision sur 16 octets.
|
Char |
1 caractère alphanumérique
|
String |
Chaîne de caractère de longueur variable (jusqu'a 2 milliards de caractères)
|
DateTime |
Date plus heure
|
Object |
Peut contenir tous les types de variables mais aussi des contrôles, des fenêtres..
|
Structure |
Ensemble de différentes variables définies par l'utilisateur.
|
|
Depuis la version 2005 il y a aussi les Unsigned ( non signé: pas de valeur négative):
|
UInteger |
Entier codé sur 32 bits pouvant prendre les valeurs 0 à 4 294 967 295.
|
ULong |
Entier codé sur 64 bits :0 à 18 446 744 073 709 551 615
|
UShort |
Entier sur 16 bits 0 à 65 535.
|
et |
|
SByte |
Byte mais signé. Codé sur 1 octet, valeur de -128 à 127
|
Complex |
Nombre complexe (en VB2010)
|
V-D-5. Les Boolean
Contient une valeur Booléenne : True ou False (Vrai ou Faux pour les sous doués en anglais!).
Exemple:
Dim myBoolean As Boolean
myBoolean = True
|
Après déclaration un Boolean a la valeur False.
V-D-6. Variable entière
Byte |
Contient les nombres entiers de 0 à 255 (sans signe).
|
Short |
Entier sur 16 bits (-32768 à 32768)
|
Integer |
Entier sur 32 bits (-2147483648 à 2147483647)
|
Long |
Entier sur 64 bits (-9223372036854775808 à 9223372036854775807)
|
BigInteger |
Entier signé très grand (sans limite supérieure ou inférieure) (VB2010)
|
Pour une variable entière il n'y a pas de possibilité de virgule!! attention, une division de 2 entiers donne un entier.
Pour le mathématicien, les Integer correspondent aux nombres entiers naturels: Entiers positif ou négatif et 0 (..-3 -2 -1 0 1 2 3...), mais avec une limite.
 |
Attention, les variables numériques en informatique ne peuvent pas contenir de nombre infiniment grand ( sauf les BigInteger): Il y a une limite maximum : un Integer est par exemple codé sur 32 bits ce qui fait qu'il peut varier de -2147483648 à 2147483647. Si on utilise une valeur trop grande, une erreur se produit. Les entiers peuvent être positifs ou négatifs (Sauf les Bytes et les 'Unsigned': UInteger, ULong, UShort).
|
Plus on augmente le type (Long au lieu de Integer) plus on peut y mettre des grands nombres. Mais cela prend aussi plus de place et le traitement des opérations est plus long.
Les processeurs travaillant sur '32 bits', utilisez plutôt les Integer (qui sont codés sur 32 bits aussi), c'est plus rapide, que les short.
On utilise largement les 'Integer' comme variable de boucle, Flag, là ou il y a besoin d'entier...(Les calculs sur les réels en virgule flottante sont beaucoup plus lent.)
Exemple:
Après déclaration une variable numérique contient 0.
Le type de données Byte est utilisé pour contenir des données binaires (octet codant de 0 à 255) non signé.
V-D-7. Variable réelle
Un réel peut avoir une partie fractionnaire: 1,454 est un réel.
Pour le mathématicien, les Single, Double.. correspondent aux nombres réels ou fractionnaires: mais avec des limites ( sur la précision et le fait qu'ils ne sont pas infinis).
Single, Double, Decimal.
Single Nombre réel en virgule flottante (-1,401298 *10^-45 à 1,401298 10^45)
Double Nombre réel en virgule flottante double précision. (-1,79769313486231570E+308 et -4,94065645841246544E-324 pour les valeurs négatives et entre 4,94065645841246544E-324 et 1,79769313486231570E+308 pour les valeurs positives)
Decimal Nombre réel en virgule fixe grande précision sur 16 octets: Avec une échelle 0 (aucune décimale), la plus grande valeur possible correspond à +/-79 228 162 514 264 337 593 543 950 335. Avec 28 décimales, la plus grande valeur correspond à +/-7,9228162514264337593543950335
Les variables en virgule flottante ou notation scientifique:
(Single, Double)
La variable peut être positive ou négative.
Le 'Double' est, bien sur, plus précis et peut atteindre des nombres plus grand que le 'Single'.
Le 'Single' comporte 7 chiffres significatifs maximum.
Le 'Double' comporte 18 chiffres significatifs maximum.
Le nombre est codé en interne sous forme scientifique, exemple:1,234568E+008.
Mais en pratique, on travaille et on les affiche de manière habituelle, en notation normale avec un point comme séparateur décimal:
Dim poids As Single
poids= 45. 45
|
Format Scientifique, Mantisse et exposant:
Voici 3 nombres:
14500000
0,145
0,0000145
Ils comportent tous les 3, deux informations:
- le nombre entier 145
- la localisation du premier chiffre par rapport à la virgule
8
-1
-5 dans nos exemples.
Donc un réel peut être stocké sous la forme d'un couple:
- Partie entière
- Localisation de la virgule
Il est codé en interne avec une mantisse (la partie entière) et un exposant (position de la virgule), sous la forme mmmEeee, dans laquelle mmm correspond à la mantisse (chiffres significatifs: partie entière) et eee à l'exposant (puissance de 10).
En fait, en notation scientifique (en codage interne) un chiffre précède toujours la virgule: 1,234568E+008.
 |
Attention, les variables numériques réelles ne peuvent pas contenir de nombre infiniment grand: Il y a une limite maximum comme pour les entiers. La valeur positive la plus élevée d'un type de données Single est 3,4028235E+38 et celle d'un type de données Double est 1,79769313486231570E+308. Si on dépasse cette valeur VB le signale en déclenchant une erreur.
|
Quand on travaille avec des nombres ayant beaucoup de chiffres significatifs, il peut y avoir des erreurs d'arrondi. Le type 'Single' comporte par exemple une mantisse de 7 chiffres significatifs seulement. Si on utilise des nombres (même petit: avec un exposant négatif par exemple)avec 8 chiffres significatifs il peut y avoir des erreurs d'arrondi.
Le type en Virgule fixe.
Le type en Virgule fixe (Decimal) prend en charge jusqu'à 29 chiffres significatifs et peut représenter des valeurs jusqu'à 7,9228 x 10^28. Ce type de données est particulièrement adapté aux calculs (par exemple financiers) qui exigent un grand nombre de chiffres, mais qui ne peuvent pas tolérer les erreurs d'arrondi.
Il est codé sur 128 bits sous forme d'un entier et une puissance de 10.
Les Calculs en Decimal sont 10 fois plus lents que les calculs en Single, mais il n'y a pas d'erreur d'arrondi avec les décimals.
 |
Pour les calculs financiers ont utilisera les 'Decimal'.
Pour les petits calculs du genre résultats d'examen biologique ont utilisera les 'Single' ou les 'Double' qui sont les plus rapides.
|
Pour les variables de boucle, les index, on utilise habituellement des Integers.
V-D-8. String, Char
Le type 'String' peut contenir une 'chaîne de caractères' (alphanumérique) comme du texte. La longueur de la chaîne n'est pas fixe et une String peut avoir un nombre de caractère allant de 0 jusqu'à environ 2 milliards de caractères.
Les chaînes de longueur fixe n'existent pas (plus).
Le Type 'Char' contient un seul caractère. On utilise souvent des tableaux de 'Char'.
Pour information Char et String contiennent en interne le code des caractères au format Unicode (dans la variable,chaque caractère est codé sur 2 octets) et pas de l'ASCII ou de l'ANSI..(ancien codage ou chaque caractère était codé sur un octet).
Les premiers caractères ont le même code Unicode et Ascii.
Exemple:
Caractère |
Code
|
"a" |
65 |
"b" |
66 |
" " |
32 |
Il y a aussi des caractères non affichable:
RC |
13 |
retour chariot |
LF |
10 |
Line Feed |
|
9 |
Tabulation |
Pour passer à la ligne, on utilise les codes 13 puis 10. Il y a une constante toute faite pour cela: ControlChars.CrLf.
V-D-9. Place occupée en mémoire
Les types de variable ont un nom en VisualBasic et un nom dans le Framework.
Exemple:
Integer et System.Int32 sont équivalents pour designer le type 'entier', Integer est le type VB, System.Int32 est le type 'NET' correspondant. On peut utiliser l'un ou l'autre.
Exemple de place occupée par une variable (et le nom de sa Classe dans NET).
Type VB |
Place occupée |
Type NET correspondant |
Boolean |
2 octets |
System.Boolean |
Byte |
1 octet |
System.Byte |
Short |
2 octets |
System.Int16 |
Integer |
4 octets |
System.Int32 |
Long |
8 octets |
System.Int64 |
Single |
4 octets |
System.Single |
Double |
8 octets |
System.Double |
Decimal |
16 octets |
System.Decimal |
Date |
8 octets |
System.DateTime |
Char |
2 octets |
System.Char |
Objet |
4 octets |
System.Objet |
String |
dépend de la chaîne |
System.String |
La méthode GetType permet de savoir de quel type, de quelle Classe est une variable.
Dim x As String = " a "
MessageBox. Show (x. GetType . ToString )
|
Prend le type de x, le transforme en String, l'affiche dans une MessageBox (Noter qu'il faut initialiser x avec une valeur avant de faire GetType).
V-D-10. Type primitif, littéral
Mise à part Objet, Structure, Class tous les autres types sont dit 'Primitif'( Byte, Boolean, Short, Integer, Long, Single, Double, Decimal, Date, Char, String).
- Tous les types primitifs permettent la création de valeurs par l'écriture de littéraux. Par exemple, i=123 ou i=123I (le I force 123 a être entier) est un littéral de type Integer.
- Il est possible de déclarer des constantes des types primitifs.
- Lorsque qu'une expression est constituée de constantes de type primitif, le compilateur évalue l'expression au moment de la compilation. C'est plus rapide.
Un littéral: c'est une donnée utilisée directement; une valeur numérique ou en toutes lettres par opposition à une variable.
On voit que le littéral est un Integer en passant la souris dessus.
Dim i As Integer
i= 100000000
Dim j As Long
j= 100000000
|
Attention, si je tape:
1.4 est un Double, il sera converti en Integer pour être affecté à i est on aura dans i la valeur 1.
Le signe entre la partie entière et fractionnaire est le '.' dans un littéral et cela force le littéral à être un Double.
On peut forcer le type d'un littéral en ajoutant une lettre:
i= 42L
i= 42I
i= 42D
i= 42S
C = " A " c
|
V-D-11. Nullable
Type Nullable.
Les types Par Valeur peuvent être étendus afin d'accepter une valeur normale habituelle ou une valeur Null (Nothing en VB).
On peut déclarer un type Nullable de 3 manières:
Dim MyInteger As Nullable (Of Integer)
|
Mais aussi:
Dim MyInteger? As Integer
Dim MyInteger As Integer?
|
C'est le '?' qui force la variable Nullable.
Sur la seconde déclaration, la variable est MyInteger
Autre exemple:
MyBol pourra prendre la valeur True, False et Nothing.
Cela a de l'intérêt quand on travaille avec les bases de données qui ont des champs qui contiennent un Null et avec Linq.
La propriété HasValue permet de voir si la variable a une valeur autre que Nothing (Valeur retrouvée dans Value).
Dim a? As Integer
If a. HasValue = True Then
MsgBox (a. Value . ToString )
End If
|
V-D-12. Choix des noms de variables
- La plupart des noms sont une concaténation de plusieurs mots, utilisez des minuscules et des majuscules pour en faciliter la lecture.
- Pour distinguer les variables et les routines (procédures), utilisez la casse Pascal (CalculTotal) pour les noms de routine (la première lettre de chaque mot est une majuscule).
- Pour les variables,la première lettre des mots est une majuscule, sauf pour le premier mot (documentFormatType).
- Le nom des variables booléennes doit contenir Is qui implique les valeurs Yes/No ou True/False, Exemple fileIsFound.
- Même pour une variable à courte durée de vie qui peut apparaître uniquement dans quelques lignes de code, utilisez un nom significatif. Utilisez des noms courts d'une seule lettre, par exemple i ou j, pour les index de petite boucle uniquement.
- N'utilisez pas des nombres ou des chaînes littérales telles que For i = 1 To 7. Utilisez plutôt des constantes nommées, par exemple For i = 1 To Nombre_jour_dans_semaine, pour simplifier la maintenance et la compréhension.
- Utilisez des paires complémentaires dans les noms de variables telles que min/max, begin/end et open/close ou des expressions min max si nécessaire en fin de nom.
V-E. Variables 'String' et 'Char'
V-E-1. Variables 'String'
Il faut déclarer une variable avant de l'utiliser, pour cela on utilise l'instruction Dim.
Déclare une variable nommée MyString et qui peut contenir une chaîne de caractère.
Cette variable peut être utilisée pour contenir une chaîne de caractère.
'On met la chaîne de caractères "TOTO" dans la variable MyString.
On peut afficher le contenu de la chaîne dans un label (zone présente dans une fenêtre et ou on peut afficher du texte) par exemple :
Cela affiche 'TOTO' dans le label.
Remarquons que pour définir une chaîne de caractères il faut utiliser des " " : Ce qui est entre " et " est la chaîne de caractères. On parle ici de chaîne littérale: une représentation textuelle d'une valeur particulière.
 |
Après avoir été créée, une String contient 'Nothing' c'est à dire rien (même pas une chaîne vide: ""); il faudra l'initialiser pour qu'elle contienne quelque chose.
|
Dim str As String
If IsNothing (str) then Console. Write ( " contient Nothing " )
|
(pas le texte "Nothing"!! mais la valeur Nothing qui signifie qu'elle ne pointe sur rien.
Notez bien l'importance des guillemets:
A est la variable A
"A" est une chaîne de caractères contenant le caractère "A"
Exemple:
Dim A As String = " Visual "
Dim B As String = " Basic "
Label. text = " A+B " affiche bêtement la chaîne « A+ B »
Label. text = A+ B affiche " VisualBasic "
|
Notez enfin que " ", l'espace est un caractère à part entière.
Si je veux inclure un caractère " dans la chaîne il faut le doubler pour qu'il ne soit pas considéré comme caractère de fin de chaîne:
A= " Bonjour " " Monsieur " " "
|
On peut initialiser la variable en même temps qu'on la déclare.
Dim Chaine as string = " Toto "
|
On peut déclarer plusieurs variables d'un même type sur une même ligne.
On utilise GetType pour connaître le type d'une variable.
x. GetType . ToString
y. GetType . ToString
z. GetType . ToString
|
donne
System. String
System. String
System. String
|
Ce qui prouve que les 3 variables sont bien des Strings.
V-E-1-a. La Classe System.String
Le type System.String ou String (Chaîne de caractères) est une Classe du Framework, qui a des méthodes.
 |
Pas besoin de connaître toutes les méthodes, il suffit de déclarer la String par 'Dim réponse As String') de taper réponse puis "." et vous voyez apparaître toutes les propriétés et méthodes :
|
Voyons par exemple la méthode .ToUpper
Elle retourne la chaîne de caractère en majuscules.
Si str contenait "abc" il contiendra "ABC"
.ToLower transforme par contre la chaîne en minuscule.
Quel intérêt ? Exemple:
Je dois comparer 2 String pour savoir si elles sont égales, la première a été saisie par l'utilisateur et je ne sais pas si l'utilisateur a tapé en majuscule ou en minuscules.
Si je compare A = "Vb" et B= "vb" elles sont différentes.
Si je compare A.ToLower et B.ToLower elles sont égales.
.Trim
Permet de supprimer des caractères en début et fin de chaîne.
Dim a As String = " #@Informatique@# "
Dim b As Char () = {" # " , " @ " }
a= a. Trim (b) Donne a= " Informatique "
|
 |
Attention : Bien utiliser Char() qui est un tableau de caractères pour définir les caractères à supprimer.
|
(Dim b As String= "#@" est déconseillé car produisant des résultats curieux.)
Pour enlever les espaces avant et après la chaîne (Cas le plus fréquent) :
s= " Bonjour "
s= s. Trim (" " )
|
Attention avec Option Strict= On, s=s.Trim(" ") n'est pas accepté car le paramètre de Trim doit être une Char; la String " " n'est pas transformée (castée) en char. Il faut écrire s=s.Trim(" "c) ou s=s.Trim(CChar(" ")).
Il existe aussi TrimStart et TrimEnd pour agir seulement sur le début ou la fin de la chaîne.
Length
Length : Taille d'une chaîne en nombre de caractère.
Afficher la taille de la chaîne « VB »
Dim s As String = " VB "
MsgBox (s. Length . ToString )
|
Concat :
Concaténation de plusieurs chaînes : mise bout à bout :
Il est plus rapide de faire : s= a & b
(s= a+b fait la même chose mais est déconseillé, on réserve '+' pour l'addition de numériques).
Concat est très pratique quand on veut mettre bout à bout tous les éléments d'un tableau:
Dim s () As String = {" hello " , " my " , " friend " , " to " }
Dim c As String = String . Concat ( s ())
|
Insert :
Insère une chaîne dans une autre.
Dim s As String = " VisualBasic "
s= s. Insert (6," " )
|
Noter: le premier caractère a la position 0.
Remove :
Enlève des caractères à une certaine position dans une chaîne.
Dim s As String = " VisualBasic "
s = s. Remove (2, 7)
|
Replace :
Remplace dans une chaîne de départ, toutes les occurrences d'une chaîne par une autre.
Resultat=ChaineDépart.Replace(ChaîneARemplacer,ChaîneQuiRemplace)
Dim s As String = " Visual_Basic "
s= s. Replace (" _ " ," " )
|
Autre exemple:
L'utilisateur a tapé une date, mais avec comme séparateur des ".", comme on le verra plus loin, il est nécessaire d'utiliser plutôt les "/", pour cela on utilise Replace
Dim ladate as string = " 12.02.1990 "
ladate= ladate. Replace (" . " ," / " )
|
Split :
Découpe en plusieurs sous chaînes une chaîne de départ, cela par rapport à un séparateur.
Exemple :
Je récupère dans un fichier une chaîne de mots ayant pour séparateur « ; », je veux mettre chaque mot dans un tableau.
Chaîne contenant les mots séparés par « ; »
Dim s As String = " Philippe;Jean ;Toto "
Dim separateur As Char = " ; "
Dim nom () As String
nom= s. Split (separateur)
|
Donne :
nom(0)= "Philippe"
nom(1)= "Jean"
nom(2)= "Toto"
|
 |
Remarque: Quand on déclare le tableau nom(), on ne donne pas le nombre d'élément, c'est Split qui crée autant d'élément qu'il faut.
|
En Framework 2, on peut utiliser plusieurs séparateurs différents:
nom= s. Split ( New Char () {" " c, " , " c, " . " c })
|
le c après chaque séparateur veut dire Char, car les séparateurs sont des caractères.
On peut ajouter 2 paramètres permettant d'indiquer le nombre de ligne maximum et forcer l'élimination des lignes vides.
Dim sep () As Char= {" " c, " , " c, " . " c}
Dim nom () As String = S. Split ( sep, 100, StringSplitOptions. RemoveEmptyEntries )
|
Allons encore plus loin: avant et après le séparateur il peut y avoir des espaces:
Il faut dans ce cas utiliser la méthode Split de la classe Regex:
Imports System. Text . RegularExpressions
Dim S As String = " abc ; def ; ghi "
Dim R As New Regex (" \s*;\s* " )
Dim Nom As String () = R. Split (S)
|
.Join
Concatène tous les éléments d'un tableau et peut ajouter des séparateurs.
Si myLines() est un tableau de String, je veux ajouter ces lignes bout à bout en les séparant d'un retour à la ligne.
Dim myText As String = String . Join ( ControlChars. CrLf , myLines)
|
.IndexOf .LastIndexOf
Indique le numéro du caractère, la position (la première occurrence) ou une chaîne à chercher est trouvée dans une autre. Recherche en commençant par la fin avec LastIndexOf.
Dim a As String = " LDF.EXE "
Dim r As Char ()= {" . " }
a. IndexOf (r) retourne 3
|
 |
Se souvenir : le premier caractère est en position 0 en .Net.
|
.LastIndexOf retourne la dernière occurrence.
.IndexOfAny .LastIndexOfAny (Framework 2)
Indique le numéro du caractère, la position (la première occurrence) ou une chaîne à chercher est trouvée dans une autre avec en plus possibilité d'indiquer la position de départ.
Dim a As String = " LDF.EXE "
Dim r As Char ()= {" . " }
a. IndexOfAny (r) recherche à partir du début de chaîne.
a. IndexOfAny (r,2) recherche à partir du deuxième caractère.
|
Autre exemple: On recherche ici plusieurs caractères (en fait un tableau de Char)
Dim str As String = " gfdjzak;,vdqsygeak "
Dim start As Integer = 2
Dim at As Integer
Dim count As Integer = 5
Dim target As String = " ou "
Dim anyOf As Char () = target. ToCharArray ()
at = str. IndexOfAny (anyOf, start, count)
|
.Compare
Compare 2 chaînes :
Dim rep As Integer
rep= String . Compare (a,b)
|
Retourne un entier.
-1 si a<b
0 si a=b
1 si a>b
|
On peut comparer des sous chaînes et indiquer la sensibilité à la casse (Framework 2):
Dim myStr1 As [String ] = " My Uncle Bill "
Dim myStr2 As [String ] = " My uncle bill "
Dim r As Integer = String . Compare (myStr1, 2, myStr2, 2, 10, StringComparison. CurrentCultureIgnoreCase )
|
Ici on compare 10 caractères en commençant par le deuxième caractère de chaque chaîne en mode insensible à la casse (majuscules=minuscule).
Voir ci-dessous, le chapitre comparaison.
.Equals
Permet de comparer 2 chaînes. Retourne True si elles sont égales.
Dim b As Booleen= String . Equals (" aaa " , " AAA " )
|
On peut ajouter un paramètre pour signifier la culture ou indiquer de ne pas tenir compte de la case comme ici:
Dim b As Booleen= String . Equals (" aaa " , " AAA " , StringComparison. CurrentCultureIgnoreCase )
|
.Contains
Permet de savoir si une chaîne apparaît dans une autre: (Framework 2)
Dim trouve As Boolean
trouve = a. Contains ( " 123 " )
|
Retourne True ou False
.Substring
Extrait une partie d'une chaîne.
Le premier paramètre indique la position de départ; le second, le nombre de caractères à extraire.
Dim a As String = " Informatique "
MessageBox. show (a. Substring (2,3))
|
Le premier paramètre indique la position du caractère où doit commencer la sous-chaîne, en commençant à la position 0. (les caractères sont comptés 0, 1, 2, 3....
Le second paramètre la longueur de la sous-chaîne.
Exercice 1: comment obtenir les 4 caractères de droite:
Dim a As String = " Informatique "
MessageBox. show (a. Substring (A. Length - 4))
|
Ici on omet le second paramètre,la longueur de la sous-chaîne, va jusqu'a la fin de la chaîne.
Exercice 2: comment obtenir les 3 caractères de gauche:
Dim a As String = " Informatique "
MessageBox. show (a. Substring (0, 3))
|
.Chars
Une chaîne peut être perçue comme un tableau de caractères (instances Char) ; vous pouvez extraire un caractère particulier en faisant référence à l'index de ce caractère par l'intermédiaire de la propriété Chars. Par exemple :
Dim maString As String = " ABCDE "
Dim monChar As Char
monChar = maString. Chars (3)
|
On peut créer des chaînes avec la Classe String:
myString = New String (" " , 15)
|
.PadRight
Aligne les caractères de cette chaîne à gauche et remplit à droite en ajoutant un caractère Unicode spécifié pour une longueur totale spécifiée.
Dim str As String
Dim pad As Char
str = " Nom "
pad = Convert. ToChar (" . " )
Console. WriteLine (str. PadRight (15, pad))
|
PadLeft fait l'inverse.
.StartsWith() et EndsWith()
Permettent de tester si une string commence ou se termine par une string, retourne True ou False.
Tester si la String s commence par "abc" et se termine par "xyz":
If s. StartWith (" abc " ) And s. EndWith (" xyz " ) Then
|
En VB 2005, on peut ajouter un argument gérant la culture ou la casse.
Voir aussi String.Format dans le chapitre: Afficher correctement du texte.
.IsNull , IsNullOrEmpty() Framework 2
Il est parfois nécessaire de vérifier si une chaîne est égale à Nothing ou de longueur égale à 0 (vide).
If S Is Nothing AndOr S. length = 0 Then
|
Ou
If String . IsNullOrEmpty ( S) Then
|
A partir de vb 2010 existe aussi String.IsNullOrWhiteSpace qui est égal à True si la chaine est Null Empty ou ne contient que des espaces:
If String . IsNullOrWhiteSpace (value) Then . .
If String . IsNullOrEmpty (value) OrElse value. Trim (). Length = 0 Then . . .
|
V-E-1-b. Les instructions 'Visual Basic'
CONSEIL: Si vous débutez, laissez de coté ces instructions Visual Basic: elles font double emploi avec la classe String, elles ne sont pas toujours cohérentes avec le reste et cela embrouille.
Utilisez donc uniquement la classe String.
Les instructions VB, elles, sont bien connues des 'anciens' et font partie intégrante de VisualBasic; elles sont parfois plus simples. Mais elles ne fonctionnent pas comme des Objets mais comme des instructions.
Elles font partie de l'espace de nom 'Microsoft.VisualBasic', il est 'chargé' par défaut et il n'y a pas lieu de l'importer. Par contre quand certains 'mots' sont communs à plusieurs classes ou instructions, il peut y avoir ambiguïté et il faut utiliser dans ce cas la syntaxe complète (avec l'espace de nom). Cela semble le cas pour left qui est un mot clé Vb mais aussi une propriété des contrôles. Pour lever l'ambiguïté il faut écrire Microsoft.VisualBasic.left(C,i) par exemple.
Ces méthodes font souvent double emploi avec les méthodes de la classe String:
 |
Attention : le premier caractère est en position 1 dans les instructions VB.
|
Mid:
Permet de récupérer une sous-chaîne.
MaString = " Mid Demonstration "
a = Mid (MaString, 1, 3)
|
Retourne 3 caractères à partir du premier
Le premier paramètre indique la position du caractère où doit commencer la sous-chaîne, en commençant à la position 1. (les caractères sont comptés 1, 2, 3...; on rappelle qu'avec SubString la sous-chaîne, commence à la position 0.
Retourne "tion": du 14ème à la fin (pas de 3ème argument)
Mid permet aussi de remplacer une string dans une string
Mid (MaString, 1, 3) = " Fin "
|
=> MaString="Fin Demonstration"
Left, Right (Pas d'équivalent dans le Framework)
Retourne x caractères de gauche ou de droite:
a="on"
a= Microsoft. VisualBasic . Left (MaString,2)
|
a="Mi"
Notez bien que, pour lever toute ambiguïté avec les méthodes 'Left' d'autres classes, il faut indiquer Microsoft.VisualBasic.Left.
Len.
Retourne la longueur de la chaîne:
Retourne 17.
LTrim, RTrim
Enlève les espaces à gauche ou à droite d'une chaîne.
a="RRR"
InStr
Retourne un entier spécifiant la position de début de la première chaîne à l'intérieur d'une autre.
Recherche à partir du premier caractère, à quelle position se trouve 'R' dans la chaîne "aaaaRaa"
Si la chaîne n'est pas trouvée, retourne 0.
InStrRev
Recherche aussi une chaîne mais de droite à gauche. la position de départ est le 3ème argument.
InStrRev (Ch1, Ch2 , PosDépart)
StrComp Compare 2 chaînes.
Space
Retourne une chaîne d'espace: Space(10) retourne " "
StrDup
Retourne une chaîne de caractères par duplication d'un caractère dont on a spécifié le nombre.
maString = StrDup (5, " P " )
|
Asc
Retourne le code de caractère du caractère. Il peut être compris entre 0 et 255 pour les valeurs du jeu de caractères codés sur un octet (SBCS) et entre -32 768 et 32 767 pour les valeurs du jeu de caractères codés sur deux octets (DBCS). La valeur retournée dépend de la page de codes
AscW retourne le code Unicode du caractère entré. Il peut être compris entre 0 et 65 535.
retourne 65
retourne 65 : Seul le premier caractère est pris en compte.
Chr et ChrW
Retourne le caractère associé au code de caractère.
retourne "A" 'cela dépend de la page de code.
On peut donner le numéro du caractère en hexadécimal, dans ce cas on le fait précéder de &H
est équivalent de Chr(32) et retourne un caractère " ".
ChrW retourne le caractère correspondant à l'Unicode.
GetChar
Retourne le caractère d'une chaîne à une position donnée.
Dim maString As String = " AIDE "
Dim monChar As Char
monChar = GetChar (maString, 3)
|
LCase Ucase
Retourne la chaîne en minuscule ou majuscule:
Lowercase = LCase (UpperCase)
|
Lset Rset
Retourne une chaîne alignée à gauche avec un nombre de caractère.
Dim maString As String = " gauche "
Dim r As String
r = LSet (maString, 2)
Si la chaîne de départ est plus courte que la longueur spécifiée, des espaces sont ajoutés.
r = LSet (maString, 8)
|
StrRevers
Retourne une chaîne ou les caractères ont été inversés:
Dim maString As String = " STRESSED "
Dim revString As String
revString = StrReverse (maString)
|
Marrant l'exemple!!
Filter (VB2005)
Passe les Strings d'un tableau dans un autre tableau, si elles contiennent ou non une chaîne.
TableauResultat= Filter ( TableauChaine, Match, Include, Compare)
|
Match: chaîne à chercher.
Include: Filtre sur la présence ou non de la chaîne à chercher.
Compare en binaire ou en texte (majuscules = minuscules dans ce cas)
Dim TestStrings (2) As String
TestStrings (0) = " Ici "
TestStrings (1) = " Si "
TestStrings (2) = " si "
Dim subStrings () As String
subStrings = Filter (TestStrings, " i " , True , CompareMethod. Text )
subStrings = Filter (TestStrings, " si " , True , CompareMethod. Binary )
subStrings = Filter (TestStrings, " si " , False , CompareMethod. Binary )
|
Like:
Instruction hyper puissante: Like, elle compare une chaîne String avec un modèle (Pattern), elle permet de voir si la chaîne contient ou ne contient pas un ou des caractères, ou une plage de caractères. (c'est l'équivalent des expressions régulières du Framework)
UTILISER PLUTOT le REGEX.
result = String Like Pattern
Si string correspond à pattern, la valeur de result est True ; s'il n'y a aucune correspondance, la valeur de result est False. Si string et pattern sont une chaîne vide, le résultat est True. Sinon, si string ou pattern est une chaîne vide, le résultat est False.
L'intérêt de Like est que l'on peut y mettre des caractères génériques:
? veut dire tout caractère unique.
* veut dire * ou plusieurs caractères.
# veut dire tout chiffre.
[caractères] veut dire tout caractères présent dans la liste.
[!caractères] veut dire tout caractères NON présent dans la liste.
- trait d'union permet de spécifier un début et une fin de plage.
Exemple:
Dim R As Boolean
R = " D " Like " D "
R = " F " Like " f "
R = " F " Like " FFF "
R = " cBBBc " Like " c*c "
R = " J " Like " [A-Z] "
R = " I " Like " [!A-Z] "
R = " a4a " Like " a#a "
R = " bM6f " Like " b[L-P]#[!c-e] "
|
V-E-1-c. Un exemple
Combinaison de chaînes de caractères, de variables.
Souvent, on a besoin d'afficher une combinaison de chaînes littérales, le contenu de variables, des résultats de calcul; c'est possible.
Exemple :
Pour afficher dans un label 'Le carré de X est X2', avec une valeur dans la variable x :
Dim X As Integer = 2
Label1. Text = " Le carré de " & X & " est " & X * X
|
Ce qui est entre guillemets est affiché tel quel. C'est le cas de "Le carré de " et de " est "
Ce qui n'est pas entre guillemets est évalué, le résultat est affiché. C'est le cas de X et X*X
Pour ne faire qu'une chaîne on ajoute les bouts de chaînes avec l'opérateur '&'.
Notez l'usage d'espace en fin de chaîne pour que les mots et les chiffres ne se touchent pas.
Dim X As Integer
X= 2
Label1. Text = " Le carré de " & X & " est " & X * X
|
Affiche dans le label: " Le carré de 2 est 4 "
V-E-1-d. Comparaison de caractères (Option Compare)
On peut comparer 2 String avec:
les instructions '=', '>', '<':
|
Dim s1 As String = " ABCD "
Dim s2 As String = " XYZ "
|
Dans ce cas s1<s2 est vraie.
Car par défaut Option Compare Binary
Les caractères sont classés dans un ordre croissant (l'ordre de leur code unicode).
Voyons l'ordre des certains caractères particuliers:
" " +,-./ 0123456789 :;ABCDEF abcdef èéê
On constate que l'ordre est espace puis quelques caractères spéciaux, les chiffres, les majuscules puis les minuscules, les accentués.(voir le tableau d'unicode)
Ainsi B<a
En utilisant Option Compare Binary, la plage [A–E] correspond à A, B, C, D et E.
Avec Option Compare Text
Les caractères sont classées dans un ordre qui reflète plus la réalité d'un texte:
Toutes les types de a: A, a, À, à, puis tous les types de b: B, b...
Avec Option Compare Text, [A–E] correspond à A, a, À, à, B, b, C, c, D, d, E et e. La plage ne correspond pas à Ê ou ê parce que les caractères accentués viennent après les caractères non accentués dans l'ordre de tri.
Ainsi B>a
L'ordre des caractères est donc défini par Option Compare et aussi les paramètres régionaux du système sur lequel s'exécute le code.
On peut modifier Option Compare soit dans les propriétés de l'application (Menu 'Projet' puis 'Propriétés de ' puis onglet 'Compiler') ou dans un module en ajoutant en haut 'option Compare Text'.
Grande règles de comparaison:
La comparaison s'effectue de gauche à droite.
La comparaison s'effectue sur le premier caractère de chaque chaîne.
Si le premier caractère est identique, la comparaison se fait sur le deuxième caractère...
"zz" > "za" est vrai
En cas de chaîne du type "zz" et "zzz" , la seconde est supérieure.
"zz" < "zzz" est vrai.
Il y a quelques pièges:
Si je veux créer des chaînes du genre 'un nombre puis le mot string' et qu'elles soient classées dans un ordre logique pour l'humain.
Je vais taper: "1string", "2string", "10string", "11string", "100string"
Le classement par Vb sera 'surprenant' car les chaînes seront classées dans cet ordre:
"100string", "10string", "11string", "1string","2string"
Pourquoi? c'est l'application stricte des règles de comparaison: regardons le troisième caractère des 2 premières chaînes (les 2 premiers caractères étant égaux), "0" est bien inférieur à "s" donc "100string" < "10string" est vrai!!
Pour résoudre le problème et obtenir un classement correct, il faut écrire des blocs numériques de même longueur et alignés à droite:
Écrire 010string et non 10string.
"001string", "002string", "010string", "011string", "100string" ' ici le trie est dans le bon ordre.
V-E-1-e. Comparaison avec Equals et String.Compare
Equals retourne un Boolean égal à True si les 2 chaines sont égales.
Cette méthode effectue une comparaison ordinale respectant la casse (majuscules et minuscules ne sont pas égales) et non spécifique à la culture.
Dim myStr1 As [String ] = " My Uncle Bill "
Dim myStr2 As [String ] = " My uncle bill "
Dim r A Boolean= myStr1. Equals (MyStr2)
Dim r A Boolean= String . Equals (MyStr1, MyStr2)
Dim r A Boolean= myStr1. Equals (MyStr2, CurrentCultureIgnoreCase)
|
String.Compare compare 2 chaines et retourne un Integer qui prend la valeur:
0 si les 2 chaines sont égales.
inférieur à 0 si string1 est inférieur à string2.
supérieur à 0 si string1 est supérieur à string2.
Dim myStr1 As [String ] = " My Uncle Bill "
Dim myStr2 As [String ] = " My uncle bill "
Dim r As Integer = String . Compare (myStr1, myStr2)
MessageBox. Show (r. ToString )
|
Par défaut la culture en cours est utilisée et la comparaison est comme avec Option Compare=Binary: le code unicode est utilisé.
MessageBox. Show (String . Compare (" A " , " a " ). ToString )
|
On peut ajouter des options de comparaison: IgnoreCase, IgnoreSymbol, IgnoreNonSpace, IgnoreWidth, IgnoreKanaType et StringSort.
Dim myStr1 As [String ] = " My Uncle Bill "
Dim myStr2 As [String ] = " My uncle bill "
Dim r As Integer = String . Compare (myStr1, myStr2, ignoreCase:= True )
MessageBox. Show (r. ToString )
Dim r As Integer = String . Compare (myStr1, myStr2, CompareOptions. IgnoreCase And CompareOptions. IgnoreSymbol )
|
On peut même comparer dans une autre culture:
Dim myComp As CompareInfo = CultureInfo. InvariantCulture . CompareInfo
Dim r As Integer= myComp. Compare (myStr1, myStr2))
|
Ici on compare 10 caractères en commençant par le deuxième caractère de chaque chaîne en mode insensible à la casse (majuscules=minuscule).
Les options font partie de l'énumération StringComparison et pas de CompareOptions comme plus haut.
Dim myStr1 As [String ] = " My Uncle Bill "
Dim myStr2 As [String ] = " My uncle bill "
Dim r As Integer = String . Compare (myStr1, 2, myStr2, 2, 10, StringComparison. CurrentCultureIgnoreCase )
|
V-E-1-f. Unicode
Les variables 'String' sont stockées sous la forme de séquences de 16 bits (2 octets) non signés dont les valeurs sont comprises entre 0 et 65 535. Chaque nombre représente un caractère Unicode. Une chaîne peut contenir jusqu'à 2 milliards de caractères.
L'unicode est donc un codage de caractères sur 16 bits qui contient tous les caractères d'usage courant dans les langues principales du monde.
Les premiers 128 codes (0–127) Unicode correspondent aux lettres et aux symboles du clavier américain standard. Ce sont les mêmes que ceux définis par le jeu de caractères ASCII (ancien codage sur un octet). Les 128 codes suivants (128–255) représentent les caractères spéciaux, tels que les lettres de l'alphabet latin, les accents, les symboles monétaires et les fractions. Les codes restants sont utilisés pour des symboles, y compris les caractères textuels mondiaux, les signes diacritiques, ainsi que les symboles mathématiques et techniques.
Voici les 255 premiers:
Le petit carré indique un caractère non imprimable (non affichable), certains caractères sont des caractères de contrôle comme le numéro 9 qui correspondant à tabulation, le numéro 13 qui correspond au retour à la ligne..
V-E-2. Variables 'Char'
Les variables Char contiennent un caractère et un seul, un caractère est stocké sous la forme d'un nombre de 16 bits (2 octets) non signé dont les valeurs sont comprises entre 0 et 65 535. Chaque nombre représente un seul caractère Unicode. Pour les conversions entre le type Char et les types numériques il y a les fonctions AscW et ChrW qui peuvent être utilisées..
L'ajout du caractère 'c' à un littéral de chaîne force ce dernier à être un type Char. A utiliser surtout si Option Strict (qui force à être strict..) est activé.
Exemple:
Option Strict On
Dim C As Char
C = " A " c
C= CChar (" A " )
|
Après déclaration une variable Char contient '' c'est à dire un caractère vide.
String.ToCharArray: Permet de passer une string dans un tableau de Char:
Dim maString As String = " abcdefghijklmnop "
Dim maArray As Char () = maString. ToCharArray
|
La variable maArray contient à présent un tableau composé de Char, chacun représentant un caractère de maString.
Pour mettre le tableau de Char dans une String:
Dim maNewString As String (maArray)
String . Chars ():
|
vous pouvez extraire un caractère particulier en faisant référence à l'index de ce caractère par l'intermédiaire de la propriété Chars. Par exemple :
Dim maString As String = " ABCDE "
Dim monChar As Char
monChar = maString. Chars (3)
|
Un caractère est-il numérique? un chiffre? une lettre? un séparateur? un espace?....
Dim chA As Char
chA = " A " c
Dim ch1 As Char
ch1 = " 1 " c
Dim str As String
str = " test string "
Console. WriteLine (chA. CompareTo (" B " c))
Console. WriteLine (chA. Equals (" A " c))
Console. WriteLine (Char. GetNumericValue (ch1))
Console. WriteLine (Char. IsControl (Chr (9)))
Console. WriteLine (Char. IsDigit (ch1))
Console. WriteLine (Char. IsLetter (" , " c))
Console. WriteLine (Char. IsLower (" u " c))
Console. WriteLine (Char. IsNumber (ch1))
Console. WriteLine (Char. IsPunctuation (" . " c))
Console. WriteLine (Char. IsSeparator (str, 4))
Console. WriteLine (Char. IsSymbol (" + " c))
Console. WriteLine (Char. IsWhiteSpace (str, 4))
Console. WriteLine (Char. ToLower (" M " c))
|
Existe aussi IsLetterOrDigit, IsUpper.
Bien sur, si 'Option Strict= On', il faut ajouter .ToString à chaque ligne:
Console. WriteLine (Char. ToLower (" M " c). ToString )
|
On note que l'on peut tester un caractère dans une chaîne: Char.IsWhiteSpace(str, 4)
Autre manière de tester chaque caractères d'une String:
Dim V as string
For Each C As Char in V
C. . .
Next
|
Ici la String est considérée comme une collection de Char. (C'est aussi une collection de String)
Mais on verra plus loin les collections et les boucles For Each.
Conversions Char <->Unicode
On rappelle que l'unicode est le mode de codage interne des caractères.
Dim monUnicode As Short = Convert. ToInt16 (" B " c)
Dim monChar As Char = Convert. ToChar (66)
|
Pour savoir si un caractère a un code unicode précis il y a 2 méthodes:
if MyChar=Convert.ToChar(27) then...
ou
if AscW(MyChar)=27 then...
Si vous souhaiter utiliser Asc et Chr de VisualBasic:
Dim monAscii As Short = Asc (" B " )
Dim monChar As Char= Chr (66)
|
V-E-3. Et les Chaînes de longueur fixe
Débutant s'abstenir.
On a vu que les chaînes de longueur fixe n'existent pas en VB.NET (compatibilité avec les autres langages oblige), ET ON S'EN PASSE TRES BIEN, mais il y a moyen de contourner le problème si nécessaire:
On peut créer une chaîne d'une longueur déterminée (comme paramètres pour appeler une API par exemple) par:
Dim Buffer As String
Buffer = New String (CChar (" " ), 25)
UserName = Left (Buffer, InStr (Buffer, Chr (0)) - 1)
|
On peut aussi utiliser la Classe de compatibilité VB6: à éviter++
(Il faut charger dans les références du projet Microsoft.VisualBasic.Compatibility et Compatibility Data)
Dim MaChaineFixe As New VB6. FixedLengthString (100)
Dim MaChaineFixe As New VB6. FixedLengthString (100, " hello " )
|
Pour afficher la chaîne fixe utilisez MaChaineFixe.ToString.
Mais pour mettre une chaîne dans cette chaîne de longueur fixe!! galère pour trouver!!!
MaChaineFixe.Value="ghg"
Enfin ce type de chaîne fixe ne peut pas être utilisé dans les structures, mais il y a un autre moyen pour les structures. On verra cela plus loin.
Donc les chaînes fixes sont à éviter.
V-E-4. Regex, expressions régulières.
Débutant s'abstenir.
Les expressions régulières sont une manière de rechercher (de remplacer, d'extraire) une sous-chaîne ou un modèle d'une chaîne de caractères.
On a un modèle, on veut voir si une chaîne contient des parties répondant à ce modèle. Simplement pour voir ou pour séparer des sous-chaînes, remplacer..
Exemple: une chaîne ne contient t-elle que les lettres 'abc', commence t-elle par 'hello' ou 'HELLO', est-elle une adresse mail valide, un code postal valide? Comment découper une chaîne ayant comme séparateur des chiffres? Comment remplacer tous les caractères 'wxyz' par des '-'?....
V-E-4-a. Principe du regex
Les Regex servent à:
- Vérifier la syntaxe d'une chaîne de caractères.
- Remplacer une partie de la chaîne par une autre chaîne.
- Découper une chaîne de caractères.
- Extraire certaines sous-chaînes.
Pour expliquer le principe, on va comparer une chaîne String avec un modèle, un 'Pattern', nommé 'REGEX'.
Cela permet de vérifier la syntaxe d'une chaîne de caractères. La chaîne de caractères à examiner respecte t-elle un motif (le Regex) décrivant la syntaxe attendue?
Necessite l'import d'un espace de nom en haut du module:
Imports System. Text . RegularExpressions
|
Premier exemple très simple: Voir si une String ne contient que des chiffres.
Il faut dans un premier temps instancier un Regex contenant le motif. Comme exemple nous allons utiliser un motif permettant de voir si la String contient uniquement des chiffres:
Dim rg As New Regex (" [0-9] " )
|
Notez que le motif est entre guillemets. Le motif [0-9] signifie: tous les caractères entre 0 et 9.
Ensuite on va utiliser la propriété IsMatch du Regex rg pour voir si la String à vérifier ("4545896245" ici comme exemple) répond au motif. Elle retourne True si la String répond au motif.
Pour afficher:
MsgBox (rg. IsMatch (" 45gdGRj1 " ))
|
Second exemple pas simple: Voir si une String contient une adresse mail valide.
Il faut dans un premier temps instancier un Regex contenant le motif. Comme exemple nous allons utiliser un motif permettant de voir si une adresse mail est valide:
Dim rg As New Regex (" ^([\w]+)@([\w]+)\.([\w]+)$ " )
|
Bonjour le motif!!!!
Ensuite on va utiliser la propriété IsMatch du Regex pour voir si la String à vérifier répond au motif. Elle retourne True si la String a bien la syntaxe d'une adresse mail.
MsgBox (rg. IsMatch (" philippe@lasserrelyon.fr " ))
|
C'est donc extremement puissant!! mais on l'a compris tout l'art est d'écrire le motif!!
V-E-4-b. Caractères pour modèle regex
Principaux caractères composant les motifs:
hello veut dire le texte 'hello'
\ Caractère d'échappement: \. veut dire un point
^ Début de ligne
$ Fin de ligne
. N'importe quel caractère
| Alternative: toto|lulu veut dire toto ou lulu
( ) Groupement
-Intervalle de caractères: a-c veut dire a b ou c
[ ] Ensemble de caractères
[^] Tout sauf un ensemble de caractères
Après le caractère ou un groupe de caractères on peut indiquer le nombre de caractère:
+ 1 fois ou plus
? 0 ou 1 fois
* 0 fois ou plus
{x} x fois exactement
{x,} x fois au moins
{x, y} x fois minimum, y maximum
Il y a aussi des métacaractères:
\s Caractère d'espacement (espace, tabulation, saut de page, etc)
\S Tout ce qui n'est pas un espacement
\d Un chiffre
\D Tout sauf un chiffre
\w Un caractère alphanumérique
\W Tout sauf un caractère alphanumérique
\r retour charriot
Il y a plein d'autres caractères et métacaractères....
V-E-4-c. Exemples
Petits exemples:
[\.] contient un point car "." ne signifie pas 'n'importe quel caractère
il y a un caractère d'echappement avant.
^z$ contient uniquement z (entre début et fin).
es$ finit par "es"
^.$ contient un seul caractère (entre début et fin)
^(i|A) commence par i ou A
^((b)|(er)) commence par b ou er
^[a-c] commence par a,b ou c
[a-zA-Z] caractères en majuscule ou minuscule
[A-Z]+ un mot en majuscules
[A-Z]{1,7} un mot en majuscules de 1 à 7 caractères
[0-9] contient un chiffre
[^0-9] tous sauf un chiffre
\d+ entier positif
[+-]?d+ entier positif ou négatif , le signe + ou - est facultatif
^[^y] ne commence pas par y
^(o)+ commence par un ou plusieurs o
^(a)* peut ou non commencer par a
a{2,4} deux, trois ou quatre fois "a"
[12\^] Chaîne contenant les chiffres 1 ou 2 ou le symbole ^
^[0-9]+-[0-9]+$ 2 nombres séparés par un tiret: 55-4589 4586-85
[aeiou]\d Une voyelle et un chiffre: a2 i5
\d+ des chiffres (un ou plusieurs)
Validité de différent nom:
^[pP]hilip(pe)?$ True si philip Philip philippe Philippe
Validité d'une adresse ip :
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
V-E-4-d. Divers utilisations de Regex
Validation d'une chaîne de caractères: IsMatch
Funtion SiValideMail (Adresse As String ) As Boolean
Dim rg As New Regex (" ^([\w]+)@([\w]+)\.([\w]+)$ " )
Return rg. IsMatch (Adresse)
End Function
|
Retourne True si la chaîne envoyée à la fonction est une adresse mail valide.
Remplacement dans une chaîne de caractères: Replace
Funtion Remplace (Chaine As String ) As String
Dim rg As New Regex (" hello|salut|buenas dias " )
Return rg. Replace (Chaine, " bonjour " )
End Function
|
Retourne une chaîne où hello, salut, buenas dias ont été remplacés par bonjour..
Découpage d'une chaîne de caractères: Split.
Split permet de découper une chaîne de caractères et de la mettre dans un tableau en utilisant l'expression régulière comme séparateur.
Dim ch As String = " az45er78ty "
Dim rg As New Regex (" \d+ " )
Dim t () As String = rg. Split (ch)
|
ch ="az45er78ty"', retourne t(1)="az" t(2)="er" t(3)="ty"
Retourne un tableau de chaînes découpées à partir de ch avec comme séparateur les chiffres (séparateur: 1 ou plusieurs chiffres).
Extraire des chaînes de caractères: Matches.
Matches permet d'extraire les séquences de caractères correspondant à un motif. Retourne une MatchCollection qui a une propriété Count indiquant le nombre d'éléments retournés. Cette MatchCollection en lecture seule est composée de 'Match' qui ont les propriétés 'Value' (chaîne retournée) 'Index' (position: numéro caractère) et 'Length'.
On va extraire les chaînes de 2 caractères (caractères de a à z, pas les ',').
Dim ch As String = " az,er,ty "
Dim rg As New Regex (" [a-z]{2} " )
Dim mac As MatchCollection = rg. Matches (ch)
For Each m As Match In mac
MsgBox ( m. Value & " en position " & m. Index )
Next
|
Extraire des mots d'une chaîne: Matches.
Matches permet d'extraire les séquences de lettres donc des mots. Retourne une MatchCollection qui a une propriété Count indiquant le nombre d'éléments retournés.
Le motif pourrait être [A-Za-z]+ mais il y a des problèmes avec les accentués qui ne font pas partie de a-z!! il faut utiliser le motif: (\p{Lu}|\p{Ll})+ (Explication: \p{LU}: caractères unicode majuscule, \p{Ll}: caractères unicode minuscule).
Dim ch As String = " Ceci est un cours vb "
Dim rg As New Regex (" (\p{Lu}|\p{Ll})+ " )
Dim mac As MatchCollection = rg. Matches (ch)
For Each m As Match In mac
MsgBox ( m. Value & " en position " & m. Index )
Next
|
Le motif "\b(?!(le|un|une|et|de|la)\b)(\p{Lu}|\p{Ll})+" permet en plus d'éliminer les un, une, le, la..
Méthodes statiques:
On peut utiliser une autre syntaxe (pour Replace, Match, Matches) avec une méthode statique (sans instanciation du regex):
Funtion Remplace (Chaine As String ) As String
Return Regex. Replace (" salut " , " bonjour " )
End Function
|
Options:
Les méthodes statiques ou non peuvent avoir un ou plusieurs arguments optionnels (les séparer par 'Or'):
RegexOptions.IgnoreCase: ignore la case oui, oui..
RegexOptions.IgnorePatternWhitespace ignore l'espace la tabulation, nouvelle ligne
RegexOptions.Compiled: accélère car compile le regex.
RegexOptions.MultiLine: applique les caractères de début et fin à chaque ligne.
Funtion Remplace (Chaine As String ) As String
Return Regex. Replace (" salut " , " bonjour " , RegexOptions. IgnoreCase Or RegexOptions. Compiled )
End Function
|
ou en instanciant le regex:
Dim rg As New Regex (" salut " , RegexOptions. IgnoreCase Or RegexOptions. Compiled )
|
V-E-5. StringBuilder
Débutant s'abstenir.
Les opérations sur les Strings peuvent être accélérées, il faut pour cela utiliser les StringBuilder.
Exemple d'une opération coûteuse en temps:
Dim s As String = " bonjour "
s + = " mon " + " ami "
|
Le Framework va créer 3 chaînes en mémoire avec toutes les pertes en mémoire et en temps que cela implique. (il crée une chaine "bonjour" puis il crée une chaine "bonjour mon" puis...
On dit que le type String est immutable.
Pour l'exemple précédent cela ralentit peu mais dans une bouche qui concatène 10 000 chaines!!
Pour effectuer des opérations répétées sur les string, le framework dispose donc d'une classe spécialement conçue et optimisée pour ça: System.Text.StringBuilder.
Pour l'utiliser, rien de plus simple:
Dim sb As new System. Text . StringBuilder ()
sb. Append (" bonjour " )
sb. Append (" mon ami " )
Dim s As String
s = sb. ToString ()
|
Il y a création et utilisation d'une seule chaîne: sb
La méthode ToString de la classe StringBuilder renvoi la chaîne qu'utilise en interne l'instance de StringBuilder.
Pour comparer 2 StringBuilder utiliser la méthode Equals plutôt que =.
A partir de vb 2010 il existe StringBuilder.Clear.
V-F. Variables Numériques.
 4815162342
Une variable numérique peut contenir des données numériques.
On a vu qu'une variable numérique peut être entière:
- Integer (entier signé)
- Short (entier court signé)
- Long (Entier long signé)
- Byte (entier non signé de valeur 0 à 255)
A partir de VB2005 il y a aussi
- UInteger (entier non signé)
- UShort (entier court non signé)
- ULong (Entier long non signé)
- SByte (entier signé)
Une variable numérique peut aussi être un fractionnaire:
- Single (virgule flottante simple précision)
- Double (virgule flottante double précision)
- Decimal (virgule fixe haute précision)
A partir de vb 2010 il y a en plus:
- BigInteger ( Entier signé très grand (sans limite supérieure ou inférieure) (VB2010) )
- Complex (Nombre complexe)
On déclare une variable numérique avec Dim.
Après déclaration une variable numérique contient 0.
on peut initialiser en même temps qu'on déclare:
Si la variable est numérique, il faut la transformer en String avant de l'afficher :
Dim I As Integer= 12
Label. Text = I. ToString
|
.ToString fait partie des méthodes de la classe String. Il y en a d'autres:
.GetType retourne le type de la variable
Dim i As Integer
i= 3
Label1. Text = i. GetType . ToString
|
.MaxValue .MinValue donne le plus grand et le plus petit nombre possible dans le type de la variable.
On verra qu'on peut utiliser des opérateurs + - * / .
Dim I As Integer= 2
Dim J As Integer
J= I+ 3
|
On rappelle que le séparateur est le point:
J=1.2 veut dire J=1,2 en bon français !!
de même pour Str et Val du VisualBasic.
Par contre pour les instructions du Framework (CType, TryCaste, Cint...), le séparateur est celui de la culture (',' en culture française, '.' en culture us).
V-F-1. La Classe Math du Framework
Pour qu'elle soit disponible il faut d'abord importer l'espace de nom 'Math' du FrameWork :
Pour cela il faut taper en haut de la fenêtre (au-dessus de public Class):
Si on n'a pas importé l'espace de nom, il faut ajouter Math. avant le nom de la fonction. Exemple:
On verra plus loin ce que cela signifie.
Dim N As Single
Dim R As Single
R= Abs (N)
R= Sign (N)
R= Round (N)
|
Pour Round, si nombre <0.5 retourne 0 si > ou = à 0.5 retourne 1; c'est la manière d'arrondir les nombres en Euros, comme sur la feuille d'impôts.
On peut donner en second paramètre le nombre de digit: Math.Round(Valeur, 2)donne 2 décimales après la virgule.
Retourne la partie entière (enlève les chiffres après la virgule, arrondi à l'entier le plus proche en allant vers zéro).
'N=1.7 R=1
Retourne le plus grand entier égal ou inférieur (arrondi à l'entier inférieur le plus proche en allant vers l'infini négatif).
N=1.7 R=1
Retourne le plus petit entier égal ou supérieur. (arrondi à l'entier supérieur le plus proche en allant vers l'infini positf).
N=1.2 R=2
Retourne le plus grand des 2 nombres.
Retourne 3
Retourne le plus petit des 2 nombres.
Retourne 2
Retourne 2 puissance 3.
Retourne 8
Retourne la racine carrée.
Retourne 3
longResult = Math.BigMul(int1, int2) 'BigMul donne le résultat de la multiplication de 2 entiers sous forme d'un long.
intResult = Math.DivRem(int1, int2, Reste) DivRem donne le résultat (intResult) de la division de int1 par int2 et retourne le reste (Reste), cela pour des entiers.
Il existe aussi Log, Log10, Exp.
Bien sur il y a aussi Sin Cos Tan, Sinh Cosh Tanh (pour hyperbolique) Asin Acos Atan Atan2.
Prenons un exemple:
Imports System. Math
Dim MonAngle, MaSecant As Double
MonAngle = 1. 3
MaSecant = 1 / Cos (MonAngle)
|
On remarque que les angles sont en radians.
Rappel:2pi=360° ; Angle en radians= (2pi/360)*Angle en degrés
V-F-2. Les instructions du langage VisualBasic
Int et Fix qui suppriment toutes deux la partie fractionnelle et retournent l'entier.
Dim R As Single= 1. 7
Int (R)
|
Si le nombre est négatif, Int retourne le premier entier négatif inférieur ou égal au nombre, alors que Fix retourne le premier entier négatif supérieur ou égal au nombre. Par exemple, Int convertit -8,4 en -9 et Fix convertit -8,4 en -8.
V-F-3. Dépassement de capacité, 'Non Nombre'
Testé en VB2005
On a vu que , codées sur un nombre de bits défini, les variables numériques ne peuvent pas avoir des valeurs très très grandes. .MaxValue donne le plus grand nombre possible dans le type de la variable. (MinValue le plus petit nombre) Que se passe t-il , si on dépasse la valeur maximum?
- Si on affecte à une variable entière une valeur supérieure à .MaxValue cela déclenche une erreur (on dit une exception de type OverFlow) et cela plante.
- Si on affecte à une valeur à virgule flottante(un Single par exemple), une valeur supérieure à .MaxValue, la variable prend la valeur 'infinie' ( +ou - infinie: Single.NegativeInfinity ou Single.PositiveInfinity))
Exemple:
IsInfinity, IsNegativeInfinity, IsPositiveInfinity permettent de tester si le résultat d'un calcul dépasse les valeurs autorisées pour le Type virgule flottante.
Dim s As Single = 2147483647 ^ 33
If Single. IsInfinity (s) Then MsgBox (" infinie " )
|
s prend la valeur Single.PositiveInfinity.
Les opérations en virgule flottante retournent NaN pour signaler que le résultat de l'opération est non défini. Par exemple, le résultat de la division de 0,0 par 0,0 est NaN.
On peut tester une expression par IsNan.
Exemple:
If Single. IsNaN (0 / 0) Then
|
V-F-4. Problème de précision
Integer Single ou Decimal ? précision ou rapidité?
Vu le système de codage en interne, on a vu qu'avec les variables en virgule flottante, comme les Single par exemple, certaines valeurs ou calculs sont représentés avec une certaine approximation, infime mais réelle.
Souvent le calcul est exact mais parfois (rarement en pratique courante) on peut avoir une infime manque de précision. Voici un exemple: on a 0,0001, avec une boucle on l'additionne dix milles fois:
Dim i As Integer
Dim k As Single
Dim j As Single = 0. 0001
For i = 1 To 10000
k = k + j
Next
MsgBox (k. ToString )
Dim k1 As Decimal
Dim j1 As Decimal = 0. 0001
For i = 1 To 10000
k1 = k1 + j1
Next
MsgBox (k1. ToString )
|
Avec des Decimal on obtient bien 1, mais avec des Single on obtient 1,000054!!
Cela peut poser des problèmes si on compare le résultat du calcul avec 1.
Avec les entiers la précision est parfaite.
Dans notre exemple le calcul est DIX fois plus long avec les Decimal qu'avec les Single.
V-F-5. BigInteger
Un BigInteger est un Entier signé très grand (sans limite supérieure ou inférieure).
Il apparait dans vb 2010.
la valeur, en théorie, n'a pas de limites supérieure ou inférieure.
Il faut charger dans les réferences (passer par propriétés du projet) pour charger System.Numerics puis Importer cet espace.
Instanciation:
Imports System. Numerics
Dim MyBitInteger As New BigInteger (17903)
Dim MylongValue As Long = 631548935
Dim MyBigInteger2 As BigInteger = Mylong
Dim MyBigInteger As BigInteger = CType (64312. 65d , BigInteger)
|
On peut utiliser les opérations mathématiques de base telles que l'addition, la soustraction, la division, la multiplication (+ -* /), la négation et la négation unaire.
Vous pouvez également comparer deux valeurs .Comme les autres types intégraux, BigInteger prend en charge également les opérateurs de bit, de décalage vers la droite et de décalage vers la gauche And, Or et XOr
Il existe aussi Add, Divide, Multiply, Negate et Subtract.
Sign, retourne une valeur qui indique le signe d'une valeur BigInteger.
Abs retourne la valeur absolue d'une valeur BigInteger.
DivRem retourne à la fois le quotient et reste d'une opération de division.
GreatestCommonDivisor retourne le plus grand diviseur commun de deux valeurs BigInteger.
Exemple: Creation de 2 BitInteger (2190 Puissance 2 et 42656*35); affichage du plus grand commun diviseur.
Dim n1 As BigInteger = BigInteger. Pow (2190, 2)
Dim n2 As BigInteger = BigInteger. Multiply (42656, 35)
Console. WriteLine (" Le plus grand commun diviseur de {0} et de {1} est {2}. " , _
n1, n2, BigInteger. GreatestCommonDivisor (n1, n2))
|
Les calculs avec les BigInteger sont lents (20 fois plus lent qu'avec les Single pour 10 000 additions par exemple).
Comme ce sont des entiers, il ne devrait pas y avoir d'erreur d'arrondi.
V-F-6. Nombre Complexe
Les nombres complexes sont une notion mathématique (je les avais étudiés en terminal S il y a quelques années). Ils sont utilisés dans certains calculs en génie electrique.
Un nombre complexe comprend une partie réelle et une partie imaginaire.
Un nombre complexe z s'écrit sous la forme suivante : z = x + yi, où x et y sont des nombres réels, et i est l'unité imaginaire qui a la propriété i2 = -1.
La partie réelle du nombre complexe est représentée par x, et la partie imaginaire du nombre complexe est représentée par y.
Un nombre complexe peut être représenté comme un point dans un système de coordonnées à deux dimensions, appelé plan complexe.La partie réelle est positionnée sur l'axe des abscisses (axe horizontal), et la partie imaginaire est positionnée sur l'axe des ordonnées (axe vertical).
Tout point peut également être exprimé, en utilisant le système de coordonnées polaires.
Un point est caractérisé par deux nombres :
-Sa grandeur, qui est la distance entre le point et l'origine (autrement dit, 0,0).
-Sa phase, qui est l'angle entre le véritable axe et la ligne tirée entre l'origine et le point.

En vb x et y (coordonnées cartésiennes) sont des 'Double'.
Les propriétés Real et Imaginary retournent la part réelle et imaginaire du nombre complexe.
La magnitude (d) et la phase (alpha exprimé en radian) sont des 'Double'.
(Pour convertir des degrés en radian multiplier par Math.Pi/180).
Les propriétés Magnitude et Phase retournent d et alpha.
Il faut charger dans les réferences (passer par propriétés du projet) pour charger System.Numerics puis Importer cet espace.
Imports System. Numerics
Module Example
Public Sub Main ()
Dim c1 As New Complex (11, 6)
Console. WriteLine (c1)
Dim c2 As Complex = 3. 1416
Console. WriteLine (c2)
Dim c3 As Complex = Complex. One + Complex. One
Console. WriteLine (c3)
Dim c4 As Complex = Complex. FromPolarCoordinates (10, . 524 )
Console. WriteLine (c4)
Console. Write (c4. Real )
Console. Write (c4. Imaginary )
Console. WriteLine (" Magnitude: {0} " , c4. Magnitude )
Console. WriteLine (" Phase: {0} radians " , c4. Phase )
End Sub
End Module
|
Opérateurs
Les opérations sur les nombres complexes obéissent à des régles mathématique particulières (voir un cours de maths). Vb connait ces régles.
En plus de quatre opérations arithmétiques fondamentales (+ - / * ou Add, Substrat, Divise, Multiply), vous pouvez élever un nombre complexe à une puissance spécifiée (Pow), rechercher la racine carrée d'un nombre complexe (Sqrt) et obtenir la valeur absolue d'un nombre complexe (Abs).
Vous pouvez obtenir l'inverse (Negate) le Log et les valeurs trigonométriques (Cos, Sin..). Enfin on peut comparer avec Equals et =.
Dim c4 As New Complex (1, 1)
Dim c2 As New Complex (2, 2)
Dim c1 As New Complex
c1 = Complex. Subtract (c4, c2)
Console. Write (c1)
|
Attention, les valeurs étant des doubles il peut y avoir des problèmes d'arrondi: perte de précision lors de certaines opérations ce qui peut poser des problèmes au cours de comparaisons.
Pour formater une impression de nombre complexe, on peut utiliser ToString ou le ComplexFormatter:
Dim c1 As Complex = New Complex (12. 1 , 15. 4 )
Console. WriteLine (" Formatting with ToString(): " +
c1. ToString ())
Console. WriteLine (" Formatting with ToString(format): " +
c1. ToString (" N2 " ))
Console. WriteLine (" Custom formatting with I0: " +
String . Format (New ComplexFormatter (), " {0:I0} " , c1))
Console. WriteLine (" Custom formatting with J3: " +
String . Format (New ComplexFormatter (), " {0:J3} " , c1))
|
V-G. Conversion, séparateur décimal
On a vu qu'on peut afficher les chaînes de caractères (des 'String'), par ailleurs, on fait des calculs avec les variables numériques (Integer, Single..).
On a donc besoin sans arrêt de faire des calculs avec des variables numériques et de transformer le résultat en String pour l'afficher et vice versa.
Est-il possible de convertir une variable d'un type à un autre? OUI!!
On aura donc besoin de savoir transformer des variables de tous types en d'autres types.
V-G-1. Conversion numérique vers String
Quel intérêt de convertir?
Après avoir effectué un calcul, on veut afficher un résultat numérique.
On ne peut afficher que des Strings (chaîne de caractères) dans un label ou un TextBox par exemple.
Aussi, il faut transformer cette valeur numérique en chaîne avant de l'afficher, on le fait avec la méthode ".ToString":
Dim i As Integer= 12
Label. text = i. ToString
|
La valeur de i est transformée en String puis affectée à la propriété Text du label, ce qui affiche '12'
On verra plus loin qu'on peut ajouter des paramètres.
Il existe aussi CStr:
Dim i As Integer= 12
Label. text = CStr (i)
|
V-G-2. Conversion String vers numérique
A l'inverse une chaîne de caractères peut être transformée en numérique :
Par exemple, l'utilisateur doit saisir un nombre, il saisit un nombre dans une boite de saisie (InputBox), mais il tape des caractères au clavier et c'est cette chaîne de caractères qui est retournée, il faut la transformer en numérique Integer grâce à CInt.
Dim s as String
Dim i as Integer
s= InputBox (" Test " , " Taper un nombre " )
i= CInt (S)
|
On peut aussi utiliser Parse:
Dim s as String
Dim i as Integer
s= InputBox (" Test " , " Taper un nombre " )
i= Integer. Parse (s)
|
Bizarre cette syntaxe!! en fait c'est le type Integer qui a une méthode (Parse) qui transforme une chaîne en entier.
On peut aussi utiliser, et c'est plus simple, CType pour convertir n'importe quel type en n'importe quel type :
Il suffit de donner à cette fonction la variable à modifier et le type à obtenir.
Dim i As Integer
Dim s As String = " 12 "
i= CType (s,Integer)
|
i contient maintenant l'entier 12.
Voila ces quelques instructions devraient suffire pour un usage courant!! Mais il en existe d'autres.
V-G-3. Tous les modes de conversion
CType pour tout.
CType peut aussi servir à convertir de la même manière un single en double, un Short en Integer....
Il est donc possible de convertir un type de variable en un autre.
Il suffit de donner à cette fonction la variable à modifier et le type à obtenir.
Dim d As Double = 2. 65
Dim i As Integer
i= CType (d,Integer)
|
Dim d As Double = 2. 65
Dim s As String
s= CType (d,String )
|
Dim d As Integer = 2
Dim S As Single
S= CType (d, Single)
|
Pour les forts:
DirectCast fait de même mais on doit utiliser une variable ByRef.
i=DirectCast(s,Integer) 'S doit être ByRef.
Par contre DirectCast nécessite que le type d'exécution d'une variable objet soit identique au type spécifié.
Dim Q As Object = 2. 37
Dim K As Integer = CType (Q, Integer)
Dim J As Integer = DirectCast (Q, Integer)
|
DirectCast échoue car le type d'exécution de Q est Double. CType réussit car Double peut être converti en Integer, mais DirectCast échoue car le type d'exécution de Q n'est pas encore Integer.
TryCast à partir de VB 2005 (Framework 2)
TryCast fonctionne comme DirectCast mais retourne Nothing si la conversion est impossible (et ne plante pas! autrement dit, il ne leve pas d'exceptions).
Dim chaine As String = TryCast (b, String )
If IsNothing (chaine) Then . .
|
Fonctions spécifiques
CType fait toutes les conversions, mais on peut aussi utiliser des fonctions qui sont spécifiques au type de la variable de retour: Le nom de ces fonctions contient le nom du type de la variable de retour.
CBool ()
CByte ()
CChar ()
CDate ()
CDbl ()
CDec ()
CInt ()
CLng ()
CObj ()
CShort ()
CSng ()
CStr ()
CSByte ()
CUShort ()
CUInt ()
CULng ()
|
Exemple CDbl retourne un 'Double'.
Dim I As Integer= 123
Dim D As Double
D= CDbl (I)
|
Ces fonctions sont plus rapides car elles sont spécifiques.
Remarque:
Les fonctions CInt et CLng arrondissent les parties décimales égales à 0,5 au nombre pair le plus proche. Par exemple, 0,5 s'arrondit à 0 et 1,5 s'arrondit à 2. Bizarre!!
Val et Str (de MicroSoft.VisualBasic) existe aussi:
Ouf pour les anciens!!
Ces fonctions permettent aussi la conversion String=>Numérique et Numérique=>String
Val donne la valeur numérique d'une expression String.
Dim i As Integer
i= Val (" 5 " )
|
Val s'arrête au premier caractère non numérique.
Val("12er") retourne 12
Val reconnaît le point (et pas la virgule).
Dim i As Double
i= Val (" 5.45 " )
i= Val (" 5,45 " )
|
Str transforme une valeur numérique en String:
Dim s As String
s= Str (1999)
|
Noter bien: Str ajoute un espace à gauche ou le signe'-' si le nombre est négatif.
Str ne reconnaît que le point comme séparateur décimal. Pour utiliser les autres séparateurs internationaux, il faut utiliser la fonction CStr() .
La Classe System.Convert:
La Classe System.Convert permet la conversion d'un type de base vers un autre:
.ToString en fait partie
Exemple
Pour convertir un Single en Byte (entier 8 bits non signé)
.ToByte
Pour convertir un Byte en Single:
.ToSingle
singleVal = System. Convert . ToSingle (byteVal)
|
En Decimal
.ToDecimal
On a des méthodes pour pratiquement convertir tous les types en tous les types. Cherchez!!
On verra plus loin, la fonction Format utilisée pour convertir une valeur numérique en une chaîne de caractères généralement destinée à l'affichage en imposant un formatage: vous pouvez mettre un format pour l'affichage des dates, des heures, un format pour les monnaies ou les nombres( nombre de chiffre affiché, séparateur..) Ce n'est pas à proprement parlé une conversion mais plutôt une mise en forme.
Dim nb As Single = 12. 23
MsgBox ( Format (nb, " 000,000.000 " )
|
V-G-4. Pour résumer et faire très simple, retenir
ToString pour les conversions en String des variables numériques(pour afficher).
CType pour convertir tout en tout.
Le fait de convertir d'un type dans un autre s'appelle 'effectuer un cast'
V-G-5. Conversion Explicite et Implicite
A noter que dans cette page, on a étudié la conversion Explicite: elle permet de forcer la conversion vers un type à l'aide de mots clés. C'est l'option par défaut de VB (pour le voir: menu 'Projet', 'Propriétés de ..', Onglet 'Compiler').
Exemple
Dim d As Double = 2. 65
Dim i As Integer
i= CType (d,Integer)
|
Il existe aussi la conversion Implicite effectuée automatiquement sans syntaxe particulière et de manière transparente.
VB peut le permettre (Si Option Explicit= Off dans la configuration ).
Exemple:
Option Explicit Off
Dim d As Double = 2. 65
Dim i As Integer
i= d
|
On verra que ce mode de travail Implicite n'est pas recommandé.
V-G-6. Conversion restrictive, erreur
 |
Attention, la conversion est dite restrictive si le type final ne peut pas convertir toutes les valeurs possibles du type de départ:
|
Si je convertis un Single en Integer, la partie décimale peut être tronquée, c'est une conversion restrictive.
L'inverse (conversion Short en Single par exemple) est dite étendue.
V-G-7. Erreur de dépassement de capacité dans les calculs
Voyons le code suivant qui semble correct:
Dim i As Integer = 1000000000
Dim j As Long
j = i * 10
MsgBox (j)
|
J'ai un grand nombre dans un integer, comme je le multiplie par 10 et que cela risque de dépasser le MaxValue dans Integer, je met le résultat dans un Long. Pourtant il y a une erreur à l'exécution!!
Explication: quand l'expression j=i*10 est exécutée, l'expression de droite (i*10) est exécutée en premier, comme i est un Integer et '10' aussi, le résultat est mis dans un Integer (c'est là qu'il y a dépassement de capacité) puis casté en Long pour être affecté à J.
Pour éviter cela, il faut travailler directement en Long ou bien écrire 'j=i*10L': le L force 10 a être un Long et le calcul est effectué en Long.
V-G-8. Séparateur décimal : le point, la virgule, Culture
On rappelle aussi que le séparateur d'un littéral est le point (un littéral sert à donner une valeur à une variable):
Dim s As Single
s= 456. 67
|
Les fonctions Val (conversion d'une String en numérique) et Str (conversion d'un numérique en String), de Visual Basic, ne reconnaissent que le point (.) comme séparateur décimal.
Dim s As Single
s= Val (" 123.4 " )
|
Les fonctions CDbl, CType, CSng ou Parse ainsi que ToString utilisent le séparateur des paramètres locaux de la machine . Ils reconnaissent la culture.
Le symbole de séparateur décimal (ainsi que celui des milliers ) est donc spécifique à la culture.
On remarque donc que ToString utilise aussi le séparateur spécifique à la culture.
Console. Out . WriteLine (s. ToString )
|
Affiche: '123,4' en France
Lors de l'utilisation d'autres séparateurs décimaux (applications internationales, par exemple), convertissez la chaîne en nombre à l'aide de la fonction CDbl ou CType CSng ou Parse.
Pour voir quel est le séparateur en cours:
Menu Démarrer->Paramètres->Panneau de configuration>Options régionales et linguistiques.
Obtient le séparateur décimal en fonction des paramètres locaux de la machine par du code.
SeparateurDécimal = NumberFormatInfo. CurrentInfo . NumberDecimalSeparator
|
On peut modifier le CultureInfo:
On peut, si on est en CultureInfo Français, afficher en mode Us.
Dim i As Single = 45. 78
Console. WriteLine (i. ToString )
Dim us As New CultureInfo (" en-US " )
Console. WriteLine (i. ToString (" c " , us))
|
Il s'agit ici d'une surcharge de ToString , "c" signifie NumberFormatInfo.
V-G-9. IsNumeric
On utilise la fonction IsNumeric pour déterminer si le contenu d'une variable peut être évalué comme un nombre.
Exemples:
Dim MyVar As Object
Dim R As Boolean
MyVar = " 45 "
R = IsNumeric (MyVar)
MyVar = " 678.92 "
R = IsNumeric (MyVar)
MyVar = " 45 Kg "
R = IsNumeric (MyVar)
|
 |
'Attention le dernier exemple indique que "45 Kg" n'est pas purement numérique, mais Val("45 Kg") retourne 45 sans déclencher d'erreur car Val transforme les caractères numériques à partir de la gauche, en s'arrêtant dès qu'il y a un caractère non numérique.
|
V-G-10. Lexique anglais=>Français
To Cast = Mouler, couler.
Type = Type, genre.
To parse = analyser.
Les sources présentés sur cette page sont libres de droits,
et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © .
Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu :
textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
Cette page est déposée à la SACD.
|