L'Altruiste : Le guide des langages Web

Le langage VBScript est une adaptation pour le Web, du célèbre langage de Microsoft, Visual Basic.

Le VBScript est un langage de script simplifié et orienté objet dont la syntaxe est basée sur celle du Visual Basic pour application. Il est possible de créer des classes avec leurs propres propriétés et méthodes.

Les programmes VBScript sont, la pluart du temps, directement insérés au sein du code HTML dans les pages ou peuvent être écrits dans un fichier spécifique portant l'extension .vbs.

VBScript est en général utilisé avec d'autres composants tels que ceux de la référence d'exécution Scripting, de l'objet FileSystemObject, d'ActiveX, les composants COM (Components Object Model), etc, afin de rendre un site Web dynamique et interactif.

La technologie ASP (Active Server Pages) s'appuie en général sur les programmes VBScript pour créer de véritables applications Web implémentées du côté serveur.

Ce langage est particulièrement adapté à l'élaboration de sites professionnels tournés vers l'e-commerce notamment.

L'implémentation du code VBScript peut s'effectuer du côté serveur comme du côté client. Cependant, des scripts devant être interpétés par le navigateur du client, risque de se heurter à des risques d'incompatibilités.

Enfin, les programmeurs avertis ne ressentiront guère de difficultés à se familiariser à ce langage et les débutants devraient par une bonne connaissance des bases de la programmation Internet et certainement par un bon investissement personnel, réussir à rapidement maîtriser cet outil.

Travailler sur la technologie VBScript, il est nécessaire de disposer d'un environnment de développement approprié.

Dans un premier temps, le système d'exploitation de prédilection du VBScript est évidemment Microsoft Windows dans l'une des versions :

• Windows 95,
• Windows 98,
• Windows Millenium,
• Windows XP,
• Windows NT 4.0,
• Windows 2000.

Ensuite, un serveur Internet spécifique à chaque système d'exploitation doit être installé et configuré proprement.

• PWS (Personal Web Server) sur Windows 95, 98, Millenium et XP,
• Services d'administration Web sur NT 4.0 Workstation ou Windows 2000 Professional,
• IIS 4.0 (Internet Information Server) sur NT 4.0 Server,
• IIS 5.0 sur NT 2000 Server.

L'installation d'un système de base de données est également souhaitable. Il est possible d'utiliser un logiciel comme Access ou SQL Server, mais également d'autres comme Oracle ou MySQL peuvent constituer une alternative intéressante.

Enfin, bien qu'un éditeur de texte conventionnel soit suffisant pour rédiger des pages VBScript, il est préférable pour des travaux plus ambitieux, d'employer des éditeurs spécialisés tels que :

• Visual Basic édité par Microsoft,
• Visual InterDev édité par Microsoft,
• Dreamweaver édité par Macromedia,
• FrontPage édité par Microsoft,
• WebExpert édité par Visicom.

Les scripts écrits en VBScript doivent être intégrés dans une page HTML par le biais d'un balisage spécifique.

<!-- Insertion de scripts VBScript -->
<script language="VBScript" 
              type="text/vbscript"
              runat="server">
  Script...
</script>

Ce couple de balises est également une alternative plus simple et plus rapide :

<%
  Script...
%>

En entête de page, on peut également utiliser la balise suivante afin d'indiquer le langage de script par défaut au serveur.

<%@ LANGUAGE="VBScript"%>

Des résultats de fonctions ou de variables peuvent être directement insérés au sein d'un balisage HTML d'une page Web par l'intermédiaire de la construction suivante :

<%= variable%>
Rem Insère le résultat de la fonction calcul()
Rem au sein d'une cellule td d'un tableau.
...
<td><%= calcul()%></td>
...

Toutes les pages HTML comportant ces balisages précités, doivent porter l'extension .asp afin que le serveur puisse traiter correctement l'ensemble des scripts VBScript.

Le langage Visual Basic Script possède un seul type de variable dénommé Variant.

Dim Variable ' Variable est de type Variant

Dans VBScript, les variables ont la possiblité de recevoir n'importe quel genre de données, comme des nombres entiers ou à virgule flottante, une chaîne de caractères ou encore une valeur logique.

' Variable de sous-type String
Variable = "Chaîne de caractères"
' Variable de sous-type Integer
Variable = 50
' Variable de sous-type Boolean
Variable = True

C'est pourquoi, le type Variant peut contenir diverses valeurs de variables appelées les sous-types de variables.

Le langage VBScript comprend cinq mots-clés permettant d'affecter des valeurs spéciales aux variables d'un programme.

Le mot-clé Empty signale que la valeur d'une variable n'est pas encore initialisé.

variable = Empty

Le mot-clé Null signifie qu'une variable ne contient pas de valeur valide.

variable = Null

Le mot-clé True représente la valeur binaire 1.

variable = True

Le mot-clé False représente la valeur binaire 0.

variable = False

Les mots-clés précités peuvent être également utilisés dans des expressions conditionnelles comme dans l'exemple ci-dessous.

If variable <> Null Then
  ' Instructions...
End if

Le mot-clé Nothing indique qu'une variable objet est en fin d'utilisation, et partant, libère l'espace mémoire qui lui était alloué.

Set variable_objet = Nothing

<html>
  <body>
    <%
      Dim objet

      ' Création de l'objet
      Set objet = Server.CreateObject("MSWC.AdRotator")

      Response.Write objet.GetAdvertisement("liste.txt")

      ' Destruction de l'objet
      Set objet = Nothing
    %>
  </body>
</html>

Le VBScript possède plusieurs types d'opérateurs permettant d'accomplir de nombreuses tâches à l'intérieur des expressions comme des comparaisons, des multiplications, de la concaténation, etc..

Un jeu complet d'opérateurs autorisent de multiples combinaisons d'expressions.

Un opérateur d'affectation assigne la valeur de l'opérande gauche basée sur la valeur de l'opérande droite.

L'opérateur d'affectation de base est le signe d'égalité (=), qui assigne la valeur de son opérande droite à son opérande gauche. C'est-à-dire, droit = gauche assigne la valeur de gauche à droit.

variable = valeur

Les exemples ci-dessous, montrent le mécanisme d'affectation de valeurs aux variables.

x = 10
y = 12

x = y
'retourne x = 12

Les opérateurs arithmétiques prennent des valeurs numériques (des littéraux ou des variables) comme leurs opérandes et renvoient une valeur numérique.

Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).

Les opérateurs logiques sont typiquement utilisés pour comparer des expressions ou des nombres et retournent en résultat des valeurs booléennes.

Un autre opérateur Imp permet d'effectuer une implication logique entre deux expressions.

resultat = expression1 Imp expression2

La comparaison obéit à une logique citée dans le tableau ci-dessous.

L'opérateur Imp effectue une comparaison binaire des bits de position identique dans deux expressions numériques et définit le bit correspondant en retour.

Ce type d'opérateur compare ses opérandes et renvoie une valeur logique en fonction du résultat. Si la comparaison est vraie, la valeur logique true est retournée.

Les opérandes peuvent être des valeurs numériques ou des chaînes de caractères.

Un opérateur spécial Is permet de comparer deux variables de référence à un objet.

resultat = objet1 Is objet2

Si la comparaison révèle que les deux objets font références au même objet alors le résultat est égal à True, sinon False.

x = a
y = a
resultat = x Is y
'resultat est égal à True

En plus des opérateurs de comparaison, qui peuvent être utilisés sur des valeurs de chaîne de caractères, l'opérateur d'enchaînement & permet d'enchaîner deux valeurs de chaîne de caractères ensemble, en renvoyant une autre qui est le résultat de la concaténation des deux opérandes.

L'opérateur d'affectation + peut également être utilisé pour enchaîner des chaînes de caractères. Mais cet opérateur pourrait être ambigu du fait de sa fonction initiale, c'est-à-dire l'addition sur des nombres.

"mon" & "programme" 'retourne "mon programme"
texte = "Un programme"
texte_2 = "VBScript"
resultat = texte & texte_2 'retourne "Un programme VBScript"

La priorité des opérateurs détermine l'ordre qui leur est appliqué lors de l'évaluation d'une expression.

Toutefois, il est possible d'ignorer la priorité des opérateurs en utilisant des parenthèses.

Lorsque des expressions sont composées d'opérateurs de différentes catégories, les opérateurs arithmétiques sont évalués en premier, suivi de l'opérateur de concaténation, puis les opérateurs de comparaison et enfin les opérateurs logiques.

