tout sur le batch

Quelques informations indispensables

Malheureusement, la majorité des sources intéressantes qui pourront vous aider à approfondir les techniques de la programmation Batch sont souvent en anglais…
« Xset » est un outil indispensable pour appendre à écrire des fichiers Batch sous toutes les versions de Windows. De plus, Marc Stern propose de nombreux didacticiels à partir de son site Internet : http://xset.tripod.com.
Jerold Schulman qui m’a autorisé à citer quelques-uns de ces scripts anime un site Internet qui propose d’innombrables pages sur la programmation Batch : http://www.jsiinc.com. C’est, par ailleurs, un des meilleurs sites traitant des systèmes NT de Windows.
D’excellents scripts sont également visibles à partir de cette adresse : www.uwasa.fi/~ts/http/http2.html#batch. Timo Salmi propose une multitude de solutions permettant de résoudre les problèmes les plus courants quand on commence à se lancer dans la programmation Batch.
Ritchie Lawrence met en lignes de nombreux modèles de scripts et propose quelques utilitaires fort bien faits qui vous permettront de réaliser des choses étonnantes en mode Ms-Dos ou en Invite de commandes. L’adresse de son site est la suivante : http://www.commandline.co.uk/index.html.
Enfin, une source inépuisable de trouvailles sont proposées à partir de ce forum recouvrant une multitude de thématiques dont Ms-Dos et l’Invite de commandes : http://www.experts-exchange.com/Operating_Systems/MSDOS.
La plupart des exemples de scripts expliqués dans ce chapitre s’inspirent directement ou indirectement des techniques présentées par ces différents auteurs.

Créer un fichier Batch
Le terme « Batch » désigne un fichier contenant une suite de commandes qui seront traitées automatiquement. Nous appelons aussi cela un « traitement par lot ». Afin de créer votre premier fichier Batch suivez cette procédure :
1) Ouvrez un éditeur de texte : le Bloc-notes par exemple.
2) Inscrivez vos lignes de commandes.
3) Enregistrez votre fichier texte.
4) Cliquez sur le nom du fichier puis appuyez sur la touche F2.
Vous serez en mode « Édition ».
5) Renommez le fichier en changeant l’extension .txt en .bat.
À la question : « Voulez-vous vraiment renommer le fichier », répondez par Oui.
Attention de désactiver au préalable la case « Masquer les extensions de fichiers dont le type est connu » dans les options avancés de l’Explorateur Windows.

Quelle différence entre l’extension .cmd .btm et .bat ?
Un fichier .cmd ou .btm ne sera pas reconnu en tant que tel par Windows 9X. Nous pouvons voir cela comme une sorte de garde-fou si tel fichier de commande est parfaitement incompatible avec ces versions de Windows. Par ailleurs, le processus est légèrement différent :
Dans le cas d’un fichier .bat ou .cmd, chaque ligne du fichier est exécutée individuellement et le fichier fermé puis ouvert à chaque lecture d’une nouvelle commande. Dans le cas d’un fichier .btm, le fichier n’est ouvert qu’une fois, puis lu en mémoire et enfin fermé. C’est donc a priori le mode le plus rapide. surtout si ce sont des commandes internes qui sont exécutées.

Savoir se servir de la commande Echo
Dans un nouveau fichier Batch, copiez ce contenu :

echo La commande Echo est active
@echo
date /t
echo off
date /t
@echo off
date /t

L’utilisation de l’arobase permet de biffer le statut de la commande « Echo ».
Par ailleurs, la commande « Echo off » évite l’affichage des commandes contenues dans le script.

Se servir des parenthèses dans les fichiers de scripts
Si vous souhaitez rediriger le résultat de différentes commandes dans un même fichier texte. Par exemple :

dir /s /b *.doc >> résultat.txt
dir /b *.dot >> résultat.txt
etc.

Il est dans ce cas plus simple de saisir :

(
dir /s /b *.doc
dir /s /b *.dot
) >> résultat.txt

Cela vous évitera de spécifier plusieurs fois le même fichier de sortie. Par ailleurs, c’est une manière de créer de toutes pièces un fichier texte :
@echo off
(
@echo Bonjour,
@echo Tout le monde !
) > test.txt

Dans ce dernier cas, les commandes sont regroupées.

Faire des remarques
La commande « Rem » vous permet d’insérer des commentaires ou de désactiver temporairement des commandes inclues dans votre fichier batch. Ce n’est pas tout à fait vrai. La commande rem echo quelque chose > Sortie.txt ne fait qu’envoyer rien au fichier Sortie.txt. La commande est donc exécutée mais en mode « désactivé ». Une sorte de coup à blanc… Pour les amoureux de la performance il est donc plus judicieux d’utiliser :: plutôt que Rem. Les deux points étant considéré comme l’indication d’une étiquette la commande ne sera pas exécutée. À titre de test saisissez tour à tour ces deux commandes :
rem echo A
:: echo B
La seconde commande provoque un retour chariot et non un saut de ligne.
Dans un fichier Config.sys il est possible de désactiver une commande en utilisant un point virgule : ;connexion=c:\dos\ramdrive.sys

Afficher le code de sortie
À chaque fois que vous saisissez une commande, cette dernière produit un code de sortie qui sont principalement les suivants :
1 : la commande a renvoyé une erreur
0 : la commande n’a pas renvoyé d’erreur.
C’est la variable %Errorlevel% qui est chargée de suivre les fluctuations de la réussite ou non des commandes exécutées.
Information : La commande « Set » teste les « Errorlevel » en partant de la plus petite valeur puis en procédant par incrémentation de 1. La commande « Goto » démarre de la plus grande valeur puis procède par décrémentation de 1.

Se servir des étiquettes
La commande « Goto » vous permet d’atteindre un point précis de votre script. La commande spécifiée doit porter un titre que nous appelons une étiquette. Cette ligne de titre commence obligatoirement par deux points. Nous sommes obligés d’anticiper quelque peu sur l’explication des conditions car c’est une des utilisations privilégiées des étiquettes. Dans un nouveau fichier Batch copiez ce contenu :

@echo off
dir *.doc
if not errorlevel 1 goto Fin else if goto Avertissement
:Avertissement
echo Aucun fichier .doc !
:Fin

La variable %Errolevel% nous permet de saisir si la commande « Dir » a renvoyé une valeur 1 (« Échec ») ou 0 (« Opération réussie »). Si au moins un fichier .doc est trouvé nous allons directement à l’étiquette :Fin. Ou, plus exactement si la sortie d’erreur n’est pas 1 (« Échec »), alors il faut se rendre à l’étiquette :Fin. Sinon (else if) nous nous rendrons à l’étiquette :Avertissement. Si nous rajoutons une commande à la suite de l’étiquette :Fin, cette dernière sera automatiquement exécutée même si la condition n’est pas remplie. Afin d’éviter cela, il nous faut nous servir d’une étiquette spéciale : goto:eof. Notre fichier script devient alors :

