ASP et Composants Serveurs

Comment les intégrer proprement

Un composant serveur est typiquement un contrôle ActiveX, conforme aux normes COM, DCOM, ou COM+. Normalement, ce sont des fichiers avec l’extension de nom de fichier ‘.dll’ ou ‘.ocx’. Ces fichiers doivent exister sur le serveur et en plus être référencés dans la base de registres du système d’exploitation. Une fois l’installation faite, le composant est disponible pour les scripts ASP. On utilise l’instruction VBScript suivante pour créer une instance de l’objet :

Set MonObjet = Server.CreateObject("Scripting.FileSystemObject")

…où Scripting.FileSystemObject est un exemple d’un nom d’objet. On accède aux fonctionnalités de l’objet utilisant la variable MonObjet. A la fin du script, ou dès que vous n’avez plus besoin de l’objet, détruisez-le avec l’instruction VBScript suivant :

Set MonObjet = Nothing

Si l’objet à des méthodes comme Open (ouverture), appeler une méthode Close (fermeture) avant de détruire l’objet. Si vous négligez de faire cette action, les ressources du serveur seront mal utilisées : au bout d’un moment, la machine va s’apercevoir que l’objet n’est plus requis, mais en attendant, elle sera moins performante.

Vous n’avez pas la liberté de choisir vous mêmes les composants serveurs à utiliser dans les projets. Certains composants des différents éditeurs ne sont pas compatible entre eux, ou encore pire, ne sont pas fiable : ce qui provoque des gros problèmes de mise en production d’une application.

Composants tierce partie

Ce sont des composants achetés auprès des entreprises spécialisées dans la création des objets ActiveX. Nous utilisons actuellement un composant de téléchargement de fichiers depuis un navigateur (upload) vers un serveur, et un composant de compression et de décompression des fichiers (formats ZIP, GZIP, TAR, etc.). Ces composants doivent être installés sur le serveur.

Réutilisation du code

Il faut d’abord que tout code soit lisible et commenté. C’est-à-dire : expliquer le but de chaque section de code, son fonctionnement, les données en entrée et en sortie, et sa façon de gérer les erreurs (ou les données inattendues).

Utilisez des fonctions et des sous-procédures au maximum. Ceci favorise la réutilisation, et a l’avantage supplémentaire de rendre modulaire le code, ce qui à son tour permet d’isoler mieux des éventuels problèmes ou des bogues. D’ailleurs, tout ce qui commun devrait être mis dans un emplacement partagé, c’est-à-dire un fichier INCLUDE dans la plupart des cas.

Un ou plusieurs fichiers de constantes (variables dont la valeur ne change jamais, sauf si on modifie l’installation du site) sert à faciliter la maintenance et la réutilisation du code. Pensez à paramétrer les noms des tables ou des champs s’il existe une possibilité de changement de bases de données, par exemple.

Evidemment, il vaut mieux ne pas réinventer le même code pour chaque projet. Normalement, les besoins des codes sources devront être identifiés au démarrage d’un projet.

Pour aller plus loin, on peut écrire le code commun d’un projet en tant qu’une série de services ; on applique le même principe à tout objet, même les objets de base. La raison, c’est la maintenance et longévité des projets. Par exemple, l’interface ODBC sera remplacée par OLE DB d’ici quelques années ; comme presque tout site s’appuie sur un accès aux bases de données, il est clair qu’il faut prévoir tout problème.

En effet, un service peut être implémenté avec une fonction ou une classe en VBScript. On appelle la fonction ou une méthode de la classe afin d’effectuer l’action requise : une telle fonction ou méthode s’appelle une service (pour la messagerie, accès aux bases de données, FTP, téléchargement, …). Ces fonctionnes peuvent être modifiées pour prendre en compte de tels changements d’environnement informatique : on n’a qu’à appeler la fonction (qui acceptera toujours les même paramètres et qui rendra toujours le même format de résultat) sans se soucier des traitements faits par la fonction.

On va maintenant regarder quelques exemples

D’abord, pour appliquer la meilleure pratique, on définit les constantes dont les fonctions de service auront besoin. Il vaut mieux définir ces constantes dans un fichier commun qui ne sert qu’au paramétrage.

