# Programmation VBScript/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du wikilivre.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l'article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL : https://fr.wikibooks.org/wiki/Programmation_VBScript

# Introduction

Le langage VBScript ou VBS (pour Visual Basic Script) est un langage de programmation de la famille (visual) basic, destiné à être interprété. Il est dépendant du logiciel Windows Script Host (WSH) exclusivement fourni par Microsoft.
On donne aux scripts logiciels écrits dans ce langage, par convention, un nom qui se termine par .vbs. Le fait que le langage est un langage de script exécuté par un interpréteur signifie que le programme est exécuté sans compilation manuelle en fichier binaire. Le fait que l’interpréteur soit associé au suffixe vbs dans Windows rend le fichier directement exécutable sur double-clic depuis l'explorateur de Windows.
Comme le logiciel supporte plusieurs langages de programmation, il est utile d'indiquer sur une ligne le langage de programmation utilisé. Configuration HTML :
* Sur client : < script langage="VBScript" />
* Sur serveur : <% script langage="VBScript" %>

# Opérateurs

| + | addition |
| - | soustraction |
| * | multiplication |
| ^ | puissance |
| / | division à float |
| \ | division entière |
| mod | modulo - reste de la division entière |
| < | plus petit |
| <= | plus petit ou égal |
| > | plus grand |
| >= | plus grand ou égal |
| <> | différent |
| not | non logique |
| and | et logique |
| or | ou logique |
| xor | xor logique |
| eqv | equivalence |
| imp | implication |
| & | concaténation |

## Déclarations

* LÉGENDE
    src - source
    nm - nom
    var - variable
    expr - expression
    ins - instruction
    arg - argument
    cond - condition
* Déclaration
    option explicit - force déclaration de toutes variables dans scr
    dim nm(src) - variable
    redim [preserve] var(src)
    const nm=expr - constante
* Procédure - execute instructions
    sub nm(arg1,arg2,...)
       [ins]
       [exit sub]
       [ins]
    end sub
* Fonction - retourne une valeur en sortie à nm
    function nm(arg1,arg2,...)
       [ins]
       [nm=expr]
       [exit function]
       [ins]
       [nm=expr]
    end function
* Get - comme fonction simple
    property get nm(arg1,arg2,...) as [type]
       [ins]
       [nm=expr]
    end property
* Let - comme fonction simple
    property let nm(arg1,arg2,...)
       [ins]
    end property
* Set - comme fonction simple
    property set nm(arg1,arg2,...)
       [ins]
    end property
* Classe - retourne initialize || terminate
    class ClassName
          [var]
       Private Sub Class_Initialize
          [ins]
       End Sub
       Private Sub Class_Terminate
          [ins]
       End Sub
       Public Function NomMethode([arg])
          [ins]
       End Function
    end Class
nota : const/sub/function/property sont déclarables en [public [default] | private]
Exemple 1
Exemple 2

## Instructions de contrôle

* TEST
* BOUCLE
* APPELS
* ERREURS
* REMARQUES
* AFFECTATION DE REFERENCES
* ASSOCIATION DE REFERENCE

# Fonctions
## conversion et mise en forme

* CBool(expr) - conversion en variant booleen
* CByte(expr) - conversion en variant byte
* CCur(expr) - conversion en variant currency
* CDate(expr) - conversion en variant date
* CDbl(expr) - conversion en variant double
* CInt(expr) - conversion en variant integer
* CLng(expr) - conversion en variant long
* CSng(expr) - conversion en variant single
* CStr(expr) - conversion en variant string
* FormatCurrency(expr,[NumDigitsAfterDecimal],[IncludeLeadingDigit],[UseParensForNegativeNumber],[GroupDigits]) - conversion formatée en variant currency
* FormatDateTime(date,[NamedFormat]) - conversion formatée en variant date
* FormatNumber(expr,[NumDigitsAfterDecimal],[IncludeLeadingDigit],[UseParensForNegativeNumber],[GroupDigits]) - conversion formatée en variant nombre
* FormatPercent(expr,[NumDigitsAfterDecimal],[IncludeLeadingDigit],[UseParensForNegativeNumber],[GroupDigits]) - conversion formatée en variant percent
* Hex(nbr) - conversion en variant hexadecimal
* IsArray(expr) - renvoit booleen si tableau
* IsDate(expr) - renvoit booleen si date
* IsEmpty(expr) - renvoit booleen si vide
* IsNull(expr) - renvoit booleen si null
* IsNumeric(expr) - renvoit booleen si nbr
* IsObject(identifier) - renvoit booleen si obj automation
* Oct(nbr) - conversion en string octal