@echo off
dir *.doc
if not errorlevel 1 goto Fin else if goto Avertissement
:Avertissement
echo Aucun fichier .doc ! & goto:eof
:Fin
echo Processus fini !

Dans ce dernier cas, la commande goto:eof nous permet d’effectuer une césure dans le script. Cela revient à dire : « Affiche le message ‘Aucun fichier .doc !’ puis ne fait plus rien ». En termes savants, puisque nous ne définissons pas d’étiquette, nous transférons le contrôle à la fin du script en cours.

Gérer les caractères accentués
Les différences entre la norme Ansi (Windows) et OEM (Ms-Dos) font que si vous vous servez d’un éditeur de texte comme le Bloc-Notes les caractères accentués ne s’afficheront pas correctement dans les sorties écran en mode « Console ». Ainsi, la phrase « Je répète : « Vous êtes un entêté » » s’affichera comme cela : Je rÚpÞte : « Vous Ûtes un entÛtÚ ». Il y a différentes solutions :
Vous pouvez toujours vous servir de l’éditeur de texte prévu dans toutes les versions de Windows : « Edit ».
ll existe de nombreux programmes vous permettant d’opérer la conversion Ansi vers OEM et vice-versa. « OEMANSI.exe » est un programme écrit en français que vous pouvez télécharger à partir de cette adresse : http://perso.wanadoo.fr/andre.araste/tele2.htm. Décompressez l’archive ZIP nommée Oemansi.zip puis double-cliquez sur ce fichier exécutable : Setup.exe afin de lancer l’installation de ce logiciel.
Imaginons que notre fichier à convertir s’appelle Test.bat suivez la procédure suivante :
1) Cliquez sur Démarrer/Tous les programmes/OEMANSI/OEMANSI.
2) Cliquez sur le bouton Ouvrir Fichier.
3) Dans la liste déroulante Fichiers de type :, sélectionnez Tous les fichiers (.) puis votre fichier Batch.
4) Cochez le bouton radio ANSI(Win) puis la flèche dirigée vers le bas.
Il est possible d’effectuer l’opération inverse !
5) Cliquez sur le bouton Sauvegarde OEM puis lancer le processus de conversion.
6) Confirmez le remplacement ou non de l’ancienne version.

Gérer les caractères réservés
Ces caractères ne peuvent pas être employés « tel quel » dans un script. Le signe % pour être « compris » dans un fichier de script doit être redoublé. Par ailleurs, nous avons déjà vu que pour afficher un caractère réservé il faut le faire précéder du signe ^. Dans ce cas là, il ne sera pas assimilé à une commande mais bien à un caractère. Afin d’afficher les signes : ! ^ & < > >>  » | créez un fichier Batch contenant cette commande :
echo ^! ^% ^^ ^& ^< ^> ^>^> ^ » ^|
Une manière d’afficher les caractères de redirection :
@echo off
sortie.txt
Nous redirigeons le produit de la commande « Set » vers le fichier Sortie.txt mais en désactivant toute sortie écran. L’utilisation de la commande « Set » est expliquée juste après.

Manipuler les variables en Invite de commandes
L’Invite de commandes a prévu un certain nombre de variables internes :

Nom de la variable – Fonction
%CD% Affiche le répertoire courant.
%DATE% Affiche la date.
%TIME% Affiche l’heure.
%RANDOM% Affiche une valeur décimale comprise entre 0 et 32767.
%ERRORLEVEL% Affiche le code d’erreur renvoyée par la précédente commande.
%CMDEXTVERSION% Affiche la version du processeur de commande.
%CMDCMDLINE% Affiche la ligne de commande originelle invoquée par le processeur de commande.

La commande Set p affiche toutes les variables commençant par la lettre P. Une suite possible de commandes est :
set variable=c:\test
set variable
Nous pouvons vérifier que notre variable est bien égale à C:\Répertoire. Nous pouvons également saisir :
dir %variable%
Le contenu de l’arborescence C:\Test s’affichera.
Une autre manière consiste à saisir le nom de l’arborescence à la suite du nom du fichier de commande. Par exemple : batch c:
Le script nommé Batch permettant de lister les fichiers texte du répertoire indiqué aura alors ce contenu :
dir %1%*.txt
Nous pouvons procéder à l’extraction de tous les caractères à l’exception des trois premiers. Saisissez donc :
set 1=dir *.txt
echo %1:~3%
echo %1:~-3%
Seuls les trois derniers caractères seront affichés.
echo %1:~0,-4%
Tous les caractères seront affichés à l’exception des 4 derniers.
echo %1:~0,3%
Nous afficherons les trois premiers caractères de la variable passée précédemment.
echo %1:~4,5%
Dans ce dernier cas, 5 caractères seront affichés en partant du 4ème caractère.
Attention : si vous utilisez un caractère réservé dans votre variable, ce dernier doit être « signalé ». Afin de passer une variable nommée Test&1 il vous faudra saisir : set x =test^&1
Si vous ne faites pas précéder le caractère réservé du signe ^ vous aurez droit à un message d’erreur salé !
Par exemple, saisissez ces commandes :
set x=%time%
set y=%date%
echo %x% %y%
echo %x:~0,5% %y%
Nous reprenons deux variables internes pour définir deux nouvelles variables nommées x et y.
Il est possible de cacher tous les répertoires en saisissant cette commande :
set dircmd=0
Le contenu des arborescences restera invisible bien que leur accès reste possible. Afin de revenir à la situation précédente, saisissez :
set dircmd=
Astuce : Il est possible d’assigner à une variable un nombre aléatoire. Saisissez ces commandes :
set variable=%random%
echo %variable%
Tilmo Salmi sur cette page web : www.uwasa.fi/~ts/http/http2.html#batch signale un problème concernant l’utilisation de la commande « Echo » quand cela s’applique aux variables. Comparez la sortie écran de ces deux fichiers Batch :

@echo off
set variable=Ceci est un test
echo %variable%
set variable=
echo %variable%

@echo off
set variable=Ceci est un test
echo. %variable%
set variable=
echo. %variable%

Seul le second fichier Batch n’affiche pas d’erreur. L’explication est simple : la commande « Echo » suivie d’un point force l’affichage d’une ligne vide.