Voici un exemple:

DSN_CONSTANTE = "chaîne_de_connexion_ODBC"

Ensuite, on définit la fonction. Comme d’habitude, utilisez un fichier commun.

Function ObtenirConnexionBDD()
Dim oAdoCnx
Set oAdoCnx = Server.CreateObject("ADODB.Connection")
oAdoCnx.Open (DSN_CONSTANTE)
' La constante
Set ObtenirConnexionBDD = oAdoCnx
End Function
Sub DetruireConnexionBDD
(ByRef oAdoConnexion)
Call oAdoConnexion.Close()
Set oAdoConnexion = Nothing
End Sub

Finalement, on appelle cette fonction. Le format de l’appel ne devrait jamais changer d’une page à l’autre, sauf s’il y a des paramètres à fournir.

Dim oConx
Set oConx = ObtenirConnexionBDD()
' Traitements ici qui se servent de la connexion...
DetruireConnexionBDD (oConx)

Ici, pour l’ouverture de la connexion, on ne sait pas qu’elle s’agit d’une connexion ADO ; on n’a pas besoin de le savoir. Evidemment, il faut faire des traitements en respectant l’API d’ADO : mais pourquoi écrire des fonctions de service pour accomplir ces traitements aussi ?

Ces exemples vous ont été présentés en VBScript, car ce langage est le plus utilisé en ce moment. Cependant, du point de vue technique, j’aurais préféré utiliser JavaScript. Pourquoi? Parce que dans le cas où une erreur serait survenue (soit une erreur logique, soit une vraie erreur système), on peut remonter le problème avec un objet 'erreur' Dans l’exemple, il fallait signaler l’échec par la valeur Null.

Rappel du langage et des objets

VBScript

VBScript s’intègre à tout environnement de scripting sur les plate formes Microsoft. Il est le langage le plus utilisé dans l’environnement ASP, principalement parce qu’il s’interface facilement aux autres éléments dans cet environnement. VBScript est facile à apprendre, et presque tous les exemples d’ASP sont en VBScript. N’oubliez pas par contre que d’autres langages peuvent être utilisés à sa place. Par exemple, JScript propose une meilleure structure et une meilleure gestion d’erreurs ; l’utilisation de JScript facilitera la conversion des ASP vers les JSP (JavaServer Pages) si jamais cette opération se révèle nécessaire.

On ne va pas vous former ici à VBScript . Nous supposons que vous comprenez déjà ce langage assez bien.

Environnement ASP

ASP n’est pas un langage. ASP est un environnement de programmation qui propose un jeu d’objets qui interface avec un serveur IIS (Internet Information Server). Pour interagir avec ses objets, ASP propose une interface à laquelle plusieurs langages peuvent se connecter, à condition qu’ils soient compatibles avec l’interface ActiveX hôte de scripting. Par défaut, cela vous permet d’utiliser VBScript ou JScript avec ASP ; il existe en plus d’autres langages tierce partie, comme PerlScript, qui sont compatibles avec cette interface. Donc, vous pouvez changer les versions de IIS-ASP indépendamment des versions des moteurs de scripting. Chaque site web est reconnue comme une Application IIS.

Celles-ci commencent lorsque le service IIS démarre sur une machine Windows NT/2000 Server, jusqu’à ce que l’on les arrête volontairement depuis le console d’administration d’IIS. Un serveur IIS peut contenir plusieurs applications à la fois; chacune d’entre elles peut être démarrée ou arrêtée indépendamment.

Lorsque un client (typiquement un ‘internaute’ ou un utilisateur d’un Intranet ou d’un Extranet) se connecte à un site web IIS-ASP, ce serveur lui donne un identifiant unique (s’il n’en a pas déjà un), utilisant un cookie. A chaque fois qu’il y a un échange d’information entre le client et le serveur, ce cookie est transmit avec la requête HTTP; le serveur saura alors associer la requête avec le bon profil d’utilisateur et ses informations (le serveur garde ces informations localement dans sa mémoire ou sur disque). Cette association dure jusqu’à ce qu’il n’y ait plus de connexions au serveur au bout d’une période prédéfinie, ou jusqu’à ce que le client ou serveur demande volontairement l’abandon de cette association. Ce concept est connu comme une Session.