## mathématiques

* Abs(nbr) - renvoie valeur absolue
* Atn(nbr) - renvoie arc tangent
* Cos(nbr) - renvoie cosinus
* Exp(nbr) - renvoie la puissance
* Int(nbr) - renvoie partie entière
* Fix(nbr) - renvoie partie entière
* Log(nbr) - renvoie log népérien
* Sqr(nbr) - renvoie racine carrée
* Tan(nbr) - renvoie tangente
* Sgn(nbr) - renvoie signe
* Randomize(nbr) - init nbr aleatoire !!les nombres ne sont pas aleatoire en vbs!!
* Rnd(nbr) - renvoie nbr aleatoire
* Round(expr,[numdecimalplaces]) - renvoie l'arrondi
* Sin(nbr) - renvoie sinus

## de traitement de chaînes

* Asc(string) - renvoie code ansi du 1er char
* Chr(charcode) - renvoie le char du code ansi
* inStr(start,string,string2,[compare]) - renvoie 1ère position d'un string dans un autre
* InStrRev(delimiter) - renvoie position d'un string dans un autre en partant de fin
* Join(string) - renvoie string joins partant d'un tableau
* LCase(string) - conversion en minuscule
* Left(string,length) - renvoie sous string partant de gauche
* Len(string) - renvoie nbr de char dans string
* LTrim(string) - renvoie string sans espace à gauche
* Mid(string,start,[length]) - renvoie sous string partant de milieu
* Replace(expr,find,replacement,[start],[count],[compare]) - remplace string dans string
* Right(string,length) - renvoie sous string partant de droite
* RTrim(string) - renvoie string sans espace à droite
* StrComp(string1,string2,[compare]) - renvoie valeur de comparaison de string
* String([nbr],[char]) - renvoie string de char repete
* StrReverse(string) - renvoie string inverse
* Space(nbr) - renvoie string de space
* Trim(string) - renvoie string sans espace ni gauche ni droite
* UCase(string) - renvoie string en majuscule

## de date et d'heure

* Date - renvoie date sys
* DateAdd(interval,nbr,Date) - renvoie date + interval. Ex : DateAdd("d", -1, now) affiche la date de la veille.
* DateDiff(interval,date1,date2,[firstdayofweek],[firstdayofyear]) - renvoie interval
* DatePart(interval,Date,[firstdayofweek],[firstdayofyear]) - renvoie partie spécifiée
* DateSerial(Year,Month,Date) - renvoie variant de type date
* DateValue(Date) - renvoie variant de type date
* Day(Date) - renvoie jour du mois
* Hour(Time) - renvoie heure
* Minute(Time) - renvoie minute
* Month(Date) - renvoie mois en chiffre
* MonthName(Month,[abbreviate]) - renvoie mois en lettre
* Now - renvoie date et heure sys
* Second(Time) - renvoie seconde
* Time - renvoie heure sys
* Timer - renvoie nbre de sec depuis 00:00
* TimeSerial(Hour,Minute,Second) - renvoit variant de type date
* TimeValue(Time) - renvoit variant de type date
* Weekday(Date,[fistdayofweek]) - renvoie jour semaine en chiffre
* WeekdayName(Weekday,abbreviate,firstdayofweek) - renvoie jour semaine en lettre
* Year(Date) - renvoie annee de date

## liées aux tableaux