« Transtyper » une variable
Il est donc possible de modifier une variable en additionnant à sa définition toute sorte de chaîne de caractères. Cette opération s’appelle du « transtypage ». Par exemple, saisissez ces commandes :
set datation =La date d’aujourd’hui est le %date%
set datation
Créez un nouveau fichier Batch contenant :

@echo off
set chaîne=[Ceci n’est qu’un test]
set chaîne=%chaîne:[=%
set chaîne=%chaîne:]=%
echo %chaîne%

Dans cet exemple, nous ne faisons que dire qu’aux caractères [ et ] rien ne correspond (et donc ils ne s’afficheront pas).
Le script suivant affichera : (Ceci n’est qu’un test)

set chaîne=[Ceci n’est qu’un test]
set chaîne=%chaîne:[=(%
set chaîne=%chaîne:]=)%
echo %chaîne%

Nous pouvons remplacer la deuxième et troisième ligne par :
set chaîne=%chaîne:~1,21%
Cela appelle deux remarques :

• La numérotation commence à partir de zéro : au caractère [ correspond donc le numéro 0.
• Les espaces sont comptés.
  Afin de convertir une chaîne de caractères de minuscules en majuscules :

@echo off
set chaîne=%1
set chaîne=%chaîne:a=A%
set chaîne=%chaîne:b=B%
set chaîne=%chaîne:c=C%
::Vous pouvez indiquer toutes les lettres de l’alphabets…
set chaîne=%chaîne:y=Y%
set chaîne=%chaîne:z=Z%
echo %chaîne%

Nous passons dans un premier temps une variable nommé %chaîne% qui sera la chaîne de caractère saisie par l’utilisateur ou, si nous préférons, le premier paramètre saisi à la suite du nom du fichier Batch : %1.
Le reste du script opère la substitution des variables en changeant à chaque fois la casse de la lettre.

Créez un formulaire permettant de récupérer une ou plusieurs variables
En Invite de commandes la solution est assez simple… Saisissez ces commandes :
set /p Variable=Veuillez entrer votre nom:
set variable
Il est donc possible de se servir de « Set » en lieu et place de « Choice ». Créez un nouveau fichier Batch en copiant les lignes suivantes :

@echo off
:début
echo 1 : Menu1
echo 2 : Menu2
echo 3 : Menu3
set /p choix=choisissez un chiffre.
if not %choix%== » set choix=%choix:~0,1%
if %choix%==1 goto Menu1
if %choix%==2 goto Menu2
if %choix%==3 goto Menu3
echo %choix% n’est pas bon !
goto début
:Menu1
echo Bonjour & goto:eof
:Menu2
echo Au revoir & goto:eof
:Menu3
echo Adieu & goto:eof

Les quatre premières lignes affiche un formulaire. La quatrième ligne nous permet d’attendre que l’utilisateur ait saisie la chaîne qui sera associée à la variable %choix% que nous allons définir. Dans ce cas le commutateur /p est obligatoire.
Si l’utilisateur appuie sur la touche Entrée sans avoir saisi de chiffre, la variable %choix% sera défini sur le chiffre 2. Pour vous en rendre compte saisissez ces commandes :
set choix=%choix:~0,1%
echo %choix%
Dans ce cas, nous nous rendons directement à l’étiquette n°2 : Menu2.
Si le chiffre saisi n’est ni 1, 2 ou 3 alors il sera affiché un message d’erreur puis nous retournerons en début de script à l’étiquette :début.
Chaque menu affiche un message puis termine l’exécution du script par la commande goto:eof.
Nous savons donc qu’il est possible de spécifier plusieurs conditions « à la chaîne ». Il suffit de dire que si aucune des trois premières conditions n’a été remplie alors c’est que la saisie de l’utilisateur n’est pas valable. C’est la seule petite astuce de ce script !

Faire des calculs en Invite de commandes
Une possibilité consiste à utiliser la commande « Set ». Saisissez ceci :
set /a z=356/356/1*356
Le tableau suivant présente les opérateurs autorisés avec le commutateur /a par ordre de priorité décroissante :

Opérateur – Opération effectuée
< > Groupement

• / % + – Calcul
  << >> Décalage logique
  & ET au niveau du bit
  ^ OU exclusif au niveau du bit
  | OU au niveau du bit
  = *= /= %= += -= &= ^= |= <<= >>= Attribution
  , Séparateur d’expression

Toute chaîne non numérique est traitée comme un nom de variable dont les valeurs sont converties en nombre avant d’être utilisées.
Si une variable est traitée sans être définie dans l’environnement en cours, sa valeur sera égale à zéro. L’ajout du signe % est donc inutile.
Il est facile d’imaginer une variable qui soit celle-ci : 0010. Nous pouvons supprimer les zéros placés devant en saisissant cette commande :
set /a variable=100%variable%%100
Avec l’opérateur % est effectuée une division modulo. Dans une division modulo, les deux valeurs sont divisées mais le résultat n’est que le reste de la division. Si vous saisissez : 19 % 5, vous obtenez comme résultat modulo 4, parce que 19 divisé par 5 égal 3 reste 4. Afin de le vérifier, saisissez ces commandes :
set /a variable=19
set /a variable=%variable%%5
Par ailleurs, si vous saisissez cette commande :
set /a variable=0010
Vous obtenez comme résultat le chiffre 8. En fait, les nombres sont en notation décimale à moins qu’ils ne soient préfixés par 0x pour les valeurs hexadécimales ou par 0 pour la notation octale. Il est donc possible d’obtenir instantanément la valeur décimale d’un chiffre hexadécimal. À titre de test, saisissez ceci : set /a 0x3e7.
Astuce : Ce type de commande marche : (set /a 75 /15) > sortie.txt.
Voici un exemple de script tout simple :

@echo off
call :fonction %1 %2
echo La somme est %somme%
call :soustraction %1 %2
echo La soustraction est %soustraction%
goto :eof
: fonction
set /a somme=%1+%2
: soustraction
set /a soustraction=%1-%2

Saisissez le nom de votre fichier Batch suivi des deux éléments de l’opération. Nous récupérons les deux paramètres en nous servant des variables %1 et %2. La commande « Set /a » nous permet de calculer la valeur respective des variables %somme% et %soustraction%.
Justifier un nombre inclus dans une variable
Dans un nouveau fichier batch ciopiez ce contenu :

@echo off
set nombre=%1
if %1 lss 10000 set a=
if %1 lss 1000 set a=0
if %1 lss 100 set a=00
if %1 lss 10 set a=000
set nombre=%a%%nombre%%
set nombre=%nombre: »=%
echo %nombre%

Saisissez le nom de votre fichier batch suivi du nombre à justifier. Nous récupérons le paramètre saisi par l’utilisateur en vérifiant si le nombre et inférieur à 10000 puis à 1000 et ainsi de suite. À chaque fois nous définissons une variable nommé %a% que nous ferons précédée à la variable %nombre%. L’avant dernière ligne nous permet simplement de supprimer les guillemets de la variable obtenue.

Localiser les variables d’environnement
Les modifications d’environnement définies par la commande « Setlocal » ne sont appliquées localement qu’à votre fichier de commandes. Lorsqu’une commande « Endlocal » est rencontrée, les paramètres précédents sont rétablis. Il n’est pas possible d’utiliser ces variables indépendamment d’un script ou d’un fichier de commandes.
Il nous est ainsi possible d’appeler un fichier de commandes situé à un emplacement différent de celui à partir duquel nous lançons le premier fichier de commandes. Par exemple, créez un fichier nommé A.bat contenant ces lignes :

@echo off
setlocal
path=F:\;%path%
call B >c:\sortie.txt
endlocal
start notepad c:\sortie.txt

Créez un autre fichier nommé B.bat que vous placerez sur un autre lecteur (dans cet exemple F:) et qui contiendra la commande à exécuter :
dir *.txt

Lancez le fichier A.bat…
La commande path=F:\;%path% nous permet de préciser que la variable définie %F:% vient s’ajouter aux autres chemins prédéfinis par la variable d’environnement %path%.
La commande call B appelle à partir du fichier A.bat le fichier B.bat. cela revient à lancer l’exécution d’un second script à partir d’un premier script.
Si nous avions pas ajouter le lecteur F: dans le « Path », le fichier B.bat n’aurai pas été trouvé.
Les commandes « Setlocal » et « Endlocal » ne sont là que pour éviter un éventuel conflit entre la définition d’un même nom de variable dans un même script ou entre deux scripts exécutés au cours de la même session d’Invite de commandes.

Définir différentes variables dans un fichier Batch
Imaginons que nous souhaitons pouvoir exécuter trois commandes différentes en fonction des circonstances. Dans un nouveau fichier Batch, copiez le texte suivant :

@echo off
if {%1}=={c} set lecteur=c:\&goto Dir
if {%1}=={d} set lecteur=d:\&goto Dir
if {%1}=={e} set lecteur=e:\&goto Dir
@echo Saisissez le nom du fichier Batch suivi d’un espace puis appuyez sur la touche C D ou E
:Dir
dir %lecteur% > %lecteur%\Sortie.txt

Nous nous servons du premier paramètre saisi par l’utilisateur à la suite du nom du script : %1. Si, par l’exemple, la touche appuyée est la lettre C alors nous définissons une variable nommée %Lecteur% qui sera égale à c:\ puis nous nous rendons à l’étiquette nommée :Dir.
Si la touche choisie n’est ni C, D ou E alors un message sera affiché.
Dans le cas contraire, un fichier nommé Sortie.txt sera créé à la racine du lecteur analysé.

• Autoriser ou non les variables temporisées :
  Créez un premier fichier Batch contenant ceci :

set variable=avant
if « %variable% » == « avant » (
set variable=maintenant
if « %variable% » == « maintenant » @echo Si vous voyez ceci le script marche
)

Si vous l’exécutez le message ne sera pas affiché.
Nous créons une variable nommée %avant%. Si notre variable correspond à la chaîne de caractères %avant% alors nous assignons à cette variable une nouvelle chaîne nommée %maintenant%. La dernière condition pose ceci : si notre variable est égale à %maintenant% alors affiche un message. Comme la variable a été fixée sur %avant% la condition n’est pas remplie et donc le message pas affiché. Créez un autre fichier Batch avec cette fois-ci ce contenu :

setlocal EnableDelayedExpansion
set Variable=avant
if « %Variable% » == « avant » (
set Variable=après
if « !Variable! » == « après » @echo Si vous voyez ceci le script marche
)

Dans ce dernier cas les variables sont assignées dynamiquement et leur affectation vient écraser celle qui leur avait été au préalable assignée. Il y a plusieurs manières d’assigner des variables de manière dynamique :

• Insérez une variable d’environnement en utilisant la commande « Setlocal EnableDelayedExpansion ».
• Lancez l’interpréteur de commandes en utilisant le commutateur /V:ON.
• Modifiez directement le Registre :
  1) Cliquez sur Démarrer/Exécuter puis saisissez : regedit
  2) Ouvrez HKEY_CURRENT_USER\Software\Microsoft\Command Processor.
  3) Dans le volet de droite créez une nouvelle valeur DWORD nommée DelayedExpansion.
  4) Éditez cette valeur et affectez comme données de la valeur le chiffre 1.
  5) Quittez puis relancez « cmd ».
  Il est possible d’opérer la même modification dans l’arborescence HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor si vous souhaitez que les modifications soient opérationnelles pour l’ensemble des utilisateurs de votre machine. Comparez ces deux fichiers Batch :
  @echo off
  setlocal EnableDelayedExpansion
  set Liste=
  for %%a in (*) do set Liste=%%a& echo !Liste!