Lorsque une application ASP ou une session commence ou se termine, il est possible de répondre à ces événements avec des scripts dans un fichier facultatif – global.asa – à la racine de l’arborescence du site web. Ainsi, au début d’une session ou d’une application, on peut définir des paramètres globaux ; également, à la fin, on peut libérer les ressources utilisées et nettoyer tout ce qui a été créé de façon temporaire.

Les objets qui font l’environnement ASP sont toujours immédiatement disponible aux scripts. Les voici:

Applicatio: contient des paramètres valides pendant la durée de vie d’une application et communs avec toutes les Sessions.
Session: contient des données relatives à chaque client. Non partagées avec d’autres clients.
Request: toutes les données associées à la requête HTTP sont gérées et interprétées par cet objet. Notamment les informations à propos de l’identité du client, la sécurité, et les informations transmises un formulaire.
Response: la réponse à envoyer (normalement un document HTML) est générée par cet objet. Permet notamment de créer dynamiquement la réponse. On peut également envoyer des directives HTTP au client pour rediriger la requête ailleurs.
Server: permet de accéder aux composants ActiveX sur le serveur, contrôler l’environnement de scripting, et encoder des données. Il existe d’importantes nouveautés dans la version 5 d’IIS (voir plus tard).

Environnement de données

L’accès aux bases de données se fait avec un ensemble de composants ActiveX installés sur le serveur. Ces composants font partie de MDAC (Microsoft Data Access Components), dont notamment l’ensemble d’objets ADO (ActiveX Data Objects). Les objets principaux d’ADO sont:

Connection (connexion): permet l’échange de données. Tout autre objet ADO a besoins d’une connexion ouverte.
Command (commande) : encadre une instruction SQL.
Parameter (paramètre) : encadre un paramètre d’une instruction SQL.
RecordSet (collection d’enregistrements) : permet de naviguer et manipuler des données.
Field (champ) : une colonne d’une RecordSet.

Transactions

Microsoft Transaction Server assure les transactions. Le but d’une transaction est de regrouper une série de traitements pour éviter l’instabilité d’une application. Si tout élément de la transaction réussi, la transaction sera ‘commit’ : c’est-à-dire que toutes les actions effectuées seront acceptées ; sinon, si tout échoue ou même juste une partie de la transaction échoue, toutes les actions seront annulées pour revenir à l’état du départ.

Environnement XML

La bibliothèque d’objets qui permet de traiter les documents XML se trouve dans le fichier MSXML.DLL. Ce fichier est à télécharger ou est installé sur un poste avec Internet Explorer 5. Ce fichier est destiné aux applications clientes et serveurs. Les objets principaux sont XMLDOM (traitement XML et XSL) et XMLHTTP (échange de données XML à travers un réseau). XMLDOM comprend un parseur validant (contre une DTD) et non-validant, ainsi qu’un processeur XSL.

Notez qu’à partir de la version 2.5 des ADO, il sera possible d’accéder les données sous format XML dans des objets RecordSet hiérarchiques. Aussi, SQL Server (et probablement d’autres serveurs de bases de données) sera capable de traiter des requêtes et des réponses de données sous format XML et HTTP

Autres langages dans l’environnement ASP

JavaScript

On peut utiliser le noyau du langage JScript pour accéder et manipuler les objets de l’environnement ASP. Rien ne change en terme de fonctionnalités par rapport à VBScript, mais vous disposerez de tous les avantages du JScript. Notez que les objets des navigateurs web ne sont évidemment pas disponible : par exemple, vous ne pouvez pas utiliser window.alert() ou document.write() ; pour cette dernière méthode, vous utiliserez Response.Write(). Commençons avec un exemple d’un script ASP écrit en JScript :