Les opérateurs arithmétiques sont évalués dans l'ordre de priorité décrit par le tableau suivant :

L'opérateur de concaténation est évalué avant les opérateurs de comparaisons.

Les opérateurs de comparaison possèdent tous une priorité identique.
Cependant, les opérateurs les plus à gauche dans une expression, détiennent une priorité plus élevé.

Les opérateurs logiques sont évalués dans l'ordre de priorité décrit par le tableau suivant :

Dans le cas ci-dessous, une première évaluation accomplit le calcul 10 + x puis, une seconde effectue la division entre y et 10 + x et enfin la dernière affecte à x le résultat des deux premières évaluations.

x = y / 10 + x

Dans ce second exemple, la multiplication 2 * x et la division y / 4 sont calculés au préalable, ensuite la comparaison <= est exécuteée afin d'évaluer z par rapport à 2 * x ou (Or) y / 4.

z <= 2 * x Or y / 4

Les constantes prédéfinies dans Visual Basic Script permettent d'apporter une meilleure efficacité dans l'utilisation de valeurs pour les variables, ainsi qu'une plus grande lisibilité du code.

Il est nécessaire de déclarer explicitement certaines constantes (attributs de fichiers et entrée/sortie), avant de les utiliser au sein d'un programme VBScript.

Les constantes de couleurs, de comparaisons, de date et heure, d'erreur, de chaînes de caractères, de boîte de dialogue, trois-états et de types de variables sont quant à elles définies par défaut dans le langage VBScript. Elles peuvent être utilisées directement au sein du code, sans qu'il soit nécessaire de les déclarer.

Les constantes 3-états peuvent être utilisées n'importe où dans un programme VBScript.

Les constantes d'attributs de fichiers peuvent être utilisées n'importe où dans un programme VBScript ou JScript.

Les constantes chaînes de caractères peuvent être utilisées n'importe où dans un programme VBScript.

Les constantes de couleur peuvent être utilisées n'importe où dans un programme VBScript.

Les constantes de comparaison peuvent être utilisées n'importe où dans un programme VBScript.

Les constantes date/heure peuvent être utilisées n'importe où dans un programme VBScript.

Les constantes de dossiers spéciaux peuvent être utilisées n'importe où dans un programme VBScript ou JScript.

Les constantes d'entrée/sortie de fichiers peuvent être utilisées n'importe où dans un programme VBScript ou JScript.

La constante d'erreur peut être utilisée n'importe où dans un programme VBScript.

Err.Raise Number = vbObjectError + 1000

Les constantes de format date/heure peuvent être utilisées n'importe où dans un programme VBScript.

Toutes ces constantes dépendent pour leur fonctionnement des paramètres systèmes de la station cliente.

Les identificateurs de langues sont utilisés en tant qu'argument dans la fonction SetLocale(ID) ou retournés par la fonction GetLocale().

Ils permettent donc de modifier les paramètres régionaux ou d'obtenir des informations sur ces-derniers.

Les constantes des boîtes de messages (msgbox) peuvent être utilisées n'importe où dans un programme VBScript.

La plupart des constantes de boîtes de messages affichent dans celles-ci, divers boutons de commandes ou icônes d'information.

D'autres constantes sont utilisées avec la fonction MsgBox afin d'identifier le bouton sur lequel l'utilisateur a cliqué.

Les constantes de types de variable peuvent être utilisées n'importe où dans un programme VBScript.

Les erreurs d'exécutions interviennent lorsqu'un script Visual Basic Script entreprend une action que le système n'est pas capable de supporter.

Les erreurs de syntaxes interviennent lorsqu'un script Visual Basic Script tente de s'exécuter alors qu'il comporte des anomalies grammaticales, en fait une construction anormale des instrructions.

Les fonctions prédéfines dans Visual basic Script s'acquittent de multiples tâches dans des programmes.

Les fonctions sont ici classées par domaine d'emploi.

Nb_décimal indique un nombre de positions à affichées après la partie décimale.

Affiche_zéro indique si un zéro non significatif s'affiche pour les valeurs décimales.

Négatif_parenthèse indique s'il faut mettre les valeurs négatives entre parenthèses.

Séparateur_groupe indique le type de séparateur de groupe qu'il faut utiliser.

Les arguments Affiche_zéro, Négatif_parenthèse et Séparateur_groupe peuvent prendre les valeurs constantes 3-états.

Format indique par une valeur numérique le format d'affichage de la date et de l'heure.

Départ spécifie la position de départ, par défaut le début de la chaîne.

Comparaison indique une comparaison binaire par défaut, soit 0 ou vbBinaryCompare, ou bien une comparaison textuelle, soit 1 ou vbTextCompare.

Délimiteur est un caractère de chaîne utilisé pour séparer des sous-chaînes dans la chaîne retournée, l'espace étant le caractère par défaut. Si la valeur est une chaîne de longueur nulle, alors tous les éléments de la liste sont concaténés sans séparateurs.

Intervalle est une chaîne de caractères correspondant à un intervalle à utiliser pour calculer la différence entre deux dates.

Premier_jour_semaine est une constante indiquant le premier jour de la semaine, par défaut Dimanche.

Premier_jour_année est une constante indiquant le premier semaine de l'année incluant le premier janvier.

Abréviation indique par une valeur booléenne si le nom du jour de la semaine doit être abrégé, par défaut False (non-abrégé).

Inclure est une valeur booléenne indiquant s'il faut renvoyer des sous-chaînes incluant ou excluant l'argument Chaîne_recherche.
Si la valeur est True, un sous-ensemble du tableau contenant l'argument Chaîne_recherche comme sous-chaîne est retourné.
Si la valeur est False, un sous-ensemble du tableau ne contenant pas l'argument Chaîne_recherche comme sous-chaîne est retourné.

Comparaison indique une comparaison binaire par défaut, soit 0 ou vbBinaryCompare, ou bien une comparaison textuelle, soit 1 ou vbTextCompare.

Prompt est une chaîne d'une taille maximum de 1024 caractères, qui est affichée sous la forme d'un message dans la boîte de dialogue. La longueur maximum de l'argument prompt est environ 1024 caractères, selon la largeur des caractères utilisés. Il est possible d'utiliser le retour chariot (Chr(13)), le retour à la ligne (Chr(10)) ou une combinaison des deux lorsque le chaîne de caractère doit s'étendre sur plusieurs lignes.

Titre est une chaîne de caractères destinée à être affichée dans la barre de titre de la boîte de dialogue.

Texte_défaut est une chaîne de caractères destinée à être affichée dans la zone de texte comme la réponse par défaut si aucune autre entrée n'est fournie.

Position_X représente la distance horizontale entre le bord gauche de la boîte de dialogue et le bord gauche de l'écran. Par défaut, la boîte est centrée horizontalement.

Position_Y représente la distance verticale entre le bord supérieur de la boîte de dialogue et le haut de l'écran. Par défaut, la boîte est centrée verticalement

Fichier_Aide est une chaîne de caractères destinée à être utilisé pour fournir l'aide contextuelle de la boîte de dialogue.

Contexte est une valeur numérique identifiant le numéro de contexte de l'aide affecté par l'auteur de l'Aide à la rubrique d'aide correspondante.

Bouton est une valeur numérique ou une constante de message de boîtes spécifiant le nombre et le type de boutons à afficher, le style d'icône à utiliser, l'identité du bouton par défaut et la modalité du message.

Les instructions dans le langage VBScript permettent d'accomplir de nombreuses tâches dans un programme.

Celles-ci peuvent être des boucles (Do...Loop, For...To, etc.), des branchements conditionnels (If...Then...Else ou Select Case), de gérer des erreurs (On Error), d'appeler des fonctions (Call), de déclarer des variables (Dim, Private ou Public), ou encore de créer des classes (Class), des propriétés (Property), des fonctions (Function) des procédures (Sub), etc..

Le langage VBScript accepte deux types de commentaires au sein du code.

Les instructions Rem et le caractère apostrophe ' permettent d'insérer des remarques dans un programme, afin de le rendre plus lisible à titre informatif, et à fortiori, pour aider un développeur à effectuer une maintenance.

Rem Commentaire...
  Lignes de code...
' Commentaire...
  Lignes de code...

Un espace blanc doit figuré entre l'instruction et le commentaire.

Les commentaires peuvent être insérés entre des lignes ou en fin de lignes de code, mais jamais au sein d'une instruction.