@echo off
set Liste=
for %%a in (*) do set Liste=%%a& echo %Liste%

Dans ce dernier cas, rien ne sera affiché.
Le premier script affichera le contenu du répertoire courant (*). Nous assignons à chaque nouvel objet trouvé (fichier ou répertoire) la variable %liste% que nous affichons en utilisant la commande « Echo ».

Déplacer la position des paramètres de commandes
Dans un nouveau fichier de commandes appelé Test.bat, copiez le texte suivant :

@echo off
:Copie
shift
if « %1″== » » goto Fin
copy %1 c:\sauvegarde
goto Copie
:Fin

Saisissez par exemple : test *.txt *.doc *.bat *.bmp *.ppt *.eml
Nous allons donc copier tous les fichiers spécifiés du répertoire courant vers le répertoire C:\Sauvegarde. Le principe consiste à utiliser la commande « Shift » qui remplacera la variable %0 par la variable %1 (.doc), la variable %1 par %2 (.bat) une fois la première commande terminée (et ainsi de suite). En l’absence de la commande « Shift » nous chercherions désespérément un fichier introuvable… Il est donc possible de créer un fichier de commandes qui accepte plus de dix paramètres (de 0 à 9) puis que les arguments situés à partir de la dixième position seront décalés un à un afin d’occuper la variable %9.
La commande spécifiant une condition nous permet d’éviter de rentrer dans une boucle sans fin. Si la variable actuelle est la même chose que rien («  ») alors nous allons à l’étiquette :Fin. Dans un premier temps, nous avons donc cette commande : if « *.txt »== » » goto fin. Comme *.txt est différent de rien, nous retournons à l’étiquette :Début. S’il n’y a plus aucun paramètre trouvé, nous poserons alors la condition suivante : if «  »== » » goto Fin.
Et là, dans ce cas, le script prend fin !
Il y a une manière légèrement différente qui nous permet de spécifier le répertoire de destination. Dans un nouveau fichier Batch copiez ces lignes :

