VBScript

1.1.1        Types de données VBScript

Toutes les données de VBScript sont de type Variant. Ce type de données peut contenir différentes catégories d'informations, selon son mode d'utilisation. Le type de données Variant étant le seul utilisé dans VBScript, il est le seul renvoyé par les fonctions VBScript.

Au delà de la classification mentionnée ci-dessus, des distinctions supplémentaires peuvent être établies quant à la nature des informations numériques de type Variant. Ainsi, lorsque des informations numériques représentent une date ou une heure, le résultat est toujours exprimé sous forme de date ou d'heure. Ce type de données peut également correspondre à une large variété d'informations numériques, allant des valeurs de type Boolean aux très grands nombres en virgule flottante. Ces différentes catégories d'informations sont qualifiées de sous-types. Le comportement des données de type Variant est toujours adapté aux informations qu'elles contiennent.

Le tableau présente les sous-types de données pouvant être contenues dans des variables de type Variant.

Pour passer d'un sous-type à un autre, il existe une large variété de fonctions de conversion. En outre, une autre fonction, VarType, renvoie des informations sur le mode de stockage des données contenues dans une variable de type Variant.

1.1.2        Variables de VBScript

Vous déclarez les variables explicitement dans le script à l'aide de l'instruction Dim, de l'instruction Public et de l'instruction Private. Par exemple:

 Dim DegreesFahrenheit

Pour déclarer plusieurs variables, séparez-les par des virgules. Par exemple:

 Dim Top, Bottom, Left, Right

Vous pouvez également déclarer une variable implicitement en utilisant simplement son nom quelque part dans le script. Cette pratique n'est généralement pas conseillée, puisqu'une simple faute de frappe dans un nom de variable pourrait créer des incidents imprévisibles lors de l'exécution du script. Pour éviter ce problème, l'instruction Option Explicit impose la déclaration explicite de toutes les variables. Cette instruction doit être la première de votre script.

Les noms de variables obéissent aux conventions standard d'affectation de nom de VBScript. Un nom de variable:

·         doit commencer par un caractère alphabétique;

·         ne peut pas contenir de point;

·         ne doit pas compter plus de 255 caractères;

·         doit être unique dans la portée dans laquelle il est déclaré.

Lorsque vous déclarez une variable dans une procédure, seul le code de cette procédure peut accéder à la valeur de cette variable et la modifier; elle a une portée locale et est qualifiée de variable de niveau procédure. Cependant, vous devez parfois utiliser une variable d'une plus large portée, notamment lorsque sa valeur doit être accessible par toutes les procédures d'un script. Si vous déclarez une variable en dehors d'une procédure, toutes les procédures du script peuvent la reconnaître. Ce type de variable de niveau script a ce qu'il est convenu d'appeler une portée de niveau script.

La durée de vie d'une variable est comprise entre la déclaration de la variable et la fin de l'exécution du script. Celle d'une variable locale va de sa déclaration à la fin de la procédure. Les variables locales constituent un espace de stockage temporaire idéal pendant l'exécution d'une procédure. Plusieurs variables locales peuvent porter le même nom dans différentes procédures, puisque chacune est reconnue uniquement par la procédure dans laquelle elle est déclarée.

La portée d'une variable est fonction de l'endroit où vous la déclarez. Au niveau script, la durée de vie d'une variable est toujours la même. Elle existe tant que le script s'exécute. Au niveau procédure, cette durée est limitée à l'exécution de la procédure. La variable est détruite automatiquement à la sortie de la procédure.

Des valeurs sont attribuées aux variables à l'aide d'expressions: la variable se trouve du côté gauche de l'expression, la valeur à attribuer à droite. Par exemple:

 B = 200

Vous souhaitez généralement attribuer une simple valeur à une variable déclarée. Cette variable est alors qualifiée de variable scalaire. Il convient parfois d'attribuer plusieurs valeurs à une variable. Dans ce cas, vous pouvez créer un tableau contenant une série de valeurs. Les tableaux sont déclarés de la même manière que les variables scalaires. Dans la déclaration d'un tableau, le nom de la variable est suivi de parenthèses. L'exemple ci-dessous présente la déclaration d'un tableau à une dimension contenant 11 éléments:

 Dim A(10)

Bien que 10 soit indiqué entre parenthèses, ce tableau contient 11 éléments parce que tous les tableaux VBScript incluent l'élément zéro. Dans ce type de tableau, le nombre d'éléments correspond toujours au nombre entre parenthèses plus un. On parle ici de tableau de taille fixe.