Lorsqu'une remarque est placée en fin de ligne, l'instruction Rem doit être précédée d'un caractère deux-points (:), en ce qui concerne l'instruction ', il suffit d'introduire un espace blanc de séparation.

Ligne de code : Rem Commentaire
Ligne de code ' Commentaire

Rem Déclaration de variables
Dim X
Dim Y
Dim Z
' Affectations
X = 12 ' X vaut 12
Y = 2 : Rem Y vaut 2
Rem Z vaut 144
Z = X ^ Y ' Mise à la puissance

La déclaration des variables peut s'effectuer par l'intermédiaire de plusieurs instructions dans un programme VBScript.

L'instruction Option Explicit contraint à déclarer explicitement toutes les variables dans un script.

Option Explicit

Cette instruction doit obligatoirement se placer au sommet d'une page d'un programme VBScript.

L'instruction Dim déclare des variables dans l'espace de nom d'un script, dans des fonctions ou procédures et également dans des propriétés (Property).

Elles seront disponible à l'intérieur de l'espace de nom dans lequel elles auront été spécifiées.

Dim nom_variable[(Indices)]

L'instruction Private déclare les variables privées dans l'espace de nom d'un script ou dans une propriété (Property).

Elles seront essentiellement disponibles dans les procédures, les fonctions, et dans le script lui-même, ou dans des propriétés.

Private nom_variable[(Indices)]

L'instruction Public déclare des variables publiques dans l'espace de nom global d'un script ou dans des propriétés (Property).

Elles pourront être utilisées dans l'ensemble d'une application VBScript.

Public nom_variable[(Indices)]

(Indices) indique la création d'un tableau d'une à soixante dimensions. Ces dernières sont des nombres entiers séparées par des virgules.

Dim tableau(10,10,10)

Cet exemple, a créé une variable appelée tableau possédant trois dimensions de 10 cellules.

<html>
  <body>
    <%
      ' Variable valable dans toutes les procédures
      ' et fonctions ainsi que dans tous les scripts.
      Public variable_public

      ' Variable valable uniquement dans ce script et
      ' dans toutes les procédures et fonctions.
      Private variable_privee

      ' Affectation des variables
      variable_public = 10
      variable_privee = 6

      Public Function Multiplication

        ' Variable déclarée dans la portée locale d'une fonction.
        Dim resultat
        resultat = variable_public * variable_privee
        Response.write resultat
      End Function

      Public Function Division

        ' Variable déclarée dans la portée locale d'une fonction.
        Dim resultat

        ' Réaffectation de variables dans la portée locale d'une fonction.
        variable_public = 12
        variable_privee = 4
        resultat = variable_public / variable_privee
        Response.write resultat
      End Function

      Response.Write "Le résultat de la multiplication est : " _
                     & variable_public & " * " & variable_privee _
                     & " = " 
      Call Multiplication()

      Response.Write "<br>Le résultat de la division est : " _
                     & variable_public & " / " & variable_privee _
                     & " = "
      Call Division()

    %>
  </body>
</html>

Les instructions Erase et ReDim sont utilisées pour gérer les tableaux.

L'instruction Erase permet de supprimer les éléments des tableaux de taille fixe et libère l'espace de stockage des tableaux dynamiques.

Erase Nom_tableau

Nom_tableau représente le tableau auquel les éléments seront supprimés.

L'instruction ReDim permet de redimensionner l'espace de stockage des tableaux dynamiques.

ReDim [Preserve] Nom_tableau(Dimensions)

Preserve active la préservation des éléments d'un tableau tout en le redimensionnant.

Nom_tableau représente la variable de type tableau.

Dimensions consite en une énumération d'une ou plusieurs dimensions du tableau concernée, séparées par une virgule.

Un tableau dynamique est déclaré initialement sans aucun indice de dimension, par l'intermédiaire des instructions Private, Public ou Dim.

Private | Public | Dim Nom_tableau

' Déclaration d'un tableau dynamique
Dim tableau
' Redimensionnement sur trois dimensions du tableau
ReDim tableau(10, 10, 10)
' Réinitialisation du tableau
Erase tableau

Lorsqu'il est nécessaire d'assigner plusieurs valeurs à une unique variable, alors il faut utiliser un tableau. Un tableau est une variable capable de contenir N valeurs, N étant la taille de ce tableau.

Les tableaux sont créés à l'instar des variables simples, en utilisant une instruction Dim précédant la déclaration de la variable suivie elle même d'un nombre entouré de parenthèses.

Dim tableau(10)

Cette déclaration indique à l'interpréteur, qu'une variable est un tableau composé de onze cellules. En effet, un tableau commence à zéro et se termine au nombre indiqué.

L'affectation de valeurs au sein d'un tableau, s'effectue par le biais de la variable suivi du numéro d'indice de la cellule à affecter.

tableau(indice) = valeur

tableau(0) = 10;
tableau(1) = 18;
...
tableau(10) = 9;

La valeur d'une cellule de tableau s'obtient de la même manière que l'affectation. Il est possible de réaffecter le contenu d'une cellule à une autre variable, de l'afficher ou encore d'effectuer un calcul.

Dim nombre = tableau(0);

Dim nombre = tableau(0) * 2

<%=tableau(0)%> 
'Affichage dans la page web courante

Un tableau peut contenir plusieurs dimensions. Ainsi, une variable peut être organisée en lignes et en colonnes (tableau à deux dimension). Si on ajoute une profondeur, on obtient un tableau tridimensionnel.

La déclaration de tableaux multidimensionnels sont identiques aux tableaux unidimensionnels, à l'exception que les parenthèses contiennent autant de nombres que de dimensions. Ces nombres doivent être séparés par des virgules.

Dim tableau(10, 20)

Dim tableau(10, 10, 10)

La fonction UBound() fournit le plus grand indice du tableau passé en argument.