@echo off
set variable=%1
:Copie
shift
if « %1″== » » goto Fin
copy %1 %variable%
goto Copie
:Fin

Saisissez le nom de votre fichier Batch suivi du répertoire de destination et des fichiers à copier. Par exemple : test c:\sauvegarde *.txt *.xls *.doc *.bat *.bmp *.ppt *.eml
La première variable %1 passe le premier argument saisi : le répertoire de destination.
Nous définissons cette première variable sous le nom de %variable%.
L’étiquette :Copie annonce les commandes permettant le processus de copie.
La commande « Shift » décale la variable : %1 devient %0. Nous avons donc simplement défini le répertoire de destination. Pour le reste le principe de fonctionnement est strictement identique au script précédent.

Appeler un programme à partir d’un autre programme
La commande « Call » vous permet d’appeler un programme sans que le programme « parent » soit stoppé. Créez un fichier de commandes nommé Test.bat contenant simplement ces lignes :
dir %1 /s> %2
Pour envoyer le contenu d’un répertoire dans un fichier nommé Sortie.txt, saisissez :
test . sortie.txt
La première variable %1 est donc défini sur le répertoire par défaut (.) et la seconde (%2) sur le nom du fichier de sortie (Sortie.txt). La commande fonctionne quelque soit le répertoire par défaut et le nom du fichier de sortie. Nous aurions également pu saisir : test c:\Documents and settings\ sortie.txt
Créez un nouveau fichier de commande contenant ces lignes :

@echo Le nom du script est : %0
@echo Le nom de la variable 1 est : %1
@echo Le nom de la variable 2 est : %2
@echo Le nom de la variable: 3 est : %3

Enregistrez le sous le même nom. Saisissez maintenant :
test Jean Marc Michel
Créez maintenant un nouveau fichier de commande contenant ces lignes :

@echo off
Call :Chemin & goto:eof
:Chemin
@echo Voici le chemin: %~dp0

Ce script donne tout bêtement le chemin d’accès du répertoire courant.
La commande « Call » appelle une étiquette nommée :Chemin.
La variable %~dp0 permet d’obtenir la lettre de lecteur et le chemin de l’arborescence visitée.
L’appel vers l’étiquette :eof permet d’arrêter l’exécution du script une fois le chemin affiché.
Vous pouvez placer ce script là où vous voulez puisqu’il aura toujours la capacité de retrouver le répertoire courant et les commandes qui seront placées dans la même arborescence.
Il vous est possible de passer différentes variables si la commande principale en contient plusieurs. Créez un fichier de commande (appelé A) contenant ces lignes :
call b %1 %2
Et un second fichier (appelé B) contenant ceci :
dir %1%*.*
dir %2%*.*
Saisissez cette commande : a c: c:\temp
Le fichier de commande A appelle le fichier B en lui passant les deux variables que vous avez saisies : %C:% et %C:\Temp%.
Par ailleurs, il est possible de se servir des commande « Call » et « Goto » pour créer des sous-routines. Vérifiez la sortie écran produite par ce « Batch » :

@echo off
echo commande1
call :echo2
echo commande4
goto :eof
: echo2
echo commande2
call :echo3
goto :eof
: echo3
echo commande3
goto :eof

L’avantage de la commande « Call » sur un simple appel d’étiquette induit par la commande « Goto » est que le déroulement du script n’est pas interrompu. Nous appelons simplement les instructions contenues sous l’étiquette puis reprenons le déroulement de notre « Batch » là où nous l’avions laissé.

Les structures de contrôles
Cette partie concerne toutes les opérations vous permettant de récupérer des paramètres, la sortie d’une commande ou les saisies effectuées par les utilisateurs.

Exécuter une commande pour un jeu de fichiers
La syntaxe générale est celle-ci :
For {%variable|%%variable} in (jeu) do commande [Options_Ligne_Commande]
Prenons tout d’abord un exemple… Si nous souhaitons afficher le contenu de tous les fichiers .txt et .doc du répertoire courant, nous saisirons :
for %1 in (*.doc *.txt) do type %1
Signalons que la variable peut être un chiffre ou une lettre (par exemple, %a fait aussi bien l’affaire).
Astuce : Si nous utilisons cette commande dans un fichier de commande le signe % doit être redoublé.
Jeu représente les noms de fichiers et doit être placé entre parenthèses.
Les mots clés in et do sont possibles lors de l’utilisation de la commande « For ». Nous pouvons les traduire par ceci : Pour tous les fichiers présents dans (in) ce jeu de fichiers exécute (do) cette commande. Il vous est possible d’utiliser les paramètres spécifiques à chaque commande (Options_Ligne_Commande).
Une manière de lister les noms seuls des fichiers exécutables du répertoire courant est de saisir :
for %a in (.exe) do @echo %a La simple liste de tous les fichiers (à l’exception des répertoires) s’obtient en saisissant : for %a in () do @echo %a

Exécuter une commande de manière récursive
En Invite de commandes si vous souhaitez afficher tous les sous-répertoires appartenant à votre profil vous saisirez :
for /r « %userprofile% » %a in (.) do @echo %a
Quand Jeu est simplement un point, c’est l’arborescence principale qui est énumérée.
Si vous souhaitez simplement lister les sous-répertoires de l’emplacement par défaut saisissez :
for /r %a in (.) do @echo %a
Afin de supprimer tous les fichiers .doc de l’emplacement par défaut il suffit de saisir :
for /r %a in (*.doc) do del /q « %a »

Gestion des noms comprenant des espaces
La commande suivante ne fonctionnera pas si le nom d’un des fichiers .doc ou .txt contient des espaces :
for %a in (*.doc *.txt) do copy %a c:\temp\
Vous devez dans ce cas mettre la seconde variable entre guillemets :
for %a in (*.doc *.txt) do copy « %a » c:\temp\

Effectuer une substitution de variable
Il est possible de changer les variables de sortie. Par exemple, si nous saisissons cette commande :
for /r %a in (*.txt) do @echo %~na
Seuls les fichiers .txt seront affichés.
La liste ci-dessous récapitule les variables de substitution ainsi que les combinaisons permises. Rappelons que la variable %a peut être remplacée par n’importe quelle autre lettre de l’alphabet ou chiffre.