<%@ Language=JavaScript %>
<%
var oAdoCnx, oAdoRst, sCmdSql, arNoms, i, j;
try {
oAdoCnx = Server.CreateObject("ADODB.Connection");
oAdoCnx.Open("PerfASP");
try {
sCmdSql = "SELECT * FROM tabExemple ORDER BY Nom ASC";
oAdoRst = Server.CreateObject("ADODB.RecordSet");
oAdoRst.Open (sCmdSql, oAdoCnx);
arNoms = new Array();
i = 0;
while (!oAdoRst.EOF) {
arNoms[i++] = oAdoRst("Nom")+", "+oAdoRst("Prenom");
oAdoRst.MoveNext();
}
oAdoRst.Close();
}
catch (t) {
throw (t); // A exécuter si une erreur est survenue
}
finally {
oAdoRst = null; // A exéctuer en tout cas
}
oAdoCnx.Close();
oAdoCnx = null;
}
catch (t) {
oAdoCnx = null;
Response.Redirect("erreur.asp?desc=" + escape(t.description));
}
%>

L’avantage principal dans cet exemple est la gestion d’erreurs on ne mélange pas le code applicatif avec le code qui gère les erreurs potentielles. On encadre les endroits où il y a une risque d’erreur pour un traitement ailleurs.

Cet exemple est très simple: on aurait pu aussi se servir de l’orientation objet de JScript ou interagir avec des scripts écrits dans d’autres langages.

PerlScript

PerlScript utilise le noyau du langage Perl (version de ActiveState) pour accéder et manipuler les objets de l’environnement ASP. Regardons un exemple simple