Vous pouvez attribuer des valeurs à chacun des éléments du tableau au moyen d'un index de 0 à 10:

 A(0) = 256

 A(1) = 324

 A(2) = 100

 . . .

 A(10) = 55

De même, les données peuvent être extraites d'un élément particulier avec un index. Par exemple:

 . . .

 SomeVariable = A(8) 

 . . .

Il est possible de créer des tableaux multidimensionnels. Vous pouvez utiliser jusqu'à 60 dimensions, bien que le nombre utile se limite généralement à trois ou quatre. Pour déclarer ces dimensions, séparez les nombres de dimension d'un tableau par des virgules. Dans l'exemple suivant, la variable MyTable correspond à un tableau bidimensionnel formé de 6 lignes et 11 colonnes:

 Dim MyTable(5, 10)

Dans un tableau bidimensionnel, le premier nombre correspond toujours au nombre de lignes, le second au nombre de colonnes.

Vous pouvez également déclarer un tableau dont la taille varie pendant l'exécution du script. Ce tableau dynamique est initialement déclaré dans une procédure avec l'instruction Dim (comme pour les autres tableaux), ou ReDim. Cependant, dans ce cas aucune taille ou nombre de dimensions n'apparaît entre parenthèses. Par exemple:

 Dim MyArray()

 ReDim AnotherArray()

Pour utiliser un tableau dynamique, vous devrez ultérieurement employer ReDim pour déterminer le nombre de dimensions et la taille de chacune. Dans l'exemple suivant, ReDim choisit 25 comme taille initiale du tableau dynamique. Une autre instruction ReDim redimensionne le tableau à 30, mais utilise le mot clé Preserve pour préserver le contenu du tableau lors du redimensionnement.

 ReDim MyArray(25)

 . . .

 ReDim Preserve MyArray(30)

Vous pouvez redimensionner un tableau autant de fois que vous le souhaitez, mais il convient de garder à l'esprit que toute diminution de la taille d'un tableau entraîne la perte des données contenues dans les éléments supprimés.

1.1.3        Constantes VBScript

Élément non modifiable, une constante est un nom significatif remplaçant un nombre ou une chaîne. Aucune constante n'est actuellement définie par le langage VBScript. Les constantes y sont mises en oeuvre comme des valeurs littérales affectées à des noms de variable.

Dans VBScript, la création de constantes s'effectue avec l'instruction Const. Cette dernière permet de créer des constantes de chaîne ou numériques portant des noms significatifs. Vous pouvez leur attribuer des valeurs littérales et les utiliser dans votre script. Par exemple:

Const MyString

MyString = "Voici ma chaîne."

Const MyAge

MyAge = 49