%~a : développe %a en supprimant les guillemets.
%~fa : développe %a en un nom de chemin complet.
%~da : développe %a en une lettre de lecteur seulement.
%~pa : développe %a en un chemin seulement.
%~na : développe %a en un nom de fichier seulement.
%~xa : développe %a en une extension de fichier seulement.
%~sa : développe le chemin afin qu’il ne contienne que des noms courts.
%~aa : développe %a jusqu’aux attributs du fichier.
%~ta : développe %a jusqu’à la date et l’heure du fichier.
%~za : développe %a jusqu’à la taille du fichier.
%~$PATH:a : recherche les répertoires énumérés dans la variable d’environnement et développe %a jusqu’au nom complet du premier répertoire trouvé.
%~dpa : développe %a en une lettre de lecteur et un chemin seulement.
%~nxa : développe %a en nom de fichier et une extension seulement.
%~fsa : développe %a en un nom de chemin complet avec des noms courts seulement.
%~dp$PATH:a : recherche les répertoires énumérés dans la variable d’environnement pour %a et développe jusqu’à la lettre du lecteur et au chemin du premier répertoire trouvé.
%~ftzaa : développe %a en une ligne de sortie semblable à celle affichée par la commande « Dir ».

Comparez les sorties affichées par ces trois commandes :
for /r %a in (.txt) do @echo %~dpa for /r %a in (.txt) do @echo %~nxa
for /r %a in (.txt) do @echo %~ftzaa Signalons que la commande for /r %a in (.txt) do @echo %~dp$PATH:a n’affichera que les arborescences contenant au moins un fichier Texte.
Là aussi, comparez le texte de sortie avec cette commande :
(for /r %a in (*.txt) do @echo %~$PATH:a) > Sortie.txt
Nous avons simplement mis entre parenthèse la commande et rediriger son résultat dans un fichier .txt nommé Sortie.txt.

Décomposer une variable
Dans un nouveau document Batch copiez ce contenu :
for /f « tokens=6-8 delims=/  » %%a in (‘echo. ^|date’) do set jour=%%a&set mois=%%b& set année=%%c
La commande « Date » affiche ce texte : « La date du jour est : 12/07/2004 »
Nous devons donc récupérer le sixième bloc de caractères (12/07/2004) et, si nous enlevons les barres inversées, 8 caractères à partir de la fin du sixième bloc (12 07 2004).
Trois valeurs nous intéressent : 12, 07 et 2004 que nous transformons en variables en utilisant la commande « Set ».
Pour vous en assurer saisissez cette commande : set jour
Nous pouvons faire la même opération pour la commande « Time » :
for /f « tokens=2-8 delims=:, » %%a in (‘echo. ^|time ^| find « actuelle »‘) do set HH=%%a&set HM=%%b& set HS=%%c& set HDS=%%d
Dans ce cas le principe est un peu différent :
Si je saisis la commande Time, le message suivant apparaît : « L’heure actuelle est : 11:51:29,13 » – « Entrez la nouvelle heure ». Évidemment seule la première ligne nous intéresse… Nous allons demander que soit afficher la ligne qui contient le mot « actuelle » : echo. ^|time ^| find « actuelle »
Dans cette ligne nous allons extraire le second bloc puis les huit caractères en partant de la fin : tokens=2-8
Du résultat brut (11:51:29,13) nous allons effacer les signes : et ,( delims=:,).
Quatre variables vont être définies : HH, HM, HS et HDS correspondant respectivement à l’heure, aux minutes, aux secondes et aux dixième de secondes. Nous devons donc spécifier quatre noms de variables : %a, %b, %c et %d.
L’opérateur & permet d’exécuter plusieurs fois la commande « Set » en une seule ligne.
Le tableau suivant récapitule les mots clés que vous pouvez utiliser :

Mot clé – Signification
eol=c : Indique un (et un seul) caractère de fin de ligne
skip=n : Spécifie le nombre de lignes à sauter à partir du début du fichier.
delims=xxx : Spécifie un séparateur.
tokens=x,y,m-n : Spécifie les jetons à passer à la commande For.
usebackq : Permet l’utilisation des guillemets.

Nous voyons plus en détails le principe d’utilisation d’un jeton au paragraphe suivant.

Principes d’utilisation d’un jeton
Le mot clé « Tokens » sert à allouer un jeton pour chaque fichier analysé. Un jeton est sorte de permission temporaire accordée à un fichier afin que soit exécuté la commande spécifiée. Une fois cette dernière achevée, le jeton est alloué au prochain fichier trouvé et ainsi de suite. Si nous souhaitons activer l’attribut « Lecture seule » des fichier .doc nous pouvons saisir :
for /f « tokens=* » %a in (‘dir /s /b *.doc’) do attrib +r %a
Bien entendu, notre commande s’exécutera pour tous les fichiers .doc placés dans les répertoires et sous-répertoires de l’emplacement par défaut. Nous pouvons traduire cette commande par : « Pour chaque fichier trouvé quand je lance la commande ‘Dir’ exécute celle qui suit le mot clé Do ». Il vous est également possible d’utiliser des itérations de plages de valeurs afin, par exemple, de créer rapidement dix répertoires nommés Test et numérotés de 1 à 10 :
for /l %a in (1,1,10) do @md test%a
Nous avons rajoutez une arobase devant la commande « Md » afin de désactiver l’affichage de la sortie écran.
De la même façon vous pouvez créer des « listes négatives » :
for /l %a in (-10,1,10) do @echo %a >> sortie.xls
Un document Excel sera créé avec une plage de valeurs comprises entre -10 et 10.
La syntaxe est la suivante : Valeur_Début, Valeur_Incrémentation, Valeur_Fin.
Créez un fichier texte nommé Fichier.txt contenant ceci :

Cellule1 Cellule2 Cellule3 etc.
-Cellule4 Cellule5 Cellule6 etc.
Cellule7,Cellule8,Cellule9 etc.
Cellule10 Cellule11 Cellule12 etc.