Language=PerlScript %>
<%
my $oAdoCnx = $Server->CreateObject("ADODB.Connection");
$oAdoCnx->Open("PerfASP");
my $sCmdSql = "SELECT * FROM tabExemple ORDER BY Nom ASC";
my $oAdoRst = $Server->CreateObject("ADODB.RecordSet");
$oAdoRst->Open ($sCmdSql, $oAdoCnx);
my @arNoms;
my $i = 0;
while ($oAdoRst->{EOF} == 0) {
$arNoms[$i] = $oAdoRst->Fields("Nom")->{Value} . ", " . $oAdoRst->Fields("Prenom")->{Value};
$oAdoRst->MoveNext();
$i++;
}
$oAdoRst->Close();
undef $oAdoRst;
$oAdoCnx->Close();
undef $oAdoCnx;
%>
for (my $j = 0; $j < scalar(@arNoms); $j++) {
$Response->Write(" }
%>

Le premier constat : les scripts Perl dans l’environnement ASP n’utilise pas les mêmes moyens qu’un script CGI (sur un serveur Apache par exemple) pour gérer le traitement de la page. On n’utilise pas l’environnement CGI ici : on utilise les objets ASP. Le deuxième constat, c’est que normalement (avec JScript et VBScript) on utilise souvent (même sans le savoir) les " propriétés par défaut " d’un objet ; par exemple, dans un exemple VBScript ou JScript, vous verrez qu’il suffit de préciser le nom de la colonne (entre guillemets et entre parenthèses) suivant le nom de l’objet RecordSet pour accéder à la valeur d’un champ. Avec Perl par contre (qui ne connaît pas l’OLE de Microsoft), il faut spécifier la propriété précisement, d’où le nom de la collection Fields et le nom de la propriété Value.

En résumé, le noyau du langage Perl est toujours disponible (ce qui est très puissant et riche en fonctionnalité, notamment les expressions régulières et l’accès à Internet). Il suffit de préciser le langage à utiliser dans l’en-tête du script, et puis se souvenir que l’on utilise le jeu d’objets d’ASP au lieu des bibliothèques CGI.

ASP Evolutions Techniques

IIS 5.0 – l’environnement serveur

Internet Information Server 5.0 fait partie de Windows 2000 Server. Au niveau des fonctionnalités du serveur lui-même, il propose un meilleur contrôle de l’environnement dans lequel tournent les applications web (partage et séparation des ressources) et une répartition de charge améliorée à travers plusieurs serveurs. Pour ce qui concerne les scripts ASP, les changements ne sont pas très nombreux mais restent cependant significatifs :

la propriété Response.Buffer est par défaut mis à True ; dans les versions précédents, cette propriété était à False par défaut. En conséquence, les pages générées par un script ne seront envoyées au client qu’au moment que le script se termine ou qu’une commande d’envoi exprès est exécutée. Avant, les pages étaient envoyées au fur et au mesure qu’un morceau du document était prêt à envoyer.
l’objet Server propose une méthode Transfer, qui permet de continuer l’exécution du script dans un autre fichier ASP ; le script qui reprend l’exécution aura accès à toutes les variables utilisées dans la page d’origine.
l’objet Server propose une autre nouvelle méthode, Execute. Celle-ci demande qu’une autre page ASP s’exécute, et à la fin d’exécution de cette deuxième page, la page d’origine reprend l’exécution.

Moteurs de script ActiveX

VBScript 5
- RegExp
  
  Les expressions régulières sont très utilisés dans le langage Perl : il permet de valider des chaînes de caractères contre les patterns – c’est-à-dire, des séries de caractères, de mots, et de chiffres, à inclure et à exclure ; on peut combiner ces séquences. Dans l’exemple ci-dessous, on valide une chaîne de caractères contre un pattern e-mail (notez que l’exemple peut être encore réduit)
  
  Function ValiderAdresse (ByRef sEmail)
  Dim oRegExp, bOut
  Set oRegExp = New RegExp
  RegExp.pattern = "\w+\@[.\w]+"
  If oRegExp.Test(sEmail) = True Then
  bOut = True
  Else
  bOut = False
  End If
  ValiderAdresse = bOut
  End Function
  
  Le syntaxe des patterns est expliqué dans la documentation officielle de Microsoft. La version 5.5 de VBScript (actuellement en phase de test) apportera encore plus de puissance aux RegExp.
- Eval, Execute, et ExecuteGlobal
  
  Un avantage clé de JavaScript était sa capacité de se modifier en cours d’exécution. Maintenant, VBScript sait faire plus ou moins la même chose : par contre, avec VBScript, c’est plus compliqué (principalement due au fait que l’opérateur ‘=’ en VBScript a deux sens). Eval est destiné à évaluer une expression, et Execute est destiné les instructions entières ; ExecuteGlobal permet d’exécuter les instructions dans un contexte global, permettant de créer des nouveaux classes dynamiquement par exemple.
  
  Eval ("x = 15") ' x est comparé à 15; le résultat est soit True ou bien False
  Execute ("x = 15") ' x aura la valeur 15
- DCOM
  
  DCOM permet d’utiliser un objet sur un serveur distant comme s’il existant sur le poste local. La seule différence au niveau d’utilisation d’un objet DCOM par rapport à un objet installé localement se trouve au moment de création d’un objet : on ajoute le nom de serveur distant à l’appel à la méthode CreateObject. Après, on utilise l’objet comme n’importe quel autre.
  
  Set monObjetDistant = CreateObject("ObjetDistantProgID","\\serveurdistant")
- Class
  
  Avec l’introduction des classes au langage VBScript, sa puissance à fortement augmentée ; il est comparable aux constructeurs d’objet sous JavaScript.
  
  Class Personne
  Public Prenom, Nom
  Private sAdresseEmail
  Property Get AdresseEmail
  AdresseEmail = sAdresseEmail
  End Property
  Property Let AdresseEmail(sEmail)
  sAdresseEmail = sEmail
  End Property
  Property Get NomComplet
  NomComplet = Prenom & " " & UCase(Nom)
  End Property
  Sub Definir(Premier, Dernier)
  Prenom = Premier
  Nom = Dernier
  End Sub
  Function BaliseEmail(sLibelle)
  BaliseEmail = "<a href=""mailto:" & sAdresseEmail & """>" & sLibelle & "</a>"
  End Function
  End Class
  
  Dim Auteur
  Set Auteur = New Personne
  Auteur.Definir "AF", "LAURENT"
  Auteur.AdresseEmail = "aflaurent@societe.com"
  
  Response.Write Auteur.BaliseEmail(oAuteur.NomComplet)
  
  Set Auteur = Nothing
  
  On définit un bloc Class, dans lequel on peut déclarer des variables de portée interne (Private) ou globale (Public). On les accède avec les blocs Property Get (lire) et Property Let (écrire). On imbrique les blocs Function pour définir les méthodes (ce qui diffère du JavaScript où les méthodes sont externes). Il est également possible de définir une propriété ou une méthode par défaut avec le mot-clé Default.
  
  Pour se servir de ces classes, on déclare une variable (avec Dim), on lui associe une nouvelle instance de la classe (avec Set … New), on accède aux propriétés et aux méthodes de manière standard, et puis on ne néglige pas de détruire l’objet à la fin.

JavaScript 5

Gestion d’erreurs et d’exceptions

Dans l’exemple de l’utilisation de JavaScript en ASP, on utilise les commandes throw, try, catch, et finally. Ces instructions (sauf throw) permet de découper le code dans trois blocs : un bloc à exécuter en supposant qu’il n’y a jamais d’erreur, un bloc qui traite toutes les erreurs attendues (et même inattendues si souhaité), et un bloc à exécuter qu’il y avait eu des erreurs ou non. L’instruction throw permet de générer volontairement une erreur, où l’erreur est un objet dont le développeur aura écrit le constructeur.

try {
/* On exécute un script ici sans tester pour les erreurs. Si une erreur est survenue ou
générée volontairement, l’exécution du bloc "try" s’arrête immédiatement, et le bloc
"catch" prend le contrôle et récupére l’erreur */
}
catch (t) {
/* "t" est l’erreur récupéré. On n’a qu’un bloc "catch" par bloc "try", donc il faut
tester le type d’erreur, normalement en utilisant l’opérateur "instanceof". On peut
même choisir de ne pas traiter l’erreur: pour faire cela, il suffit l’instruction
"throw t". Un bloc try...catch extérieur est donc réquis pour empêcher l’affichage
de l’erreur dans l’environnement hôte. */
}
finally {
/* Ce bloc est exécute dans tout cas (sauf si vous déchargez le script...) */
}

Notez que si vous abandonner le script dans un bloc catch, par exemple avec Response.Redirect, le bloc finally ne pourra pas être exécuté.

DCOM

L’utilisation des objets distants (sur un autre serveur) fonctionne identiquement sous JScript ; la syntaxe est la suivante:

var monObjetDistant = new ActiveXObject("ObjetDistantProgID","\\serveurdistant");
Prochaines évolutions

Dans l’immédiat, JScript sera homogénéisé avec le norme ECMAScript 262/3. Ce qui veut dire des nouvelles fonctions ( notamment pour améliorer les tableaux et la manipulation des objets ) et des fonctions renommés ( escape() et unescape() devient encodeURI() et decodeURI() ). Les expressions régulières seront encore plus puissantes.

Plus loin (d’ici un an), ECMAScript 262/4 proposeront un typage plus fort et davantage d’orientation objet.

Les Failles et Points Sensibles

Formatage du code ASP

Vous n’êtes pas obligé de déclarer les variables en VBScript, mais cette pratique est recommandée. Vos erreurs deviendront plus facile à repérer et vous allez pouvoir intégrer facilement des scripts externes. Utilisez la directive Option Explicit avant toute instruction dans un script : vous serez obligé de déclarer toute variable, ce qui vous donne deux avantages. Le premier, c’est que les variables inconnues seront immédiatement visible, et le deuxième, c’est le script sera plus rapide car le moteur VBScript ne serait pas obligé de faire de démarches lentes et compliquées pour savoir à quelle variable vous faites référence.

Respectez la casse, même s’il n’est pas obligatoire. Les règles de nommage de variables sont aussi à respecter, surtout parce que les variables peuvent changer de type. Voici les conseils, pris du document Méthodes de Développement:

Préfix		Type	Exemple
b	bln	Boolean	bEstConnu
dt	dat	Date et/ou Heure (pas caractère)	dtEnregistrement
f	flt	Numérique point flottant	fEchelle
n	num	Numérique entier	nPersonneID
s	str	Chaîne de caractères	sPrenom
v	var	Type variant	vChampLu
a	arr	Array (tableau)	aLignesBdd()
o	obj	Objet	oNewMail
c	col	Collection	cCellules

L’utilisation des objets

Ne négligez jamais de détruire les objets utilisés. Pour vous rappeler comment faire cette action en tout langage courant, voici les instructions nécessaires :

en VBScript :Set monObjet = Nothing
en JScript :monObjet = null;
en PerlScript :undef $monObjet ;

Certains objets, comme les RecordSet et les Connection devront être d’abord mis dans un état " fermé ", normalement avec une méthode Close(). N’oubliez pas que vous créez parfois des objets sans le savoir. Par exemple, l’instruction :

Set annuaire = oAdoCnx.Execute("SELECT * FROM annuaire")
…créera un objet RecordSet. Vous devez donc le fermer et détruire après que vous n’en avez plus besoin.

Choix de types de variables en VBScript

Certaines subtilités du langage VBScript doivent être comprises afin de garantir la fiabilité du code. Il faut bien comprendre les types de données (en effet, les sous-types de Variant) qui vous sont proposés en VBScript. Regardons cette table:

Sous-type	Description
Empty	Variable non-renseignée : considérée comme 0 (zéro) et une chaîne vide.
Null	Variable déclarée volontairement d’être vide. Très utile.
Boolean	Soit True ou False. En VBScript, True égale -1, et False égale 0.
Byte	Un entier entre 0 et 255.
Integer	Un entier entre –32 768 et 32 767.
Currency	Entre –922 337 203 685 477,5808 et 922 337 203 685 477,5807 .
Long	Un entier entre –2 147 483 648 et 2 147 483 647.
Single	Nombre à point flottant, de –3,402823E38 à –1,401298E-45 (valeurs négatives) et de 1,401298E-45 à 3,402823E38 (valeurs positives)
Double	Nombre à point flottant (maximum précision)
Date (Time)	Une date entre l’an 100 et l’an 9999 (précis jusqu’à la milliseconde)
String	Une chaîne de caractères (limité à deux milliards de caractères)
Object	Un objet
Error	Une erreur

Un piège grave, trop souvent oublié en VBScript dans le contexte des scripts ASP qui appuient sur les bases de données, c’est l’utilisation du type Int où on aura du choisir le type Lng, notamment avec la fonction CInt (où il vaut mieux utiliser la fonction CLng). Comme un Int ne peut jamais avoir une valeur supérieure à 32768, on survient souvent des problèmes où un script ne fonctionne plus car une valeur en provenance d’une base de données (disons un identifiant numérique) est supérieure à cette limite.

Dans le contexte des requêtes et des réponses HTTP, on manipule toujours les chaînes de caractères. Tout ce que vous récupérez d’un formulaire est une chaîne de caractères : si vous réussissez dans certains circonstances à utiliser un chiffre lu d’un formulaire comme un nombre, c’est parce que – dans certains circonstances – VBScript simplifiera les conversions ; néanmoins, cette simplification ne fonctionne pas partout, donc vous devez toujours faire des conversions explicites en utilisant les fonctions de conversion de VBScript.

Si vous utilisez les sous-procédures en VBScript pour modifier la valeur de variables passées comme des paramètres, utilisez les mots-clés ByRef (pour avoir une référence à la variable ou à l’objet) ou ByVal (pour avoir une copie de la variable ou de l’objet).

Finalement, notez que les fonctions de conversion en VBScript prend toujours compte des paramètres régionaux, donc si un tiers du système (soit le navigateur, le serveur web, ou la base de données) diffère d’un autre, ces conversions risque de ne pas fonctionner correctement.

Gestion d’erreurs en VBScript

Vous démarrer la gestion d’erreurs en VBScript avec l’instruction : On Error Resume Next

…ce qui veut dire : " ne pas arrêter s’il y a une erreur ". Vous êtes obligé de vérifier après chaque commande problématique s’il a échoué ou réussie. Mais une fois activé, vous ne pouvez pas le désactiver. Donc s’il y une erreur inattendue plus loin dans le script, vous n’allez pas le repérer facilement. Faites donc très attention.