Notez que la chaîne est entre guillemets ("). Les guillemets constituent la meilleure méthode de différenciation des valeurs de chaîne et des valeurs numériques. Pour représenter des littéraux de date et des littéraux d'heure, placez-les entre dièses (caractère #). Par exemple:

Const CutoffDate

CutOffDate = #1-1-96#

Puisqu'il n'existe aucune différence entre les constantes ainsi créées et les variables ordinaires, il peut être préférable d'adopter un schéma d'attribution de noms assurant la différenciation des deux éléments. Vous éviterez ainsi de vainement tenter de leur attribuer de nouvelles valeurs lors de l'exécution du script.

1.1.4        Opérateurs de VBScript        

1.1.4.1     Priorité des opérateurs

VBScript comporte une gamme complète d'opérateurs, notamment des opérateurs arithmétiques, des opérateurs de comparaison, des opérateurs de concaténation et des opérateurs logiques.

Lorsque plusieurs opérations sont incluses dans une expression, chaque partie est évaluée et résolue selon un ordre prédéfini. On parle alors de priorité des opérateurs. Vous pouvez utiliser des parenthèses pour outrepasser l'ordre de priorité et forcer l'évaluation de certaines parties d'une expression avant d'autres. Les opérations entre parenthèses sont toujours effectuées avant celles placées à l'extérieur. Cependant, à l'intérieur des parenthèses la priorité normale des opérateurs est maintenue.

Lorsque des expressions contiennent des opérateurs de plusieurs catégories, les opérateurs arithmétiques sont évalués en premier, suivis des opérateurs de comparaison et des opérateurs logiques. Tous les opérateurs de comparaison ayant une priorité égale, ceux-ci sont évalués de gauche à droite. L'évaluation des opérateurs arithmétiques et logiques s'effectue selon l'ordre de priorité suivant.

Lorsqu'une multiplication et une division sont incluses dans une expression, chaque opération est évaluée de gauche à droite. Il en est de même lorsqu'une expression comporte une addition et une soustraction.

L'opérateur de concaténation de chaîne (&) n'est pas un opérateur arithmétique, mais en termes de priorité, il se situe après tous les opérateurs arithmétiques et avant tous les opérateurs de comparaison. L'opérateur Is est un opérateur de comparaison de référence d'objet. Il ne compare ni les objets ni leur valeur, mais vérifie uniquement si deux références d'objet se réfèrent au même objet.

1.1.5        Contrôle du déroulement d'un programme dans VBScript

1.1.5.1     Contrôle de l'exécution d'un programme

À l'aide d'instructions conditionnelles et d'instructions de boucle (également qualifiées de structures de contrôle), vous pouvez écrire du code VBScript prenant des décisions et répétant des actions.

1.1.5.2     Décisions à l'aide de If...Then...Else

L'instruction If...Then...Else permet d'évaluer si une condition est True ou False et de prévoir l'exécution d'une ou de plusieurs instructions en fonction du résultat. Généralement, cette condition correspond à une expression qui utilise un opérateur comparant une valeur ou une variable à une autre. Les instructions If...Then...Else peuvent être imbriquées au nombre de niveaux requis.

Si vous souhaitez exécuter une seule instruction lorsqu'une condition est True, vous pouvez employer la syntaxe à une ligne de l'instruction If...Then...Else. L'exemple suivant présente cette syntaxe; notez que le mot clé Else n'y est pas utilisé.

 Sub FixDate()

     Dim myDate

     myDate = #2/13/95#

     If myDate < Now Then myDate = Now

 End Sub

Si vous souhaitez exécuter plusieurs lignes de code, vous devez employer la syntaxe à plusieurs lignes. Celle-ci inclut l'instruction End If, comme dans l'exemple ci-dessous:

 Sub AlertUser(value)

     If value = 0 Then

         AlertLabel.ForeColor = vbRed

         AlertLabel.Font.Bold = True

         AlertLabel.Font.Italic = True

     End If

 End Sub

L'instruction If...Then...Else permet de définir deux blocs d'instructions exécutables: le premier s'exécute si la condition est True, l'autre si elle est False.

 Sub AlertUser(value)

     If value = 0 Then

         AlertLabel.ForeColor = vbRed

         AlertLabel.Font.Bold = True

         AlertLabel.Font.Italic = True

     Else

         AlertLabel.Forecolor = vbBlack

         AlertLabel.Font.Bold = False

         AlertLabel.Font.Italic = False

     End If

 End Sub

1.1.5.3     Utilisation de boucles de répétition

Les boucles permettent de répéter l'exécution d'un groupe d'instructions. Certaines répètent les instructions jusqu'à ce qu'une condition soit False, d'autres jusqu'à ce qu'elle soit True. Il est également possible de prévoir un nombre spécifique de répétitions.

VBScript comporte les instructions de boucle suivantes:

·         Do...Loop: effectue une boucle tant qu'une condition est True ou jusqu'à ce qu'elle le devienne.

·         While...Wend: effectue une boucle tant qu'une condition est True.

·         For...Next: utilise un compteur pour exécuter des instructions un nombre de fois spécifié.

Les instructions Do...Loop permettent d'exécuter un bloc d'instructions un nombre de fois indéfini. Les instructions sont répétées tant qu'une condition est True ou jusqu'à ce qu'elle le devienne.

Utilisez le mot clé While pour vérifier une condition dans une instruction Do...Loop. Vous pouvez le faire avant d'entrer dans la boucle (comme dans le premier exemple ci-dessous), ou après au moins une exécution de la boucle (deuxième exemple). Dans la procédure ChkFirstWhile, si myNum avait la valeur 9 et non 20, les instructions à l'intérieur de la boucle ne s'exécuteraient jamais. Dans la procédure ChkLastWhile, les instructions de la boucle ne s'exécutent qu'une seule fois puisque la condition est déjà False.

 Sub ChkFirstWhile()

     Dim counter, myNum

     counter = 0

     myNum = 20

     Do While myNum > 10

         myNum = myNum - 1

         counter = counter + 1

     Loop

     MsgBox "La boucle a effectué " & counter & " répétitions."

 End Sub

 Sub ChkLastWhile()

     Dim counter, myNum

     counter = 0

     myNum = 9

     Do

         myNum = myNum - 1

         counter = counter + 1

     Loop While myNum > 10

     MsgBox "La boucle a effectué " & counter & " répétitions."

 End Sub

Le mot clé Until s'utilise de deux manières pour vérifier une condition dans une instruction Do...Loop. Vous pouvez procéder à cette vérification avant d'entrer dans la boucle (comme dans le premier exemple qui suit), ou le faire après au moins une exécution de la boucle (deuxième exemple). Tant que la condition est False, la boucle continue.

 Sub ChkFirstUntil()

     Dim counter, myNum

     counter = 0

     myNum = 20

     Do Until myNum = 10

         myNum = myNum - 1

         counter = counter + 1

     Loop

     MsgBox "La boucle a effectué " & counter & " répétitions."

 End Sub

 Sub ChkLastUntil()

     Dim counter, myNum

     counter = 0

     myNum = 1

     Do

         myNum = myNum + 1

         counter = counter + 1

     Loop Until myNum = 10

     MsgBox "La boucle a effectué " & counter & " répétitions."

 End Sub

L'instruction Exit Do permet de sortir d'une boucle Do...Loop. Cette sortie ne devant généralement être effectuée que dans certaines situations, notamment pour éviter la création d'une boucle sans fin, il convient d'utiliser l'instruction Exit Do dans le bloc d'instructions True d'une instruction If...Then...Else. Si la condition est False, la boucle s'exécute normalement.

Dans l'exemple suivant, myNum obtient une valeur qui crée une boucle sans fin. L'instruction If...Then...Else vérifie la présence de cette condition pour éviter cet incident.

 Sub ExitExample()

     Dim counter, myNum

     counter = 0

     myNum = 9

     Do Until myNum = 10

         myNum = myNum - 1

         counter = counter + 1

         If myNum < 10 Then Exit Do

     Loop

     MsgBox "La boucle a effectué " & counter & " répétitions."

 End Sub

Les instructions For...Next permettent d'exécuter un bloc d'instructions un certain nombre de fois. Pour les boucles, utiliser une variable de compteur dont la valeur est incrémentée ou décrémentée à chaque répétition de la boucle.

Dans l'exemple suivant, la procédure MyProc s'exécute 50 fois. L'instruction For spécifie la variable de compteur x et ses valeurs de début et de fin. L'instruction Next incrémente cette variable de 1.

 Sub DoMyProc50Times()

     Dim x

     For x = 1 To 50

         MyProc

     Next

 End Sub

Le mot clé Step permet de préciser de combien la variable doit être incrémentée ou décrémentée. Dans l'exemple, cette variable est incrémentée de 2 à chaque itération de la boucle. Une fois la boucle terminée, le total correspond à la somme de 2, 4, 6, 8 et 10.

 Sub TwosTotal()

     Dim j, total

     For j = 2 To 10 Step 2

         total = total + j

     Next

     MsgBox "Le total est égale à " & total

 End Sub

Pour décrémenter la variable du compteur, utilisez une valeur Step négative. Dans ce cas, vous devez préciser une valeur finale inférieure à la valeur initiale. Dans l'exemple suivant, la variable de compteur myNum est décrémentée de 2 à chaque itération de la boucle. Une fois la boucle terminée, le total correspond à la somme de 16, 14, 12, 10, 8, 6, 4 et 2.

 Sub NewTotal()

     Dim myNum, total

     For myNum = 16 To 2 Step -2

         total = total + myNum

     Next

     MsgBox "Le total est égale à " & total

 End Sub

L'instruction Exit For permet de sortir d'une boucle For...Next avant que le compteur n'atteigne sa valeur finale. Ce type de sortie étant normalement utilisé dans des situations particulières, notamment lors d'une erreur, il convient d'employer l'instruction Exit For dans le bloc d'instructions True d'une instruction If...Then...Else. Si la condition est False, la boucle s'exécute normalement.

1.1.6        Procédures de VBScript 

Une procédure Sub correspond à une série d'instructions VBScript, délimitée par les instructions Sub et End Sub, qui effectuent des actions mais ne renvoient pas de valeur. Une procédure Sub accepte des arguments (constantes, variables ou expressions passées par une procédure appelante). Si une procédure Sub n'a pas d'arguments, son instruction Sub doit inclure des parenthèses ouvrante et fermante vides.

Une procédure Function est similaire à une procédure Sub, mais elle peut également renvoyer une valeur. Elle peut accepter des arguments (constantes, variables, ou expressions qui lui sont passées par une procédure d'appel). Si elle n'a pas d'arguments, son instruction Function doit inclure des parenthèses ouvrante et fermante vides. Elle renvoie une valeur en affectant une valeur à son nom dans une ou plusieurs instructions de la procédure. Les données renvoyées sont toujours de type Variant. Exemple :

Sub ConvertTemp()

     temp = InputBox("Veuillez entrer la température en degrés F.", 1)

     MsgBox "La température est égale à " & Celsius(temp) & " degrés C."

 End Sub

 Function Celsius(fDegrees)

     Celsius = (fDegrees - 32) * 5 / 9

 End Function

Chaque élément de données est passé dans les procédures au moyen d'un argument. Les arguments servent d'espaces réservés pour les données à passer. Lorsque vous créez une procédure utilisant les instructions Sub ou Function, des parenthèses doivent apparaître après le nom de la procédure. Les éventuels arguments sont placés à l'intérieur de ces parenthèses, séparés par des virgules.

Pour utiliser une procédure Function dans du code, celle-ci doit toujours se trouver à droite d'une affectation de variable ou dans une expression. Par exemple:

 Temp = Celsius(fDegrees)

ou

 MsgBox "La température Celsius est égale à " & Celsius(fDegrees) & " degrés."

Pour appeler une procédure Sub à partir d'une autre procédure, il suffit de taper le nom de la procédure avec les valeurs des arguments requis séparées par des virgules. L'instruction Call n'est pas obligatoire, mais si vous l'employez, vous devez mettre les éventuels arguments entre parenthèses. Exemple :

Call MyProc(firstarg, secondarg)

 MyProc firstarg, secondarg

1.1.7        Caractéristiques de VBScript

1.1.8        Principaux objets prédéfinis

1.1.8.1     Dictionary, objet

Un objet Dictionary est l'équivalent d'un tableau associatif PERL. Les éléments, pouvant correspondre à n'importe quelle forme de données, sont stockés dans le tableau. Chaque élément est associé à une clé qui lui est propre. La clé est utilisée pour extraire un élément individuel et correspond généralement à un nombre entier ou à une chaîne, mais peut être n'importe quelle information à l'exception d'un tableau.

Le code suivant illustre la création d'un objet Dictionary:

Dim d                    'Crée une variable

Set d = CreateObject("Scripting.Dictionary")

d.Add "a", "Athènes"     'Ajoute des clés et des éléments

d.Add "b", "Belgrade"

d.Add "c", "Le Caire"

...

1.1.8.2     TextStream, objet

TextStream.{property | method}

Les éléments property et method peuvent correspondre à n'importe quelles propriétés et méthodes associées à l'objet TextStream. Notez qu'en utilisation réelle, l'objet TextStream est remplacé par un espace réservé de variable représentant l'objet TextStream renvoyé par l'objet FileSystemObject.

Dans le code suivant, a correspond à l'objet TextStream renvoyé par la méthode CreateTextFile sur l'objet FileSystemObject:

Set fs = CreateOject("Scripting.FileSystemObject")

Set a = fs.CreateTextFile("c:\testfile.txt", True)

a.WriteLine("Ceci est un essai.")

a.Close

WriteLine et Close sont deux méthodes de l'objet TextStream.

1.1.8.3     FileSystemObject, objet

Deux méthodes permettent l'emploi de l'objet FileSystemObject; l'une pour créer un fichier texte, l'autre pour ouvrir un fichier texte. Le code suivant illustre comment l'objet FileSystemObject est employé pour renvoyer un objet TextStream pouvant être lu, ou dans lequel il est possible d'écrire des informations:

Set fs = CreateObject("Scripting.FileSystemObject")

Set a = fs.CreateTextFile("c:\testfile.txt", True)

a.WriteLine("Ceci est un essai.")

a.Close

Dans le code ci-dessus, la fonction CreateObject renvoie l'objet FileSystemObject (fs). La méthode CreateTextFile crée ensuite le fichier sous forme d'objet TextStream (a) et la méthode WriteLine écrit une ligne de texte dans le fichier texte créé. La méthode Close purge le tampon et ferme le fichier.