* Array(arg) - renvoie variant contenant tableau
* Erase tableau - libère tableau
* Filter(InputStrings,Value,[Include],[compare]) - renvoie tableau commençant par 0 contenant sous ensemble de string
* LBound(arrayname,[dimension]) - renvoie plus petit indice tableau
* Split(expr,[delimiter],[count],[compare]) - renvoie tableau commençant par 0 comprenant # de string
* UBound(arrayname,[dimension]) - renvoie plus grand indice tableau

## Autres fonctions

* CreateObject(class) - renvoie ref à objet automation
* Eval(string) - renvoie resultat
* Execute ins - execute ins
* ExecuteGlobal ins - execute ins globale
* GetLocale - renvoie valeur ID parametre regionnaux sys
* GetObject([pathname],[class]) - renvoie ref à objet automation de fichier
* GetRef(string) - renvoie ref à procedure
* InputBox(prompt,[title],[default],[xpos],[ypos],[helpfile],[context]) - prompt
* LoadPicture([stringexpr) - renvoie img
* MsgBox(prompt,[buttons],[title],[helpfile],[context]) - msgbox
* RGB(red,green,blue) - renvoie int rgb
* ScriptEngine - renvoie string de script utilisé
* ScriptEngineBuildVersion - renvoie N° version
* ScriptEngineMajorVersion - renvoie N° version principale
* ScriptEngineMinorVersion - renvoie N° version secondaire
* SetLocate(Icid) - def param regionnaux globaux
* TypeName(varname) - renvoit string d'info sur variant
* VarType(varname) - renvoit valeur sous type de var
Pour déclarer ses propres fonctions, voir le chapitre Application.

# Objets

* Err - infos relatives aux erreurs d'exec
** Proprietes
       Description
       Helpcontext
       Helpfile
       Number
       Source
** Methodes
       Clear
       Raise(nbr,src,desc,hlpf,hlpcontext)
* RegExp - gestion des regular expr
** Proprietes
       Global
       IgnoreCase
       Pattern
** Methodes
       Execute(string)
       Replace(string1,string2)
       Test(string)
* Match - accès aux proprietes correspondant de regular expr
** Proprietes
       FirstIndex
       Length
       Value
* Matches - collection de match
** Proprietes
       Count
       Item(key)
* SubMatches - collection de sous-match
** Proprietes
       Count
       Item(key)

# Constantes

| CONSTANTE | VALEUR | DESCRIPTION |
| Chaînes de caractères |||
| vbCr | chr(13) | Retour chariot |
| vbCrlf | chr(13)+chr(10) | Retour chariot et saut de ligne |
| vbFormFeed | chr(12) | Saut de page |
| vblf | chr(10) | Saut de ligne |
| vbNewline | chr(13)+chr(10) | Nouvelle ligne |
| vbNullChar | chr(0) | 0 |
| vbNullString | chaîne ayant val. 0 | chaîne nulle |
| vbTab | chr(9) | tabulation horizontale |
| vbVerticalTab | chr(11) | tabulation verticale |
| Couleur |||
| vbBlack | &h000000 | Noir |
| vbRed | &h0000FF | Rouge |
| vbGreen | &h00FF00 | Vert |
| vbYellow | &h00FFFF | Jaune |
| vbBlue | &hFF0000 | Bleu |
| vbMagenta | &hFF00FF | Magenta |
| vbCyan | &hFFFF00 | Cyan |
| vbWhite | &hFFFFFF | Blanc |
| Comparaison |||
| vbBinaryCompare | 0 | Comparaison binaire |
| vbTextCompare | 1 | Comparaison texte |
| Date et heure |||
| vbSunday | 1 | Dimanche |
| vbMonday | 2 | Lundi |
| vbTuesday | 3 | Mardi |
| vbWednesday | 4 | Mercredi |
| vbThursday | 5 | Jeudi |
| vbFriday | 6 | Vendredi |
| vbSaturday | 7 | Samedi |
| vbUseSystem | 0 | Format de date des paramètres régionaux |
| vbUseSystemDayOfWeek | 0 | Jour semaine des paramètres régionaux |
| vbFirstJan1 | 1 | Utilise la semaine du 01 Janvier |
| vbFisrtFourDays | 2 | Première semaine avec 4 jours dans nouvelle année |
| vbFirstFullWeek | 3 | Utilise la première semaine complète de l’année |
| Format de date |||
| vbGeneralDate | 0 | Date et heure |
| vbLongDate | 1 | Date complète |
| vbShortDate | 2 | Date abrégée |
| vbLongTime | 3 | Heure complète |
| vbShortTime | 4 | Heure abrégée |
| MsgBox |||
| vbOkOnly | 0 | ok |
| vbOkCancel | 1 | ok/cancel |
| vbAbortRetryIgnore | 2 | abort/retry/ignore |
| vbYesNoCancel | 3 | yes/no/cancel |
| vbYesNo | 4 | yes/no |
| vbRetryCancel | 5 | retry/cancel |
| vbCritical | 16 | message critique |
| vbQuestion | 32 | demande avertissement |
| vbExclamation | 48 | exclamation |
| vbInformation | 64 | information |
| vbDefaultButton1 | 0 | bouton1 |
| vbDefaultButton2 | 256 | bouton2 |
| vbDefaultButton3 | 542 | bouton3 |
| vbDefaultButton4 | 768 | bouton4 |
| vbApplicationModal | 0 | boite modale pour l'application |
| vbSystemModal | 4096 | boite modale pour le système |
| VarType |||
| vbEmpty | 0 | non init (defaut) |
| vbNull | 1 | pas de data |
| vbInteger | 2 | sous-type integer |
| vbLong | 3 | sous-type long |
| vbSingle | 4 | sous-type single |
| vbDouble | 5 | sous-type double |
| vbCurrency | 6 | sous-type currency |
| vbDate | 7 | sous-type date |
| vbString | 8 | sous-type string |
| vbObject | 9 | objet |
| vbError | 10 | sous-type error |
| vbBoolean | 11 | sous-type booléen |
| vbVariant | 12 | variant pour tableau variant |
| vbDataObject | 13 | objet d’accès aux données |
| vbDecimal | 14 | sous-type decimal |
| vbByte | 17 | sous-type byte |
| vbArray | 8192 | tableau |
| Autres constantes |||
| vbObjectError | -2147221504 | num d'erreur doivent être supérieur |
| vbUseDefault | -2 | utiliser la valeur par défaut du paramètre |
| vbTrue | -1 | true |
| vbFalse | 0 | false |

# Codes d'erreur

Il y a deux types d'erreurs :
* Erreur de syntaxe : Une erreur de syntaxe empêche l'interprétation correcte du script.
* Erreur à l'exécution : Une erreur s'est produite durant l'exécution du script.

## Erreur de syntaxe

| NUMÉRO | DESCRIPTION |
| 1052 | trop de méthodes et propriétés |
| 1044 | parenthèses interdites |
| 1053 | classe sans argument |
| 1058 | 'default' que dans get |
| 1057 | 'default' + 'public' |
| 1005 | '(' attendu |
| 1006 | ')' attendu |
| 1011 | '=' attendu |
| 1021 | 'case' attendu |
| 1047 | 'class' attendu |
| 1025 | Fin d'instruction attendue |
| 1014 | 'end' attendu |
| 1023 | Expression attendue |
| 1015 | 'function' attendu |
| 1010 | Identificateur attendu |
| 1012 | 'lf' attendu |
| 1046 | 'ln' attendu |
| 1026 | Constante (int) attendue |
| 1049 | 'let', 'get', 'set' attendu |
| 1045 | Constante (string) attendue |
| 1019 | 'loop' attendu |
| 1020 | 'next' attendu |
| 1050 | 'property' attendu |
| 1022 | 'select' attendu |
| 1024 | Instruction attendue |
| 1016 | 'sub' attendu |
| 1017 | 'then' attendu |
| 1013 | 'to' attendu |
| 1018 | 'wend' attendu |
| 1027 | 'while' 'until' attendu |
| 1028 | 'while' 'until' ou fin d'instruction attendu |
| 1029 | 'with' attendu |
| 1030 | Identificateur trop long |
| 1014 | Caractère incorrect |
| 1039 | 'exit' incorrect |
| 1040 | Variable de ctrl de 'for' incorrecte |
| 1013 | Nombre incorrect |
| 1037 | Utilisation incorrecte de 'me' |
| 1038 | 'loop' sans 'do' |
| 1048 | Doit être défini dans la classe |
| 1042 | Doit être la première instruction de la ligne |
| 1041 | Nom redéfini |
| 1051 | Nombre d'argument inégal |
| 1001 | Mémoire insuffisante |
| 1054 | Argument manquant dans let ou set |
| 1002 | Erreur de syntaxe |
| 1055 | 'next' attendu |
| 1015 | Constante de chaîne non terminée |

## Erreur à l'exécution

| NUMÉRO | DESCRIPTION |
| 5 | Appel de procédure incorrect |
| 6 | Dépassement de capacité |
| 7 | Mémoire insuffisante |
| 9 | Indice hors plage |
| 10 | Tableau fixe ou verrouillé |
| 11 | Division par zéro |
| 13 | Type incompatible |
| 14 | Espace de chaîne insuffisant |
| 17 | Opération impossible |
| 28 | Espace pile insuffisant |
| 35 | Sub non définie |
| 48 | Erreur chargement de dll |
| 51 | Erreur interne |
| 91 | Var d'objet non définie |
| 92 | Boucle non init |
| 94 | Utilisation incorrecte de null |
| 424 | Objet requis |
| 429 | ActiveX ne peut pas créer l'objet |
| 430 | Classe ne gère pas automation |
| 432 | Fichier ou classe introuvable |
| 438 | Méthode ou propriété non géré |
| 445 | Objet ne gère pas action |
| 447 | Objet ne gère pas les param |
| 448 | Argument introuvable |
| 449 | Argument obligatoire |
| 450 | Nombre d'arguments ou propriété incorrect |
| 451 | Objet n'est pas une collection |
| 458 | Type automation non géré |
| 462 | Machine distante indisponible |
| 481 | Image incorrecte |
| 500 | Variable indéfinie |
| 502 | Objet non sécurisé pour script |
| 503 | Objet non sécurisé pour init |
| 504 | Objet non sécurisé pour création |
| 505 | Référence incorrecte ou non qualifiée |
| 506 | Classe non définie |
| 507 | Exception |
| 5008 | Affectation illégale |
| 5017 | Erreur syntaxique dans l'expression régulière |
| 5018 | Quantifiant inattendu |
| 5019 | ']' attendu dans l'expression régulière |
| 5020 | ')' attendu dans l'expression régulière |
| 5021 | Jeu de caractère incorrect |

# Application

Pour commencer, VBS comme tous les langages d'édition nécessite un éditeur de texte. Il doit être enregistré avec l'extension .vbs pour être reconnu par MIME et interprété par wscript.exe ou cscript.exe qui se trouvent dans le répertoire %system% de votre OS Windows.
* Pour écrire un .vbs, il faut au minimum un éditeur de texte comme notepad.exe et sauver le fichier en NomProgramme.vbs en mettant Type à "Tous les fichiers".
* Pour avoir une description complète des fonctions et de leurs paramètres, consulter le livre VBScript et ses liens externes.

## Qu'est-ce qu'un programme

Un programme est une suite d'instructions qui comporte des traitements sur des données.
* Légende des abréviations utilisées ici :
| cond | condition |
| arg | argument |
| ins | instruction |
| var | variable |
| cmt | commentaire |
| expr | expression |
| var | variable |
| res | résultat |
| str | string |
| > | Sortie |
| < | Entrée |

# Paradigme de programmation

Un programme fonctionne en termes d'entrée de données et de sortie de données. Les fonctions reçoivent des données (entrée de données) et les renvoient (sortie de données). Ces entrées et sorties (E/S) permettent à un programme d'être rédigé comme une pile d'instructions ou pipeline traitant/renvoyant des données. Pour concevoir un programme, il faut d'abord vous demander ce que vous voulez faire, c'est à dire le résultat à produire.
Les résultats peuvent être transmis à d'autres (sous)programmes.
* Qu'est-ce qu'une donnée ?
Une donnée est une valeur.
* Qu'est-ce qu'une expression ?
Une expression est un TERME comprenant des opérations sur données et qui produisent un résultat.
* Qu'est-ce qu'un résultat ?
Un résultat est une nouvelle donnée.
* Qu'est-ce qu'une instruction ?
Une instruction est une pile d'opérations sur données.
* Qu'est-ce qu'une variable ?
Une variable est une zone temporaire recevant une donnée. Elle doit commencer par une lettre. Une var CONSTANTE est une cellule de donnée permanente pour toute la durée du programme.
* Qu'est-ce qu'une condition ?
Une condition est une expression à TESTER.
* Qu'est-ce qu'un "type" ?
Un type est une façon d'interpréter une donnée. Il y a les nombres, les caractères, les chaînes de caractère, les tableaux...

# Notions élémentaires

* Faire un commentaire
Un commentaire est une ligne du programme qui commence par ' et qui indique au programme qu'il doit la sauter car ne faisant pas partie des [ins].
* Afficher un string
* Initialiser une variable <
Il n'est pas encore utile de définir le type de variable, par défaut entre "" c'est du [str] sinon c'est du [nbr].
* Introduire une donnée au clavier > sortie
La var msg reçoit la saisie clavier et la sort.
* Faire un programme qui calcule toutes les opérations sur 2 [nbr] <
! Dans ce programme, msgbox retourne un string. Ici cette chaîne est constituée par [str]&[expr]&VbCrLf&... VbCrLf passe à une nouvelle ligne et fait un retour chariot. _ permet de couper une [expr] en deux lignes.
* Faire une boucle qui calcule
Une boucle doit TOUJOURS avoir une condition d'arrêt sans quoi elle est infinie.
! les nbr sont initialisés avant de rentrer dans la boucle qui compte de 1 à 15 en rajoutant 1 à chaque tour de boucle.
* Même boucle avec [cond]
! Ici il a fallu incrémenter de 1 cpt dans cette boucle qui continue jusqu'à ce que cpt=15. Par défaut une var=0=null.
* Test booléen (#res={vrai,faux})
Si vous tapez 1 dans le prompt c'est >vrai. Pour avoir plusieurs instructions il faut adopter le format suivant :
! Ici [res] est la var pour la transmettre > msgbox il ne faut pas la mettre entre "" comme pour les str>[var].
* Test non-booléen (#[res]={[res1],[res2],...})
! Après le test de msg, il y a plusieurs cas possibles de [res]. Selon que on a entré 1 ou autre chose on est pipé -> vers le Case correspondant au [res] de la [var] msg.

## Type de variable

* VAR
Une var sous vbs est en mode auto, ainsi lorsque l'on affecte une valeur ou [expr] à, le [str] est typé en fonction de son contenu ce qui n'est pas toujours vrai en visual basic.
! On ne peut effectuer d'opération sur var1 et var2 en var3 car elles ne sont pas de même type. Seule la concaténation fonctionne ici.
* CONST
Une constante est une valeur qui ne change pas.
* ARRAY
Un tableau est une var contenant n cellule. On peut y stocker des [str]. Un array se déclare comme une var et reçoit des valeurs. Chaque cellule a un indice, ainsi la cellule n°n a l'indice n.
! La première cellule a l'indice 0. MonTableau(1) ou la deuxième cellule de MonTableau aura donc pour [str]="Cellule_1".

# Fonctions et procédures

À partir d'ici, pour une meilleure écriture et lisibilité des programmes, il est conseillé de séparer les parties déclaration et instruction :
    [var]
    [ins]
Les procédures et les fonctions constituent des sous programmes permettant de définir une pile d'[ins] qui ont pour point d'entrée le nom. Pour les exécuter il suffit d'appeler la méthode Call Nom([arg]) ou simplement Nom() si elle ne comporte pas d'[arg].Les [arg]/datas sont à passer en paramètre selon leur définition.
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. Private signifie que la fonction ou la procédure ne sera valable que dans l'espace du nom global qui l'encapsule, par exemple une classe ou le script en cours.
Pour déclarer leur nom, attention de ne pas prendre un nom déjà attribué. Voir librairie VBScript.

## Procédures

Sub permet de déclarer nom [args] et [ins] formant la procédure. Son but est d'exécuter des [ins].
    [Public [Default] | Private] Sub Nom_Procédure [(arg1,arg2,...)]
       [ins]
    End Sub
* Sans arguments
On déclare ici la procédure heure - sans [arg] - qui > now - procédure affichant heure sys. On appelle ensuite l'exécution de cette procédure.
* Avec arguments
Vous remarquez ici que Dim déclare [somme] en tête du sous-programme adi qui est appelé avec deux args/paramètres définis par adi(a,b).

## Fonctions

Function permet de déclarer nom [args] et [ins] formant la fonction. Son but est de retourner une valeur. Sinon, autant utiliser une procédure.
    [Public [Default] | Private] Function Nom_Fonction [(arg1,arg2,...)]
       [ins]
    Nom_fonction=[expr]
    End Function
La fonction à Nom_Fonction comme point d'entrée et retourne Nom_Fonction=[expr] en sortie. Vous comprenez maintenant ? Un programme c'est un pipeline, les [res] ne font que passer d'un bout à l'autre jusqu'au terminus, l'écran ou un fichier ou autre :)
! Il est impossible de créer Function à l'intérieur de Sub et réciproquement.
* Sans arg
* Avec arg
* Autre exemple
! Dans calc Round retourne directement l'arrondi. À la ligne 5, le pipe s'effectue de la plus petite parenthèse à l’intérieur, ici calc(10,20,30) pour retourner sa valeur a Abs qui retourne sa valeur en même temps que calc(15,10,2.5) > [str] > MsgBox qui affiche [str]. C'est simple comme 'Hello World'.

# Classe d'objets

En POO, une classe encapsule des données et [ins] définissant des propriétés [var] et méthodes [ins]. Les classes permettent de construire des objets types à réutiliser. L'instanciation consiste à créer un nouvel objet de classe. Un objet est donc une instance de classe.
    Class NomDeClasse
       [var]
       Private Sub Class_Initialize
          [ins]
       End Sub
       Private Sub Class_Terminate
          [ins]
       End Sub
       Public Function NomMethode([arg])
          [ins]
       End Function
    End Class
* Application
! On initialise et on termine une classe pour libérer la ressource après usage. On déclare plusieurs fonctions qui sont les méthodes à appeler. Les Init et Termin sont en private car utile que dans la classe, en revanche toute autre function ou sub doit être public pour l'E/S hors classe.
Pour utiliser une classe :
* on initialise d'abord l'objet obj= new NomDeClass;
* on appelle la méthode dans l'objet obj.NomDeFonction([arg]);
* comme dans fonction ordinaire [arg] [var] [expr] < en parametre ;
* Voir cet article

# E/S fichier

Le programme suivant crée un fichier, en supprimer un autre, puis copie le premier$^,$ :
VBS peut aussi faire plus en utilisant WSH (Windows Script Host).
Pour lire et écrire dans un fichier, utiliser la méthode OpenTextFile du FileSystemObject.

# Bases de données

Pour encapsuler du SQL dans du VBS pour Microsoft SQL Server, créer une connexion ADOdb :
Théoriquement plusieurs SGBD peuvent être manipulés en changeant le paramètre Provider (ou driver).

## Références

* ↑ http://www.devguru.com/technologies/vbscript/quickref/filesystemobject_deletefile.html
* ↑ http://msdn.microsoft.com/en-us/library/e1wf9e7w%28v=vs.85%29.aspx
* ↑ http://www.computing.net/answers/programming/vbs-set-subdirectories-files-too/9928.html
* ↑ http://msdn.microsoft.com/en-us/library/t5399c99%28v=vs.84%29.aspx
* ↑ http://stackoverflow.com/questions/11143764/vbscript-and-sql-server-2008-questions
* ↑ http://drq.developpez.com/vb/tutoriels/ADO/Chapitre2/
* http://www.activexperts.com/activmonitor/windowsmanagement/adminscripts/filesfolders/folders/