Dim tableau(30)
Response.Write(UBound(tableau)
'La fonction Write affiche 30

Il faut donc être vigilant en utilisant cette fonction puisque la taille réelle du tableau est supérieure de un élément.

Les tableaux peuvent changer de taille durant l'exécution d'un script. La commande ReDim permet de redéfinir la taille d'un tableau.

Redim tableau(20)

Le redimensionnement d'un tableau s'accompagne de la perte de toutes les données qu'il contenait. C'est pourquoi, le mot clé Preserve permet d'éviter une redéfinition complète d'un tableau en conservant les données existantes.

Redim Preserve tableau(20)

L'instruction Erase supprime le contenu de toutes les cellules d'un tableau et libère les resources qui lui été affectée.

Erase tableau

Il existe des artifices permettant d'affecter ou de consulter un tableau à l'aide de boucles, évitant ainsi la fastidieuse opération d'affectation ou de consultation manuelle d'un tableau. La boucle For To...Next réalise parfaitement le parcours complet d'un tableau.

For i = 0 To UBound(tableau) + 1 Step 1
    tableau(i) = i + 1
    Response.Write(i & " : " & tableau(i))
Next
'Affiche :

i : 1

i : 2

i : 3

...

i : 11

L'instruction Const permet de déclarer des constantes destinées à se substituer à des valeurs de variables.

Public | Private Const Nom = Valeur

Nom représente le nom de la constante.

Valeur peut être aussi bien une valeur littérale comme une chaîne de caractères ou un nombre, qu'une expression combinant n'importe quels opérateurs, hormis Is.

Les variables ou les fonctions ne peuvent être utilisées dans les valeurs de constantes, puisque par définition les constantes sont fixes, et les variables sont fluctuantes.

Enfin, les constantes peuvent être utilisées partout dans le code.

Private Const ma-couleur = "#EC33D5"

Public Const message_erreur = "Désolé, vous venez d'être 
                                                   confronté à un problème !"

Const euro = 6.55957

Const taux_conversion = 1 / euro

L'instruction Randomize permet d'initialiser le générateur de nombre aléatoire de la fonction Rnd()

Randomize [Nombre]

Nombre peut être une valeur numérique quelconque. La valeur de l'horloge du système est employée par défaut

<html>
  <body>
    <%
      Dim resultat, condition

      Rem Initialisation du générateur de nombres aléatoires.
      Randomize

        ' Génération d'une valeur aléatoire comprise entre 1 et 18.
        resultat = Int((100 * Rnd) + 1)

        Response.Write "Le résultat est : <b>" & resultat & "</b>"
  %>
    <br>
    <a href="coursasp/exemples/randomize.asp">
      Recommencer
    </a>
  </body>
</html>

L'instruction Do...Loop répète un bloc d'instructions tant qu'une condition est vraie (While) ou jusqu'à ce qu'une condition devienne vraie (Until).

Do while|Until Condition
  ' Instructions...
Loop

Do
  ' Instructions...
While|Until Condition

Dans cette boucle, la condition peut être placée soit au début de la boucle, soit à la fin. Dans ce dernier cas, un cycle sera exécuté quelque soit l'état de la condition de la boucle.

<html>
  <body>
    <%
      Public x
      Public i
      x = 0
      i = 0

      Response.Write "<u>Boucle Do While...Loop</u><br>Comptage :<br>"

      ' Boucle faire tant que x est inférieur ou égal à 10.
      Do While x <= 10
        Response.Write x & "<br>"
        x = x + 1
      Loop

      Response.Write "<u>Boucle Do...Loop While</u><br>Comptage :<br>"

      ' Boucle identique avec la condition en fin de boucle.
      Do
        Response.Write x
        x = x + 1
      Loop While x <= 10
    %>
  <body>
<html>

L'instruction While...Wend répète des instructions tant que la condition spécifiée est vraie (True).

While Condition
  ' Instructions...
Wend

Cette boucle signifie tant que (while) la condition est vraie, les instructions avant la fin de la boucle (Wend) sont exécutées.

<html>
  <body>
    <%
      Dim phrase(9), i
      phrase(0) = "Ce"
      phrase(1) = "texte"
      phrase(2) = "contient"
      phrase(3) = "un"
      phrase(4) = "mot"
      phrase(5) = "qui"
      phrase(6) = "doit"
      phrase(7) = "être"
      phrase(8) = "trouvé"
      recherche = "être"
      i = 0

      while trouve = False

        If phrase(i) = recherche Then
          Response.Write "Le verbe <b>" & recherche & "</b> a été trouvé" _
                               & " à la position n° <b>" & i & "</b>" _
                               & " au sein de la phrase suivante :<br>"

          For i = 0 To 7 Step 1
            Response.Write phrase(i) & " "
          Next

          Response.Write phrase(8) & ". "
          trouve = True
        End If

        i = i + 1

      Wend
    %>
  <body>
<html>

L'instruction For...Next exécute des boucles par rapport à un comptage délimité par un début et une fin.

For Compteur=Début To Fin [Step Pas]
  ' Instructions...
Next

La traduction d'une telle commande peut être : pour (For) le compteur à une condition de début jusqu'à (To) une condition de fin selon un certain pas (Step), exécuter les instructions de la boucle.

L'instruction For...Next incrémente automatiquement le compteur, ainsi il n'est pas utile de placer une commande d'incrémentation comme i = i + 1.

<html>
  <body>
    <%
      ' Déclaration des variables, un tableau et deux incréments
      Dim jour(7), i, j
      jour(0) = "Lundi"
      jour(1) = "Mardi"
      jour(2) = "Mercredi"
      jour(3) = "Jeudi"
      jour(4) = "Vendredi"
      jour(5) = "Samedi"
      jour(6) = "Dimanche"
      j = 0

      ' Boucle comptabilisant les jours du mois
      For i = 1 To 31 Step 1

        ' Réinitialise au septième jour de la semaine
        If j = 5 Then
          j = -2
        End If

        Response.Write jour(j + 2) & " " & i & " janvier 2002
"

        ' Incrémentation de i et de j
        j = j + 1
      Next
    %>
  <body>
<html>

L'instruction For Each...Next parcourt tous les éléments d'un tableau ou d'une collection afin d'appliquer à chacun un traitement défini par une séries d'instructions.

For Each Elément In Groupe
  ' Instructions...
Next [Elément]

Elément est le nom d'une variable contenue dans un groupe. Cette variable peut être du type Variant, Objet générique ou Objet Automation pour les collections et seulement Variant pour les tableaux.

Groupe représente un conteneur d'éléments comme un tableau ou un collection.

<% response.expires = "-1" %>
<html>
  <body>
    <% 
      Dim dossier, chemin, dossier_parent 
      Set ObjSystemeFichier = Server.CreateObject("Scripting.FileSystemObject")
      dossier = Request.QueryString("dossier") 
      chemin = Server.MapPath(dossier&"/") 
      set objet_dossier = ObjSystemeFichier.getFolder(chemin) 
    %>
      <table border="0" align="center">
    <%
      if dossier <> "" Then 
        dossier_parent = Left(dossier, inStrRev(dossier, "/")-1)
    %>
      <tr>
        <th colspan="2">
          <a href="exemple.asp?dossier=<%=dossier_parent%>"
             title ="Retour au répertoire parent">
            ../
          </a>
        </th>
      </tr>
    <% end if %> 
      <tr>
        <th colspan="2"><h2><%=objet_dossier.Name%></h2></th>
      </tr>
      <tr>
        <th colspan="2">Dossiers</th>
      </tr>
    <%
      for each sousDossier in objet_dossier.SubFolders
    %>

      <tr>
        <td width="12"> </td>
        <td>
          <a href="exemple.asp?dossier= _
                                  <%=dossier&"/"&sousDossier.Name%>">
            <%=SousDossier.Name%>
          </a>
        </td>
      </tr>
  <% next %>
      <tr>
        <th colspan="2">Fichiers</th>
      </tr>
  <%
      for each Fichier in objet_dossier.Files
  %>
      <tr>
        <td width="12"> </td>
        <td>
          <a href="<%=dossier&"/"&Fichier.Name%>">
            <%=Fichier.Name%>
          </a>
        </td>
      </tr>
    <%
      next
      Set ObjSystemeFichier = Nothing
      Set objet_dossier = Nothing
    %> 
      </table>
  </body>
</html>

L'instruction If Then Else est une commande de contrôle qui provoque un branchement conditionnel.

If Condition Then
  ' Instructions...
Else If Seconde_Condition
  ' Instructions...
Else
  ' Instructions...
End If

En fait, cette instruction signifie : si (If) une condition est vérifiée alors (Then) des instructions seront exécutées, sinon (Else) d'autres le seront.

Cette instruction peut également supporter des conditions multiples par l'intermédiaire de la commande ElseIf comportant sa propre condition.

L'instruction Select Case est en général plus adaptée à plusieurs cas possibles de branchement conditionnel.

<html>
  <head>
    <script language="VBScript" type="text/vbscript"> 
    <!--
      Sub validation
        Dim doc, valeur
        Set doc = Document.forms("formulaire")
        valeur = doc.age.Value
        If IsNumeric() Then
          If valeur < 3 Then
            MsgBox "Vous ne pouvez avoir moins de 3 ans !chr(13) " _
                          & "Veuillez entrer un âge valide, s'il vous plaît."
          ElseIf valeur > 125 Then
            MsgBox "Vous ne pouvez avoir plus de 125 ans !chr(13) " _
                          & "Veuillez entrer un âge valide, s'il vous plaît."
          Else
            MsgBox "Merci."
          End If
        Else
          MsgBox "Veuillez entrer une valeur numérique seule !chr(13) Merci !"
        End If
      End Sub
    -->
    </script>
  </head>
  <body>
    <p>Veuillez saisir votre âge :</p>
    <form id="formulaire" 
               action="selectcase.asp"
               onsubmit="validation(); return false;"
               language="jscript">
      <input name="age" type="text" size="4">
      <input name="Valider" type="submit" value="Valider">
    </form>
  </body>
</html>

L'instruction Select Case est une structure de choix, proposant de multiples possibilités de branchement conditionnel.

Select Case Variable
  Case Condition
    ' Instructions...
   Case Seconde_Condition
     ' Instructions...
   Case Troisième_Condition
     ' Instructions...
   ...
   Case Else
     ' Instructions...
End Select

En fait, cette instruction signifie : exécuter un bloc d'instructions selon le cas (case) correspondant à la valeur de la variable test.

Variable est en fait une expression de chaîne de caractères ou numérique contenant une valeur a tester par rapport à chacun des cas spécifiés.

La dernière commande Case Else détermine le dernier cas possible si aucune des conditions précédentes ne convenait.

<html>
  <head>
    <script language="VBScript" type="text/vbscript"> 
    <!--
      Sub validation
        Dim doc
        Dim valeur
        Set doc = Document.forms("formulaire")
        valeur = doc.age.Value
        If IsNumeric(valeur) Then
          Select Case valeur
            Case 1
              MsgBox "Vous êtes encore un bébé !"
            Case 7
              MsgBox "Vous avez atteint l'âge de raison."
            Case 10
              MsgBox "La première dixaine !"
            Case 15
              MsgBox "Les années lycées commencent !"
            Case 18
              MsgBox "Vous avez la majorité, enfin !"
            Case 25
              MsgBox "Vous investissez le marché du travail."
            Case 30
              MsgBox "Vous vous êtes fixés dans votre carrière professionnelle."
            Case 55
              MsgBox "Vous préparez activement la retraite."
            Case 65
              MsgBox "Vous êtes à la retraite."
            Case 75
              MsgBox "Vous profitez pleinement de votre retraite."
            Case 100
              MsgBox "Vous êtes centenaire. Bravo pour cette longévité !"
            Case Else
              MsgBox "Votre âge : " & valeur & " ans"
          End Select
        Else
          MsgBox "Veuillez entrer une valeur numérique seule !" & chr(13) & "Merci !"
        End If
      End Sub
    -->
    </script>
  </head>
  <body>
    <p>Veuillez saisir votre âge :</p>
    <form id="formulaire" 
               action="selectcase.asp"
               onsubmit="validation(); return false;"
               language="jscript">
      <input name="age" type="text" size="4">
      <input name="Valider" type="submit" value="Valider">
    </form>
  </body>
</html>

L'instruction With permet d'appliquer des instructions à un objet spécifié.

With Objet
  ' Instructions...
End With

Objet est le nom d'un objet quelconque ou une fonction qui retourne un objet.

Une telle instruction agit sur un unique objet sans qu'il soit nécessaire de le rappeler pour chaque commandes qu'elle contient. Elle peut être utilisée pour modifier les propriétés d'un objet par exemple.

<html>
  <body>
    <%
      Class livre
        Private titre_livre
        Private prix_livre
        Private commentaire_livre

        Private Sub Class_Initialize
        End Sub

        Private Sub Class_Terminate
        End Sub

        Public Property Let titre(valeur)
          titre_livre = valeur
        End Property

        Public Property Get titre
          titre = titre_livre
        End Property

        Public Property Let commentaire(texte)
          commentaire_livre = texte
        End Property

        Public Property Get commentaire
          commentaire = commentaire_livre
        End Property

        Public Property Let prix(montant)
          prix_livre = FormatNumber(montant,2,-1)
        End Property

        Public Property Get prix
          prix = prix_livre
        End Property

        Public Property Get convFrancsEuro
          convFrancsEuro = FormatNumber(prix_livre * (1 / 6.55957),2)
        End Property

        Public Sub reduction(taux)
          if taux > 5 then
            taux = 5
          End If
          prix_livre = FormatNumber(prix_livre - (prix_livre * taux / 100),2,-1)
        End Sub
      End Class

      Dim objet

      Set objet = New livre

      With objet
        .titre = "ASP 3.0 : Le guide du développeur"
        .commentaire = "Ce livre complet vous permet d'apprendre " _
                   & "la technologie ASP en découvrant tour à tour " _
                   & "le HTML, le VBScript, les composants ASP, l'intégration " _
                   & "des bases de données, l'utilisation des classes, de " _
                   & "Internet Information Server, de Microsoft Transaction " _
                   & "Server, ainsi que des exemples d'applications."
        .prix = 298.00

        Response.Write "<h2>Le livre " & .titre  & "</h2>" _
                    & "<h4>Commentaire :</h4><p>" & .commentaire & "</p>"
        Response.Write "<h4>Prix : " & .prix & " Francs "
        Response.Write "<em style='font-size:10pt'>(" _ 
                          & .convFrancsEuro & " Euro)</em></h4>"
        .reduction 5
        Response.Write "<h4 style='color:green'>Si vous êtes abonnés, " _
                        & "vous bénéficiez d'une réduction de maximum 5%.</h4>"
        Response.Write "<h4>Prix réduit : " & .prix & " Francs</h4>"
      End With

      Set objet = Nothing
    %>
  </body>
</html>

Le langage Visual Basic Script dispose de moyens permettant de créer des procédures ou fonctions pouvant être appelées n'importe où dans un programme par l'instruction Call notamment.

L'instruction Sub permet de déclarer le nom, les arguments et les instructions formant une procédure.

[Public [Default] | Private] Sub Nom_Procédure [(Arguments)]
  ' Instructions...
End Sub

L'instruction Function permet de déclarer le nom, les arguments et les instructions formant une fonction.

[Public [Default] | Private] Function Nom_Fonction [(Arguments)]
  ' Instructions...
End Function

Les fonctions et procédures sont publiques (Public) par défaut, c'est-à-dire disponible dans l'ensemble d'une application VBScript.

Public Default est utilisé pour indiquer que la fonction ou la procédure est utilisée par défaut dans une classe (Class).

Private signifie que la fonction ou la procédure ne sera valable que dans l'espace de nom global du script courant.

Arguments représente une liste d'arguments séparés par des espaces blancs.

Un argument peut être composé selon la construction ci-dessous.

[ByVal | ByRef] nom_argument[( )]

ByVal indique un passage d'argument par valeur.

ByRef indique un passage d'argument par référence, soit l'adresse de la variable concernée.

Il est impossible de créer une fonction (Function) à l'intérieur d'une procédure (Sub) et vice-versa. De même qu'il n'est pas possible d'en créer dans une définition de propriété Property Get.

Une procédure Sub et une fonction Function sont des instructions différentes capables de prendre des arguments, d'exécuter un bloc d'instructions et de modifier la valeur de leurs arguments.

La différence réside dans la faculté d'une fonction de pouvoir être utilisée dans la partie droite d'une expression, celle qui suit le signe égal( =) afin de disposer directement de la valeur retournée par la fonction.

Variable = nom_fonction()

Pour retourner le résultat d'une fonction, il suffit de créer une variable réceptrice du résultat et de lui donner le nom de la fonction.

Function Addition(val1, val2)
  Addition = val1 + val2
End Function

Enfin, les procédures ou les fonctions acceptent des déclarations de variables implicites, ou explicites. Dans ce dernier cas, la variable devra être précédée de l'instruction Dim uniquement.

<html>
  <body>
    <%
      Sub aujourdhui()
        Dim jour_mois, mois, annee, resultat
        date_courante = Date()

        jour_mois = Day(date_courante)
        mois = Month(date_courante)
        annee = Year(date_courante)

        resultat = jour_mois & "/" & mois & "/" & annee
        Response.Write "Date d'aujourd'hui : " & resultat
      End Sub

      Call aujourdhui()
    %>

    <%
    Function modification()
       Dim objFSO
       Dim objFichier

       Set objFSO = Server.CreateObject("Scripting.FileSystemObject")
       Set objFichier = _
               objFSO.GetFile(Request.ServerVariables("PATH_TRANSLATED"))

       modification = objFichier.DateLastModified
       Set objFichier = Nothing
       Set objFSO = Nothing
    End Function

    Dim date_modification
    date_modification = modification()
    Response.Write "Date de dernière modification : " _
                            & Day(date_modification) & " " _
                            & MonthName(Month(date_modification)) _
                            & " " & Year(date_modification)
    %>
  </body>
</html>

L'instruction Call permet d'appeler une fonction ou une procédure pour leur exécution.

Call Fonction(Arguments)

Cette écriture est équivalente à l'appel de fonction suivant :

Fonction Arguments

Fonction représente le nom de la fonction à appeler.

Arguments indique une liste d'arguments séparés par des espaces blancs.

Call Fonction(arg1, arg2,..., argN)

Lorsque Call est utilisé, la liste des arguments doit être impérativement entre des parenthèses, alors que pour un appel simple, l'énumération des arguments n'en nécessite pas.

<html>
  <body>
    <%
      Function AfficheValeur(valeur, monnaie)
        Dim euro
        euro = 6.55957
        ConvFrancsEuro = FormatNumber(valeur / euro, 2)
        ConvEuroFrancs = FormatNumber(valeur * euro, 2)
        If monnaie = "francs" Then
          Response.Write "La somme de " & valeur & " " & monnaie _
                                    & " équivaut à " & ConvFrancsEuro & " euros
"
        ElseIf monnaie = "euros" Then
          Response.Write "La somme de " & valeur & " " & monnaie _
                                    & " équivaut à " & ConvEuroFrancs & " francs
"
        Else
          Response.Write "La monnaie entrée est"_
                                    & " incorrecte ou non gérée !"
        End If
      End Function

      Call AfficheValeur (10, "francs")

      AfficheValeur 100, "euros"
    %>
  </body>
</html>

L'instruction Property permet de déclarer, un nom, des arguments et le code formant une propriété, dans une déclaration de classe créée par la commande Class.

[Public | Private] Property Get | Let | Set Nom_Propriété [(Arguments)]
  ' Instructions...
  [Exit Property]
  ' Instructions...
End Property

La définition dans un espace de nom d'une propriété peut s'effectuer soit dans le domaine privée, c'est-à-dire valable essentiellement au sein de la classe dans laquelle elle a été déclarée, soit dans le domaine privée (par défaut), soit dans tout un programme VBScript.

Nom_Propriété représente le nom de la propriété concernée et (Arguments), sa propre liste d'arguments séparées par des espaces blancs.

Exit Property est une instruction optionnelle permettant de sortir immédiatement de la propriété en cours.

L'instruction Let affecte la valeur de la propriété.

Public Property Let propriete(valeur)
  valeur_propriete = valeur
End Property

L'instruction Property Let peut contenir en son sein des commandes d'affectations Set permettant d'affecter une référence à une propriété.

L'instruction Get obtient la valeur de la propriété.

Public Property Get propriete
  propriete = valeur_propriete
End Property

L'instruction Set définit la référence à un objet.

Public Property Set propriete([arguments,] reference)
  ...
End Property

<html>
  <body>
    <%
      Class livre
        Private titre_livre
        Private prix_livre

        Private Sub Class_Initialize
          Response.Write "<p><i>La classe est initialisée</i></p>"
        End Sub

        Private Sub Class_Terminate
          Response.Write "<p><i>La classe est détruite</i></p>"
        End Sub

        Public Property Let titre(valeur)
          titre_livre = valeur
        End Property

        Public Property Get titre
          titre = titre_livre
        End Property

        Public Property Let prix(montant)
          prix_livre = FormatNumber(montant,2,-1)
        End Property

        Public Property Get prix
          prix = prix_livre
        End Property

        Public Property Get convFrancsEuro
          convFrancsEuro = FormatNumber(prix_livre * (1 / 6.55957),2)
        End Property

        Public Sub reduction(taux)
          if taux > 5 then
            taux = 5
          End If
          prix_livre = FormatNumber(prix_livre - (prix_livre * taux / 100),2,-1)
        End Sub
      End Class

      Dim objet

      Set objet = New livre
      objet.titre = "ASP 3.0 : Le guide du développeur"
      objet.prix = 298.00

      Response.Write "<h2>Le livre " & objet.titre  & "</h2>" _
                           & "<h4>Prix : " & objet.prix & " Francs "
      Response.Write "<em style='font-size:10pt'>(" _ 
                           & objet.convFrancsEuro & " Euro)</em></h4>"
      objet.reduction 5
      Response.Write "<h4 style='color:green'>Si vous êtes abonnés, " 
                           & "vous bénéficiez d'une réduction de maximum 5%.</h4>"
      Response.Write "<h4>Prix réduit : " & objet.prix & " Francs</h4>"
      Set objet = Nothing
    %>
  </body>
</html>

L'instruction Class permet de déclarer le nom d'une classe, et également de définir les variables, les propriétés et les méthodes afférentes à cette classe.

Class Nom
  ' Instructions...
End Class

Nom spécifie l'appellation de la classe.

Instructions représentent n'importe quelles instructions VBScript permettant de définir des variable, propriétés et méthodes appropriées à la création de classes.

<html>
  <body>
    <%
      Class livre
        Private titre_livre
        Private prix_livre

        Private Sub Class_Initialize
          Response.Write "<p><i>La classe est initialisée</i></p>"
        End Sub

        Private Sub Class_Terminate
          Response.Write "<p><i>La classe est détruite</i></p>"
        End Sub

        Public Property Let titre(valeur)
          titre_livre = valeur
        End Property

        Public Property Get titre
          titre = titre_livre
        End Property

        Public Property Let prix(montant)
          prix_livre = FormatNumber(montant,2,-1)
        End Property

        Public Property Get prix
          prix = prix_livre
        End Property

        Public Property Get convFrancsEuro
          convFrancsEuro = FormatNumber(prix_livre * (1 / 6.55957),2)
        End Property

        Public Sub reduction(taux)
          if taux > 5 then
            taux = 5
          End If
          prix_livre = FormatNumber(prix_livre - (prix_livre * taux / 100),2,-1)
        End Sub
      End Class

      Dim objet

      Set objet = New livre
      objet.titre = "ASP 3.0 : Le guide du développeur"
      objet.prix = 298.00

      Response.Write "<h2>Le livre " & objet.titre  & "</h2>" _
                           & "<h4>Prix : " & objet.prix & " Francs "
      Response.Write "<em style='font-size:10pt'>(" _ 
                           & objet.convFrancsEuro & " Euro)</em></h4>"
      objet.reduction 5
      Response.Write "<h4 style='color:green'>Si vous êtes abonnés, " 
                           & "vous bénéficiez d'une réduction de maximum 5%.</h4>"
      Response.Write "<h4>Prix réduit : " & objet.prix & " Francs</h4>"
      Set objet = Nothing
    %>
  </body>
</html>

L'événement Initialize se produit lorsqu'une instance de la classe associée est créée, alors que l'événement Terminate intervient lors de son terme.

Private Sub Class_Initialize()
  'instructions...
End Sub

Private Sub Class_Terminate()
  'instructions...
End Sub

Les deux procédures permettent de capturer leur événement respectif, et subséquemment, d'exécuter les instructions contenues.

Class TestClass
  'Configuration de l'événement Initialize.
  Private Sub Class_Initialize
    MsgBox("Classe_de_test démarré")
  End Sub

  'Configuration de l'événement Terminate.
  Private Sub Class_Terminate
    MsgBox("Classe_de_test terminé")
  End Sub
End Class

'Création d'une instance de Classe_de_test.
Set X = New Classe_de_test
'Destruction de l'instance.
Set X = Nothing

L'instruction Exit permet de sortir des boucles (For, Do), des fonctions (Function), des procédures (Sub) ou propriétés (Property).

For...To
  ' Instructions...
  Exit For
  ' Instructions...
Next

For Each...
  ' Instructions...
  Exit For
  ' Instructions...
Next

Do[...]
  ' Instructions...
  Exit Do
  ' Instructions...
Loop[...]

Function...
  ' Instructions...
  Exit Function
  ' Instructions...
End Function

Sub...
  ' Instructions...
  Exit Sub
  ' Instructions...
End Sub

Property...
  ' Instructions...
  Exit Property
  ' Instructions...
End Property

L'instruction Exit interrompt immédiatement un des éléments précités et provoque la reprise du déroulement du programme immédiatement après la commande de fin, Next, Loop, End....

Dans le cas de boucles imbriquées, la sortie provoque une reprise du programme à partir de la boucle de niveau immédiatement supérieur.

<html>
  <head>
    <script language="VBScript" type="text/vbscript"> 
    <!--
      Sub validation
        Dim i, nombre, choix, doc, j
        i = 1
        Set doc = Document.forms("formulaire")
        choix = doc.valeur.Value
        If choix >= 1 And choix <= 4 Then
          Do While i <= 10
            For j = 1 To 5
              Select Case choix
                Case 1
                  MsgBox "Vous sortez de la boucle For" _
                           & chr(13) & "i = " & i & " et j = " & j
                  Exit For
                Case 2
                  MsgBox "Vous sortez de la boucle Do Loop"
                  Exit Do
                Case 3
                  MsgBox "Vous sortez de la procédure"
                  Exit Sub
                Case 4
                  MsgBox "i = " & i & " et j = " & j
              End Select
            Next
            i = i + 1
          Loop
        Else
          MsgBox "Veuillez entrer une valeur numérique " _
                    & "entre 1 et 4 !" & chr(13) & "Merci !"
        End If
      End Sub
    -->
    </script>
  </head>
  <body>
    <p>Veuillez une des valeurs suivante :</p>
    <ol>
      <li>pour sortir de la boucle For...Next</li>
      <li>pour sortir de la boucle Do...Loop</li>
      <li>pour sortir de la procédure Sub</li>
      <li>pour accomplir les tours de boucles.</li>
    </ol>
    <form id="formulaire"
             action="exit.asp"
             onsubmit="validation(); return false;"
             language="jscript">
      <input name="valeur" type="text" size="3">
      <input name="Valider" type="submit" value="Valider">
    </form>
  </body>
</html>

L'instruction Set permet d'affecter une référence d'objet à une variable ou à une propriété.

Set variable_objet = Expression | New Nom_Classe | Nothing

Expression correspond à un nom d'objet, à une variable comportant un type d'objet identique, ou bien une fonction ou une méthode retournant un même type d'objet.

New Nom_Class initialise une nouvelle classe.

Nothing libère l'espace mémoire de la variable en détruisant notamment, une classe précédemment initialisée.

L'instruction Set peut également associer une référence de procédure à un événement.

Set object.Nom_Evénement = GetRef(Nom_Fonction)

Nom.Evénement représente le nom de l'événement à associée.

Nom_Fonction peut être une fonction ou une procédure déclarée par respectivement Function ou Sub.

<html>
  <body>
    <%
    ' Page hôte affichant les bannières aléatoires.

      Dim objet

      ' Création de l'objet
      Set objet = Server.CreateObject("MSWC.AdRotator")

      Response.Write objet.GetAdvertisement("liste.txt")

      ' Destruction de l'objet
      Set objet = Nothing
    %>
  </body>
</html>
' Fichier de redirection des liens : lien.asp
<%
  Response.Redirect Request.QueryString("url")
%>
' Fichier présentant le liste des bannières et liens : liste.txt
REDIRECT lien.asp
WIDTH 468
HEIGHT 60
BORDER 0
*
http://www.laltruiste.com/coursasp/images/alapage.gif
http://www.alapage.com/
Visitez la librairie en ligne!
4
http://www.laltruiste.com/coursasp/images/blackorange.gif
http://www.blackorange.com/
Découvrez la logithèque en ligne !
3
http://www.laltruiste.com/coursasp/images/oreilly.gif
http://www.editions-oreilly.com/
Découvrez le célèbre éditeur de livres !
3

Les instructions d'exécutions permettent d'exécuter d'une à plusieurs instructions.

L'instruction Execute exécute les instructions contenues dans ses arguments.

Execute instruction: instruction2:... 

Les instructions doivent être placées entre des guillemets et être séparés soit par un caractère deux-points : ou par un caractère de saut de ligne ch(10).

L'instruction ExecuteGlobal exécute des instructions dans l'espace de nom global d'un script.

Dans le cadre de l'espace de nom global, l'instruction donnera un résultat qui dépendra des variables globales du script et non des locales.

Execute instruction: instruction2:... 

Les instructions obéissent ici aux mêmes règles que précitées.

<html>
  <body>
    <%
      Dim taille, valeur
      taille = 10
      valeur = 8
      Sub procedure
        Dim taille
        taille = 2

        ExecuteGlobal "Sub affiche: Response.Write taille * valeur: End Sub"
        ' affiche produit 10 * 8 = 80
        affiche

        ' affiche2 produit 10 * 8 = 16
        Response.Write taille * valeur & "<br>"

        Execute "Sub affiche2: Response.Write taille * valeur: End Sub"
        ' affiche2 produit 10 * 8 = 16
        affiche2
      End Sub

      Execute "Sub affiche3: Response.Write taille * valeur: End Sub"

      ' affiche produirait une erreur car la fonction 
      ' n'est pas disponible hors de la procédure.
      ' affiche

      ' affiche3 produit 10 * 8 = 80
      affiche3

      ' affiche2 produit 10 * 8 = 16
      Response.Write taille * valeur & "<br>"

      ' Appel de la procédure Sub class="rem"
      procedure
    %>
  </body>
</html>

L'instruction On Error permet d'activer la gestion des erreurs dans des programmes Visual Basic Script.

On Error...

L'instruction On Error Resume Next évite l'interruption du déroulement d'un script lorsqu'une erreur se produit, et partant, les erreurs pourront être traitées par le programmeur à l'aide d'une instruction spécifique, en l'occurrence l'objet Err conservant les références de l'erreur en cours.

On Error Resume Next

L'instruction On Error Goto 0 provoque la reprise en charge des erreurs par le système, c'est-à-dire lorsqu'une erreur intervient, le programme s'interrompera immédiatement.

On Error Goto 0

<html>
  <body>
    <%
      Public x
      Public y
      x = 10

      On Error Resume Next
      Response.Write "Division " & x & " / " & y & " = " & x / y
      ' Une erreur a été détectée, pourtant le traitement continue...

      If Err.Number <> 0 Then
        Response.Write "<br>Une erreur  s'est produite !" & chr(13) _
                 &  "n°" & Err.Number & " :" & chr(13) & Err.Description
      End If

      y = 2
      On Error Goto 0
      Response.Write "<br>Division " & x & " / " & y & " = " & x / y
    %>
  </body>
</html>

Le langage VBScript ne contient que quelques objets.

Les objets disponibles sont des variables de types classes, conteneurs d'erreurs ou liés aux expressions régulières.

L'objet Class produit par l'instruction Class, permet d'accéder aux propriétés, méthodes et événements de la classe.

Une classe ne peut être créée de façon de explicite, il est nécessaire de s'appuyer sur une classe existante pour déclarer une variable du même type.

Class Nom_Classe
  'Instructions...
End Class

Dim objet_classe
Set objet_classe = New Nom_Classe

L'objet de type classe ainsi créé, peut ensuite utiliser n'importe quelles propriétés, méthodes définies par la classe concernée.

objet_classe.propriété = valeur
objet_class.méthode = résultat

Les deux événements intrinsèques de l'objet classe permettent d'initialiser ou de détruire la variable objet.

' Initialise l'objet en s'appuyant sur l'événement 
' Initialize déclaré dans la définition de classe
Set objet_classe = New Nom_Classe

' Détruit l'objet en s'appuyant sur l'événement 
' Terminate déclaré dans la définition de classe
Set objet_classe = Nothing

<html>
  <body>
    <%
      Class livre
        Private titre_livre
        Private prix_livre

        Private Sub Class_Initialize
          Response.Write "<p><i>La classe est initialisée</i></p>"
        End Sub

        Private Sub Class_Terminate
          Response.Write "<p><i>La classe est détruite</i></p>"
        End Sub

        Public Property Let titre(valeur)
          titre_livre = valeur
        End Property

        Public Property Get titre
          titre = titre_livre
        End Property

        Public Property Let prix(montant)
          prix_livre = FormatNumber(montant,2,-1)
        End Property

        Public Property Get prix
          prix = prix_livre
        End Property

        Public Property Get convFrancsEuro
          convFrancsEuro = FormatNumber(prix_livre * (1 / 6.55957),2)
        End Property

        Public Sub reduction(taux)
          if taux > 5 then
            taux = 5
          End If
          prix_livre = FormatNumber(prix_livre - (prix_livre * taux / 100),2,-1)
        End Sub
      End Class

      Dim objet
      Set objet = New livre

      objet.titre = "ASP 3.0 : Le guide du développeur"
      objet.prix = 298.00

      Response.Write "<h2>Le livre " & objet.titre  & "</h2>" _
                           & "<h4>Prix : " & objet.prix & " Francs "
      Response.Write "<em style='font-size:10pt'>(" _ 
                           & objet.convFrancsEuro & " Euro)</em></h4>"
      objet.reduction 5
      Response.Write "<h4 style='color:green'>Si vous êtes abonnés, " 
                           & "vous bénéficiez d'une réduction de maximum 5%.</h4>"
      Response.Write "<h4>Prix réduit : " & objet.prix & " Francs</h4>"
      Set objet = Nothing
    %>
  </body>
</html>

L'objet Err constitue la solution de gestion des erreurs d'exécutions ou de syntaxes d'un programme VBScript.

L'objet Err contient cinq informations, le numéro, la description et la source de l'erreur ainsi qu'un identificateur contextuel et une adresse d'un fichier d'aide.
Ces informations sont accessibles à partir des cinq propriétés citées ci-dessous.

Deux méthodes permettent soit de générer une erreur sciemment, soit d'effacer les propriétés de l'objet Err.

<-- Fichier érroné -->
<!--#include file="identiferr.asp" -->
<html>
  <head>
    <title>Démonstration de Err</title>
  </head>
  <body>
    <%
      On Error Resume Next
      Response.Write 100 / 0
      HandleError("Division par zéro ! Ligne 9")
    %>
<-- Fichier inclus identiferr.asp -->
<%
  Sub HandleError(sourceErreur)
  If Err.Number = 0 Then Exit Sub
%>
    <h3>--> Une erreur a été détectée ! <--</h3>
    <DL>
      <DT><U>Numéro :</u></dt>
        <DD><% = Err.Number %></dd>
      <DT><U>Description :</u></dt>
        <DD><% = Err.Description %></dd>
      <DT><U>Source :</u></dt>
        <DD><% = Err.Source %></dd>
      <DT><U>Fichier concernée :</u></dt>
        <DD><% = Request.ServerVariables("PATH_TRANSLATED") %></dd>
      <DT><U>Adresse du fichier :</u></dt>
        <DD><% = Request.ServerVariables("URL") %></dd>
      <DT><U>Localisation :</u></dt>
        <DD><% = sourceErreur %></dd>
    </dl>
  </body>
</html>
<%
  Response.End
  End Sub
%>

L'objet RegExp permet de créer des expressions régulières.

Set objet = New RegExp

<html>
  <body>
    <%
      Dim texte, resultat

      Function recherche(modele, chaine)
        Dim objet
        Dim correspondance
        Dim collection

        Set objet = New RegExp
        objet.Pattern = modele
        objet.IgnoreCase = True
        objet.Global = True
        Set collection = objet.Execute(chaine)

        For Each correspondance in collection
          resultat = resultat & "<tr><td>" & correspondance.FirstIndex _
                      & "</td><td>" & correspondance.Value & "</td></tr>"
        Next
        recherche = resultat
      End Function

      texte = "Le chercheur d'opale a trouvé une belle pierre dans " _
               & "une galerie sinistre, pour le plus grand bonheur de " _
               & "la population occidentale qui pourtant se désolerait " _
               & " de travailler dans de telles conditions inhumaines."

      resultat = recherche(_
                     "\b[a-zA-Zàâäéèêëïîôöùûç]*le[a-zA-Zàâäéèêëïîôöùûç]*\b",_
                                                                                       texte)
      Response.Write "<h3>Liste des mots contenant la " _
                          & "chaîne de caractères <I>le</I></h3>" _
                          & "<h4>Texte</h4><p>" & texte & "</p>" _
                          & "<table border='1' cellpadding='3'>" _
                          & "<tr><th>Position</th><th>Mot</th></tr>" _
                          & resultat & "</table>"
    %>
  </body>
</html>

L'objet Match fournit un accès aux propriétés d'une mise en correspondance d'expression régulière.

L'objet Err contient cinq informations, le numéro, la description et la source de l'erreur ainsi qu'un identificateur contextuel et une adresse d'un fichier d'aide.
Ces informations sont accessibles à partir des cinq propriétés citées ci-dessous.

<html>
  <body>
    <%
      Dim texte, resultat

      Function recherche(modele, chaine)
        Dim objet
        Dim correspondance
        Dim collection

        Set objet = New RegExp
        objet.Pattern = modele
        objet.IgnoreCase = True
        objet.Global = True
        Set collection = objet.Execute(chaine)

        For Each correspondance in collection
          resultat = resultat & "<tr><td>" & correspondance.FirstIndex _
                      & "</td><td>" & correspondance.Value & "</td></tr>"
        Next
        RegExpTest = resultat
      End Function

      texte = "Le chercheur d'opale a trouvé une belle pierre dans " _
               & "une galerie sinistre, pour le plus grand bonheur de " _
               & "la population occidentale qui pourtant se désolerait " _
               & " de travailler dans de telles conditions inhumaines."

      resultat = recherche(_
                     "\b[a-zA-Zàâäéèêëïîôöùûç]*le[a-zA-Zàâäéèêëïîôöùûç]*\b",_
                                                                                       texte)
      Response.Write "<h3>Liste des mots contenant la " _
                          & "chaîne de caractères <I>le</I></h3>" _
                          & "<h4>Texte</h4><p>" & texte & "</p>" _
                          & "<table border='1' cellpadding='3'>" _
                          & "<tr><th>Position</th><th>Mot</th></tr>" _
                          & resultat & "</table>"
    %>
  </body>
</html>

L'objet Matches contient une collection de correspondances créées par l'objet Match.

objet.Matches(n)

<html>
  <body>
    <%
      Dim texte, resultat

      Function recherche(modele, chaine)
        Dim objet
        Dim correspondance
        Dim collection

        Set objet = New RegExp
        objet.Pattern = modele
        objet.IgnoreCase = True
        objet.Global = True
        Set collection = objet.Execute(chaine)

        For Each correspondance in collection
          resultat = resultat & "<tr><td>" & correspondance.FirstIndex _
                      & "</td><td>" & correspondance.Value & "</td></tr>"
        Next
        RegExpTest = resultat
      End Function

      texte = "Le chercheur d'opale a trouvé une belle pierre dans " _
               & "une galerie sinistre, pour le plus grand bonheur de " _
               & "la population occidentale qui pourtant se désolerait " _
               & " de travailler dans de telles conditions inhumaines."

      resultat = recherche(_
                     "\b[a-zA-Zàâäéèêëïîôöùûç]*le[a-zA-Zàâäéèêëïîôöùûç]*\b",_
                                                                                       texte)
      Response.Write "<h3>Liste des mots contenant la " _
                          & "chaîne de caractères <I>le</I></h3>" _
                          & "<h4>Texte</h4><p>" & texte & "</p>" _
                          & "<table border='1' cellpadding='3'>" _
                          & "<tr><th>Position</th><th>Mot</th></tr>" _
                          & resultat & "</table>"
    %>
  </body>
</html>

L'objet SubMatches représente une collection de sous-correspondances.

objet.SubMatches(n)

Une sous-correspondance provient d'un modèle d'expression régulière décomposé par des sous-expressions entre parenthèses.

objet.modèle = "...(sous-expression)...(sous-expressionN)..."
' N valant au maximum 99

objet.Pattern = "(\w+)@(\w+).(\w+)"

L'exmple ci-dessus permet de décomposer une adresse email en trois sous-correspondances $1, $2 et $3 ou en utlisant l'objet SubMatches en :

' correspond à objet.$1 et donc (\w+) avant @.
objet.SubMatches(0)
' correspond à objet.$2 et donc (\w+) après @.
objet.SubMatches(1)
' correspond à objet.$3 et donc (\w+) après le point.
objet.SubMatches(2)

<html>
  <body>
    <%
      Dim adresse, resultat

      Function recherche(modele, chaine)
        Dim objet
        Dim correspondance
        Dim collection
        Dim i, fin, tableau

        Set objet = New RegExp
        objet.Pattern = modele
        objet.IgnoreCase = True
        objet.Global = True
        Set collection = objet.Execute(chaine)
        Set correspondance = collection(0)

        resultat = "<tr><td>Protocole</td><td>" _
                         & correspondance.SubMatches(0) & "</td></tr>" _
                         & "<tr><td>Domaine</td><td>" _
                         & correspondance.SubMatches(1) & "</td></tr>" _
                         & "<tr><td>Port</td><td>" _
                         & correspondance.SubMatches(2) & "</td></tr>" _
                         & "<tr><td>Répertoire</td><td>" _
                         & correspondance.SubMatches(3) & "</td></tr>" _
                         & "<tr><td>Fichier</td><td>" _
                         & correspondance.SubMatches(4) & "</td></tr>" _
                         & "<tr><td>Ancre</td><td>" _
                         & correspondance.SubMatches(5) & "</td></tr>"

        recherche = resultat
      End Function

      adresse = "http://www.laltruiste.com:80/coursasp/sommaire.html#ancre"

      resultat = recherche(_
                      "(\w+):\/\/([^/:]+):?(\d*)?\/(.*[^.])\/(\w+.\w+)#?(\w+)?", _
                                                                                           adresse)

      Response.Write "<h3>Décomposition d'une adresse URL " _
                           & "(Uniform Resource Locator)</h3>" _
                           & "<h4>URL : " & adresse & "</h4>" _
                           & "<table border='1' cellpadding='3'>" _
                           & resultat & "</table>"
    %>
  </body>
</html>

Les caractères spéciaux permettent d'affiner une recherche, là où une expression régulière simple ne peut suffire.

Les caractères et autres symboles spéciaux représentent des caractères non-imprimables comme des sauts de lignes (\n), des tabulations (\t) ou des options particulières ou encore des plages de lettres ou de chiffres, etc.

Le langage VBScript est composé de quelques méthodes permettant d'accomplir certaines opérations sur les variables objets d'un programme.

objet.méthode

Les méthodes s'appliquent soit à des variables de chaînes de caractères soit à des objets liés aux erreurs.

Le langage VBScript est composé de quelques propriétés permettant de définir ou retourner certaines informations sur les variables objets d'un programme.

objet.méthode