Saisissez cette commande si vous voulez afficher l’ensemble de Fichier.txt à l’exception de la seconde ligne :
for /f « eol=- tokens=1,2* delims=,  » %a in (fichier.txt) do @echo %a %b %c
« eol=- » : spécifie que les lignes commençant par un – seront ignorées.
« tokens= » : alloue un jeton puis un second pour chaque ligne explorée. Deux blocs de données seront adressées. L’astérisque permet d’allouer autant de variables que nécessaire pour recevoir le texte « restant ». C’est plus simple d’utilisation que d’indiquer : « tokens=1,2,3,4 » (puis que nous devons afficher quatre blocs de données).
« delims=,  » : nous permet de préciser que les jetons passés sont à chercher dans les blocs délimités par un espace ou une virgule.
« %a %b %c » : permet de dénombrer le nombre de valeurs à afficher.
À titre de test saisissez cette commande :
for /f « eol=- tokens=1,2 delims=,  » %a in (fichier.txt) do @echo %a %b %c %d
Les deux dernières variables seront indiquées comme étant non « remplies » puisqu’un nombre insuffisant de jetons a été alloué.
L’affichage des deux dernières colonnes s’obtient donc en saisissant :
for /f « eol=- tokens=3,4 delims=,  » %a in (fichier.txt) do @echo %a %b
Nous pouvons résumer la commande en disant : « Pour chaque ligne analysée, passe le troisième et le quatrième jeton jusqu’à ce que soient renseignées les variables %a et %b qui correspondront aux blocs de données n°3 et 4 ».

Récupérer différentes variables à partir d’un fichier
Dans un nouveau document nommé Fichier.txt copiez ceci :
C:\Sauvegarde
C:\Test
Dans un nouveau fichier Batch copiez ceci :

@echo off
set Fichier=%1
set Dossier=%2
for /f %%a in (fichier.txt) do call :Commande %%a
:Commande
set source=%1
copy %source%%fichier% %dossier%

Ce Batch se lance de cette façon : Nom_Batch .txt c:\temp Nous récupérons les deux paramètres saisis par l’utilisateur (.txt et c:\temp) et définissant deux variables (Fichier et Dossier) qui correspondent respectivement à %1 et %2.
Comme nous l’avons dit précédemment le signe % doit être redoublé quand il est utilisé dans un fichier Batch.
À chaque ligne trouvée dans Fichier.txt nous appelons les commandes inclues dans l’étiquette :Commande.
Le premier paramètre trouvé %1 (c:\sauvegarde) est passé en tant que variable nommée %source%.
La ligne suivante se contente d’effectuer le processus de copie en concaténant les variables de telle sorte que la commande s’exécute.

Analyser une chaîne de caractères
Il vous est possible d’analyser le contenu d’un fichier d’une commande ou d’une variable d’environnement en les plaçant entre deux guillemets simples et inversés :
for /f « usebackq » %a in (set) do @echo %a
Le commutateur /f vous permet de spécifier plusieurs jetons d’analyse.
Dans cet exemple, l’utilisation du mot clé Usebackq est nécessaire puisque Jeu est placé entre accents inversés. Si vous ne souhaitez n’avoir que les noms sans les chemins correspondants, saisissez :
for /f « usebackq delims== » %a in (set) do @echo %a
Le principe est de spécifier un jeu de séparateur.
Dans notre exemple, la ligne « windir=C:\WINDOWS » sera coupée à partir du signe égal. Il ne s’affichera plus que « windir ».
Il vous tout à fait possible de faire la même opération sur un fichier nommé Fichier.txt :
for /f « usebackq delims= » %a in (Fichier.txt) do @echo %a
Le Bloc-notes s’ouvrira directement dans le fichier spécifié puisque qu’il lui est demandé d’être exécuté…
Curieusement, le mot-clé « usebackq » n’est jamais employé ! Comme nous le verrons dans les paragraphes suivants, il est en effet plus simple de saisir, par exemple, ces commandes :
for /f « delims== » %a in (‘set’) do @echo %a
for /f « delims= » %a in (Fichier.txt) do @echo %a

Utiliser un filtre avec la commande For
La commande « For » ne s’accommode pas d’un filtre de redirection. Dans l’exemple suivant le symbole de redirection | n’a aucun effet :
for %%a in (.txt) do type %%a | more Le symbole | étant repris pour le compte de la commande « For » et non de « Type ». Vous devez en passer par la création de deux scripts : L’un contiendra ceci : for %%a in (.txt) do test %%a
Nous pouvons aussi écrire : for %%a in (.txt) do call test %%a Ou encore : for %%a in (.txt) do command /c test %%a
Dans l’autre fichier (appelé dans notre exemple Test) copiez ceci :
@type %1 | more
Les fichiers seront triés en fonction de leur nom.

Récupérer le résultat d’une commande en tant que variable
Imaginons que nous souhaitons récupérer le nom du dernier fichier sans son extension et de nous en servir comme d’une variable, nous pouvons nous inspirer de ce script :

@echo off
for /f %%a in (‘dir /b /od /a-d .‘) do set variable=%%~na
echo Le nom du dernier fichier est : %variable%

Le principe du script consiste à récupérer la dernière ligne affichée par la commande « Dir » et de transformer cette ligne en une variable. Pour ce faire, seule le nom du fichier seul est extrait (%~na).

Comparer si deux fichiers font la même taille
Dans un nouveau fichier Batch copiez ce contenu :

@echo off
set fichier1=%1
set fichier2=%2
for %%a in (%fichier1%) do set taille1=%%~za
for %%a in (%fichier2%) do set taille2=%%~za
if %taille1%==%taille2% (
echo Les tailles des fichiers sont identiques.
) else (
echo Les tailles des fichiers ne sont pas identiques.
)

Deux variables récupèrent les deux paramètres saisis par l’utilisateur. Ce sont les deux noms de fichiers à comparer.
Pour chaque fichier, nous procédons à l’extraction de la taille (%~za) et créons à chaque fois une variable.
Si les deux tailles sont identiques nous affichons un message de confirmation sinon nous signalons que les tailles trouvées ne sont pas identiques.

Assurer le traitement conditionnel des commandes
Prenons un exemple :
if not exist Fichier.txt echo « Le fichier est manquant »
Nous pouvons également imaginer ce type de commande :
if exist Fichier.txt (del fichier.txt) else echo « Le fichier est manquant »
En bref, nous demandons simplement que si le fichier Fichier.txt est présent dans le répertoire par défaut il faut le supprimer sinon le message suivant apparaîtra : « Le fichier est manquant ». La syntaxe de la commande est variable :
if [not] errorlevel Nombre Commande [else Expression]
if [not] Chaîne1==Chaîne2 Commande [else Expression]
Cela suppose que Chaîne1 doit être équivalent à Chaîne2
if [not] exist Nom_Fichier Commande [else Expression]
Si les extensions de commandes sont activées, il est possible d’utiliser la syntaxe suivante :
if [/i] Chaîne1 Options_Comparaison Chaîne2 Commande [else Expression]
Le commutateur /i permet de ne pas tenir compte de la casse.
Le tableau suivant récapitulatif les valeurs possibles pour Options_Comparaison :

Opérateur Description
EQU Égal à
NEQ Différent de
LSS Inférieur à
LEQ Inférieur ou égal à
GTR Supérieur à
GEQ Supérieur ou égal à

Examinons cette commande : if cmdextversion Nombre Commande [else Expression]
Le mot clé cmdextversion permet de vérifier si les extensions de commandes sont activées ou non. La première version est égale à 1. Elle doit être indiquée dans « Nombre ».
Voici une autre possibilité : if defined Variable Commande [else Expression]
Ne reconnaît la condition comme étant vraie que si « Variable » est défini.
Astuce : Un cas particulier concerne la vérification des répertoires. Si nous souhaitons nous assurer que le répertoire Test existe bien nous devrons saisir : if exist Test\nul (@echo « Le répertoire existe bien ! ») else md Test
Cela revient à dire que si le répertoire Test existe bien un périphérique fictif (nul) existe aussi.
Nous pouvons imaginer la création d’un fichier de commande qui se chargera de vérifier si un répertoire Test existe sur le disque dur. Si la commande précédente échoue (errorlevel 0) alors il sera créé. Copiez dans un nouveau fichier Batch ces trois lignes :

echo off
dir /s Test
if errorlevel 0 (md Test)

Nous pourrions écrire la dernière ligne de cette façon :
if %errorlevel% leq 0 (md c:\Test)
Dans ce dernier cas nous nous servons de errorlevel comme d’une variable qui sera égale ou non à 0.
Nous pouvons aussi saisir ce type de commande :
if not exist c:\Test\nul md c:\Test
Vous pouvez conditionner la recherche à la condition que l’utilisateur saisisse le nom du fichier à rechercher :

@echo off
if not exist %1 (echo Le fichier %1 est introuvable dans ce répertoire.) else echo Fichier trouvé !

La variable %1 représente dans ce cas la chaîne de caractères (le nom du fichier) que l’utilisateur aura saisie à la suite du nom du fichier de commande.

Créer un contrôle de saisie
Dans le cas d’un fichier Batch nécessitant la saisie d’un paramètre vous pouvez insérer en début de script une routine de contrôle. Vous pouvez tester ces deux méthodes en saisissant ou non n’importe quelle variable en début de votre fichier batch :

if [%1] ==[] echo Paramètres de commande manquants
if [%1] equ [] echo Paramètres de commande manquants

Cela revient à dire : si aucune chaîne de caractères n’a été saisie à la suite du nom du fichier de commandes affiche ce message : « Paramètres de commande manquants ». Voici un autre exemple :

@echo off
if {%1}=={} @echo Saisissez le nom du fichier&goto :eof
if not exist %1 (@echo %1 n’existe pas) else @echo Le fichier existe !

La première ligne s’assure qu’à la variable %1 correspond une saisie quelconque. Si le paramètre qui suit le nom de la commande {%1} est égale == à rien {} ou, plus exactement, si rien n’a été saisi au clavier alors un message d’avertissement sera affiché.
Si le paramètre saisi ne correspond (dans ce cas) à aucun fichier existant alors affiche cet autre message d’avertissement.
L’étiquette :goto:eof permet de quitter le fichier de commande si la condition posée est vraie. Si la condition est fausse, la commande suivante sera exécutée. Cela évite d’insérer une étiquette :fin à la fin de notre script.
Il y a une méthode plus simple : inspirez-vous de ce script :

@echo off
if not %1[==[ if exist %1 goto message
echo Le fichier n’existe pas ou rien n’a pas été précisé & goto:eof
: message
echo Bonjour !

De cette façon, nous vérifions en une seule commande que l’utilisateur a bien saisi un paramètre et que le fichier spécifié est bien présent.

Choisir à quel étage l’ascenseur va s’arrêter
Dans un nouveau Batch copiez ce contenu :

@echo off
if « %1 » == « 3 » goto niveau3
if « %1 » == « 2 » goto niveau2
if « %1 » == « 1 » goto niveau1
if « %1 » == «  » goto :eof
:niveau3
CD ……\
goto :eof
:niveau2
CD ….\
goto :eof
:niveau1
CD ..\
goto :eof

Copiez ce script dans un des chemins définis par la variable d’environnement %Path%. Saisissez à partir de n’importe quelle arborescence le nom du Batch suivi du numéro de niveau auquel vous souhaitez remonter.
Si, par exemple, nous saisissons le chiffre 3 nous exécuterons cette commande : CD …….

Créer une boucle
Dans un nouveau fichier Batch copiez ce contenu :

@echo off
set variable=
: Boucle
set /a variable+=1
if /i %variable% equ 10 goto :eof
echo %variable% && goto Boucle

Nous posons une variable sans la définir. Pour vous en rendre compte saisissez ces commandes :
set variable=
set variable
Nous créons une étiquette nommée :Boucle qui va effectuer les actions suivantes :
set /a variable+=1 : incrémenter la variable de départ d’un pas de 1. De 0 notre variable va donc être égale à 1.
if /i %variable% equ 11 goto :eof : Si la variable est égale au nombre 10 arrêter l’exécution du script.
Dans le cas contraire inscrire à l’écran la valeur obtenue puis reprendre l’exécution du fichier de commandes à partir de l’étiquette nommée :Boucle.
Si nous voulons obtenir un pas de « deux » il suffit de modifier la ligne set /a variable+=1 par ceci : set /a variable+=2

Créer un compteur
Créez un fichier Batch avec ce contenu :

@echo off
set filtre=.
set taille=0
set compteur=0
for /r %%a in (%filtre%) do if %%~za==%taille% (
set /a compteur+=1
)
echo Il y a %compteur% fichiers dont la taille est de 0 octet.

À l’aide de la commande « Set » nous définissons trois variables :
filtre : dans ce cas la recherche portera sur tous les fichiers ..
taille : définit la taille du fichier à chercher. Dans notre cas : 0 ko.
compteur : qui est tout d’abord définit à 0 puis incrémenté à chaque fois de 1 (set /a compteur+=1) dès qu’un nouveau fichier répondant aux critères définis a été signalé.
La commande for /r démarre une recherche récursive jusqu’à ce que plus aucun nouveau fichier ne soit trouvé.
Chaque nom de fichier est passé sous forme de variable (%a) qui se réinitialise à chaque nouveau fichier trouvé et le lot de commandes exécuté.
Le commutateur %~za développe %a jusqu’à la taille du fichier.
L’utilisation des parenthèses nous permet de définir que si les critères de recherche sont remplis alors la variable %compteur% est incrémenté d’une unité.
Le commutateur /a permet d’indiquer que c’est une expression numérique qui sera évaluée pour la variable %compteur%
La dernière ligne affiche simplement la dernière valeur de la variable %compteur%