Apprendre la programmation de script batch

Un simple éditeur de texte, tel que le notepad fourni avec Windows, s'avère peu pratique pour écrire des scripts batch. Pour exploiter pleinement les capacités de ces scripts, il faut pouvoir encoder les caractères non anglophones comme les accents ou le « ç » afin de pouvoir accéder aux fichiers dont les noms comportent ce genre de caractères exotiques. La plupart des éditeurs de texte encodent les fichiers avec le jeu de caractères de la norme ANSI qui correspond à la langue d'installation du système d'exploitation alors que l'interpréteur de commande utilise une étendue de page de code (aussi appelée Code Page) comme CP-850 qui est l'encodage par défaut de l'interpréteur pour les systèmes Windows installés en français (France).

Sous Windows, il y a un éditeur de texte que vous possédez peut-être déjà, c'est Notepad++ (la version 5.9.x ou supérieure est nécessaire) ; si ce n'est pas le cas, vous pouvez le télécharger ici : http://notepad-plus-plus.org/fr/

Dans ce dernier, vous pourrez sélectionner l'encodage dans le menu « Encodage > Codage de caractères », puis si vous voulez le français par exemple : sélectionnez « Langues d'Europe occidentale>OEM-850 ». Dans Notepad++, les code pages sont appelés OEM-XXX, au lieu de CP-XXX, mais ce sont les mêmes encodages. Il faut aussi noter que dans le même menu que OEM-850, il y a OEM-863 : français ; c'est bien du français, mais pour le Québec. Cette manipulation sera à effectuer pour chaque script afin d'utiliser le bon encodage, il n'est pas possible d'effectuer cette opération de façon automatique dans Notepad++.

La gestion des pages de code dans l'interpréteur se fait via les commandes mode et chcp, ces commandes permettent d'afficher le code page utilisé ou de le modifier en utilisant l'une des syntaxes suivantes.

Définir le code page à utiliser (où <XXX> est le numéro de code page).

mode con cp select=<XXX>

chcp <XXX>

Afficher le code page utilisé.

mode con cp [/status]

chcp

Le tableau 1 fournit une liste non exhaustive des différents code pages utilisés par l'interpréteur de commande.

Tableau 1 : Code Page

Il faut noter que malgré la mise à jour de CP-850 par CP-858, l'encodage par défaut pour l'interpréteur sous Windows installé en français (France) reste CP-850. Il est donc préférable d'utiliser CP-850. La liste des code pages supportés par un système Windows est disponible dans le registre sous la clé : HKLM\SYSTEM\CurrentControlSet\Control\Nls\CodePage. Vous noterez la présence de 1252 dans la clé précédemment mentionnée, il s'agit de l'encodage Windows-1252 utilisé par les API Windows et donc par la plupart des blocs-notes sur les systèmes installés en français (France) ; cependant il n'est pas recommandé de l'utiliser dans l'interpréteur de commande du fait que les commandes ne sont pas faites pour le supporter, il peut même provoquer des bogues dans certains cas. L'encodage par défaut pour l'interpréteur peut être trouvé via la valeur OEMCP de type REG_SZ toujours dans la clé précédemment mentionnée.

Il est possible d'ajouter les Code Pages manquants (par défaut, seuls les code pages correspondant à la langue d'installation sont disponibles) en installant le pack de langue correspondant à l'encodage voulu. Chaque pack de langue comprend une table de conversion permettant à Windows de convertir un point de code en sa représentation graphique et donc de l'afficher. Il est aussi possible d'utiliser l'Unicode (UCS-2 seulement) avec les sorties de commandes internes de l'interpréteur pour permettre l'interaction avec les programmes qui utilisent Unicode de manière « native » (pour Perl par exemple) en appelant l'interpréteur via la commande suivante (où <commande> est la commande à exécuter).

cmd /u <commande>

Dans Notepad++, les caractères absents du clavier peuvent êtres rajoutés via le menu « Édition>Panneau des caractères ASCII » puis double-clic sur le caractère voulu.

Nous allons commencer par le traditionnel « hello world », dont voici le code (Script 1). Copiez le code dans Notepad++, puis enregistrez-le avec l'encodage OEM-850 et l'extension « .bat » ou « .cmd » (seulement sur les systèmes Vista et supérieur).

@echo off
cls

rem Ceci est une remarque.
:: Ceci est un commentaire.

echo Hello World !!!! Déjà là ?
echo.
pause

Lorsqu'on exécute ce script en cliquant dessus, on obtient l'affichage suivant.

Étudions la composition du script 1. La première ligne, @echo off, est déjà intéressante, elle est composée :

• du préfixe @ qui sert à inverser l'état de l'affichage standard ;
• de la commande echo qui sert à gérer l'affichage en ligne de commande ;
• et du paramètre off qui sert à désactiver l'affichage standard.

L'affichage standard définit ce que l'interpréteur de commande affiche par défaut. Par exemple lors du lancement de l'interpréteur de commande ci-dessous ; l'affichage standard renvoie le chemin d'accès du répertoire courant, soit C:\Users\Portable>.

Lors de l'exécution d'un script, l'affichage standard renvoie, par défaut, le chemin d'accès du répertoire courant suivi de la commande en cours d'exécution comme dans l'exemple ci-dessous.

Le préfixe @, quand il est placé en début de ligne, sert à inverser l'état de l'affichage standard (activé ou désactivé) pour l'exécution de la commande qui le suit (pas seulement pour la commande echo). Ce comportement prend fin une fois la commande exécutée. Ainsi la commande @cd /d "C:\Users\Portable\" ne sera affichée que si l'affichage standard est désactivé. La syntaxe du préfixe @ est la suivante (où <commande> est la commande à exécuter) :

@<commande>

La commande echo gère l'affichage dans l'interpréteur, elle peut :

• modifier l'état de l'affichage standard ;
• afficher l'état de l'affichage standard ;
• afficher un message ou une ligne vide dans l'interpréteur.

Désactiver l'affichage standard peut être fait via la syntaxe suivante (seuls les erreurs et les messages de la commande echo sont affichés).

echo off

Activer l'affichage standard peut être fait via la syntaxe suivante (tout est affiché).

echo on

Utilisée sans paramètre, la commande echo renvoie l'état de l'affichage standard en cours.

echo

Si l'on reprend le script 1, la ligne @echo off permet de désactiver l'affichage standard sans que la commande soit affichée. Sur la deuxième ligne du script 1, la commande cls est utilisée pour vider la fenêtre de l'interpréteur de son contenu, cette commande ne prend aucun paramètre. Sa syntaxe est donc la suivante.

cls

La ligne suivante du script 1 est vide, elle ne sera donc pas prise en compte lors de l'exécution du script permettant ainsi de le rendre plus lisible. La quatrième ligne est composée de la commande rem et d'une chaîne de caractères, cette commande permet d'insérer des remarques dans son script. Si et seulement si l'affichage standard est activé, la commande rem sera affichée. La syntaxe de la commande rem est la suivante (où <remarque> est la chaîne de caractères à insérer en remarque).

rem <remarque>

La cinquième ligne du script 1, :: Ceci est un commentaire., est composée du préfixe :: et d'une chaîne de caractères. Le préfixe :: définit la chaîne de caractères qui le suit comme étant un commentaire ; ce comportement prend fin au premier retour à la ligne. Quel que soit l'état de l'affichage standard, la chaîne de caractères préfixée par :: ne sera pas affichée. La syntaxe est la suivante (où <commentaire> est le commentaire à insérer).

::<commentaire>

Suit une autre ligne vide puis la commande echo Hello World !!!! Déjà là ? qui affiche Hello World !!!! Déjà là ? dans la fenêtre de l'interpréteur. La syntaxe suivante permet donc d'afficher un message même si l'affichage standard est désactivé (où <message> est le message à afficher).

echo <message>

Vient ensuite la commande echo. qui permet d'afficher la ligne vide que l'on voit dans l'affichage obtenu. Si un point suit directement la commande echo et qu'après le point il y a un retour à la ligne, celle-ci affiche une ligne vide.

echo.

Sur la ligne suivante se trouve la commande pause qui met en pause l'exécution du script jusqu'à ce que l'utilisateur appuie sur une touche quelconque du clavier, elle affiche le message Appuyez sur une touche pour continuer… (quel que soit l'état en cours de l'affichage standard) et ne prend aucun paramètre. Dans le script 1, cette commande permet de visualiser le contenu de la fenêtre de l'interpréteur avant que celle-ci ne se ferme.

pause

Pour mieux comprendre la différence entre la commande rem et le préfixe ::, étudions le script 2.

cls
rem Remarque 1
:: Commentaire 1
@echo off
rem Remarque 2
:: Commentaire 2
pause

Comme vous le voyez dans l'affichage du script 2, la commande rem Remarque 1, est présente à l'écran ; l'affichage standard étant activé, les commandes exécutées sont toutes affichées. La chaîne :: Commentaire 1 n'est pas affichée, c'est dû au fait que le préfixe :: n'est pas une commande et donc n'est pas renvoyé par l'affichage standard. Vient ensuite la commande @echo off qui désactive l'affichage standard sans que la commande ne soit affichée, suivie de la commande rem Remarque 2 qui n'est pas affichée (l'affichage standard étant à présent désactivé), pas plus que la chaîne :: Commentaire 2 qui est de toute façon exclue par l'affichage standard.

Les caractères spéciaux (aussi appelé méta-caractères) sont des caractères ayant une signification particulière pour l'interpréteur de commande. Chaque fois que l'interpréteur les rencontre, il leur applique le traitement correspondant, quelles que soient leurs positions dans la ligne de commande. En voici la liste :

& | ^ < > ( )

Pour pouvoir les utiliser dans une chaîne de caractères, il faut les « échapper » avec le caractère ^, c'est-à-dire placer ce caractère devant. Ainsi l'interpréteur saura qu'ils font partie d'une chaîne et qu'ils n'ont rien à voir avec la commande. Voir le script 3 comme exemple.

@echo off
echo ^& ^| ^^ ^< ^> ^( ^)
pause

Il faut aussi noter que d'autres caractères peuvent avoir besoin d'être échappés, mais ils suivent d'autres règles. Le caractère % doit être échappé par lui-même pour être considéré comme faisant partie d'une chaîne lorsqu'il est utilisé dans un script comme le montre le script 4.

@echo off
echo %%
pause

Un autre cas est à noter, il concerne les caractères " et \ qui doivent être échappés avec le caractère \ lorsqu'ils sont utilisés dans un paramètre entre guillemets. Dans le script 5, si les caractères " et \ n'avaient pas été échappés, le résultat ne serait pas celui attendu. L'interpréteur aurait compris qu'il y avait une chaîne "cmd /c "notepad et une chaîne "%cd%\%~nx0"", ce qui aurait conduit à une erreur d'évaluation de la commande.

@echo off
runas /User:%UserName% "cmd /c \"notepad \"%cd%\\%~nx0\""
pause

Le caractère d'échappement ^ peut aussi être utilisé afin d'écrire une seule et même commande sur plusieurs lignes. Lorsque l'interpréteur rencontre le caractère ^ devant un retour à la ligne, il supprime ce caractère et le retour à la ligne, puis continue à lire les données fournies dans la ligne suivante. Exemple avec le script 6.

@echo off
echo foo ^
bar
pause

D'autres échappements existent, cependant ils seront abordés plus loin dans ce document, car ils s'appliquent à des commandes précises et ne concernent pas les autres. Par exemple, la commande echo qui considère le point comme un échappement de la chaîne qui le suit. Lorsque la commande echo est directement suivie d'un point, elle considère la chaîne qui se trouve après le point comme une chaîne à afficher, retour à la ligne compris. Cela permet d'utiliser en début de chaîne un « mot » qu'elle aurait, dans le cas contraire, considéré comme un paramètre. Exemple avec le script 7.

@echo off

echo Affichage d'une ligne vide sans le point:
echo

echo.
echo.

echo Affichage d'une ligne vide avec le point:
echo.

echo.
echo.

echo Affichage de la chaîne "     /?  Print this help." sans le point:
echo     /?  Print this help.

echo.
echo.

echo Affichage de la chaîne "     /?  Print this help." avec le point:
echo.    /?  Print this help.

echo.
echo.
pause

Dans l'affichage ci-dessous, on remarque que l'affichage d'une ligne vide sans le point renvoie l'état de l'affichage standard contrairement à celle avec un point. Si à la place d'un retour à la ligne, nous avions utilisé plusieurs espaces, le résultat aurait été le même, quel que soit le nombre d'espaces. En effet, l'interpréteur n'évalue pas le nombre d'espaces entre deux constituantes d'une ligne de commande, il aurait donc considéré qu'aucun paramètre n'est fourni. Il en est de même avec la chaîne /? Print this help., l'interpréteur considère la sous-chaîne /? comme un paramètre qui affiche l'aide en ligne de commande.

Le tableau 2 récapitule les différents échappements que l'on vient de voir.

Tableau 2 : Les échappements

Un problème récurrent en batch scripting est que les remarques et commentaires (fournis via rem et ::) provoquent des bogues du fait d'une mauvaise utilisation. La commande rem et le préfixe :: prenant en paramètre une chaîne de caractères, ils attendent donc une chaîne de caractères valide. Ainsi les échappements doivent être utilisés pour les caractères suivants : & | ^ < > ( ) %.

Nous allons commencer par les variables d'environnement, elles sont toutes de type chaîne de caractères. C'est le système d'exploitation qui définit leurs valeurs soit parce que d'un système à l'autre leurs valeurs peuvent être différentes, soit parce que ces variables sont définies dynamiquement lors de leur expansion. Cela permet d'accéder à des fichiers dont le chemin d'accès pourrait ne pas être le même d'une machine à l'autre ou de pouvoir obtenir, par exemple, l'heure ou la date dont les valeurs sont modifiées en permanence.

Dans le tableau 3, vous trouverez la liste de ces variables. Dans la première colonne, vous trouverez le nom de ces variables ; ces noms sont réservés par le système, et même s'il est possible de modifier leur valeur pendant l'exécution du script, les modifications apportées prendront fin en même temps que le script. De plus, dans certains cas, la modification de leur valeur peut entraîner une mauvaise évaluation de l'environnement par le script. La deuxième colonne donne la description de la valeur renvoyée par la variable. Et enfin, la troisième colonne donne la compatibilité en fonction de la version du système. Dans cette colonne, il est fait mention de « systèmes NT », il s'agit de la « famille » du système d'exploitation. Les systèmes NT sont des systèmes reposant sur un noyau de type NT provenant du système Windows du même nom. Cette famille comprend au jour où sont écrites ces lignes :

• les systèmes Windows NT X.Y (où X est la révision majeure et Y la révision mineure) ;
• les systèmes Windows 2000 ;
• les systèmes Windows XP ;
• les systèmes Windows Server 2003 ;
• les systèmes Windows Vista ;
• les systèmes Windows Server 2008 ;
• les systèmes Windows 7 ;
• les systèmes Windows Server 2012 ;
• et les systèmes Windows 8.

Tableau 3 : les variables d'environnement

La commande set gère les variables dans l'interpréteur, elle permet :

• de créer une variable ;
• d'attribuer une valeur à une variable ;
• de modifier le contenu d'une variable ;
• de supprimer le contenu d'une variable ;
• d'effectuer des opérations mathématiques ou logiques entre des nombres ;
• de récupérer la saisie d'un utilisateur pour la placer dans une variable ;
• et de transtyper le contenu d'une variable.

Voici la syntaxe de la commande set.

Attribue à la variable une valeur sous forme de chaîne de caractères (où <variable> est son identifiant et <chaîne> est une chaîne de caractères).

set ["]<variable>=<chaîne>["]

Attribue à la variable une valeur sous forme d'un nombre entier signé (où <expression> est une expression numérique à évaluer : détaillé par la suite).

set /a ["]<expression>["]

Attribue à la variable une valeur, saisie par l'utilisateur, sous forme de chaîne de caractères après l'affichage de la chaîne d'invite si elle est spécifiée (où <variable> est son identifiant et où <chaîne_invite> est une chaîne de caractères affichée à l'utilisateur afin de l'inviter à saisir une chaîne au clavier).

set /p ["]<variable>=[<chaîne_invite>]["]

Supprime la valeur de la variable de la mémoire, son identifiant reste indexé par l'interpréteur, mais sa valeur est indéfinie.

set ["]<variable>=["]

Voici les règles usuelles de la commande set :

• Si la commande set est employée sans paramètre, elle affiche les variables définies dans le contexte courant (détaillé par la suite).
• Si elle est utilisée avec comme paramètre une chaîne (ou un nom de variable), sans valeur ni signe égal ; alors elle affiche la variable dont le nom correspond à la chaîne donnée en paramètre et/ou les variables ayant un nom commençant par la chaîne donnée en paramètre.
• Si elle est utilisée avec un nom de variable et un signe égal sans valeur alors le contenu de la variable est vidé de la mémoire, il est possible de tester si une variable est définie, mais nous aborderons ce point au prochain chapitre.
• Toute chaîne non numérique dans l'expression à évaluer est traitée comme un identifiant de variable et est convertie en nombre avant d'être utilisée (dans son utilisation avec le paramètre /a), si la variable n'existe pas ou qu'elle est indéfinie, elle prend comme valeur 0.
• Une expression numérique à évaluer devrait toujours être placée entre guillemets afin de permettre l'utilisation des opérateurs logiques et des opérateurs de groupement.

Voyons plus en détail le fonctionnement de la commande set avec le script 9.

@echo off
set VAR_Espace_Un="Ma chaîne avec des espaces"
set VAR_Espace_Deux"=Ma chaîne avec des espaces"
set "VAR_Espace_Trois=Ma chaîne avec des espaces"
::il y a quatre espaces à la fin de la ligne suivante
set /p VAR_Saisie_Un=    ma saisie un:    
set /p "VAR_Saisie_Deux=    ma saisie deux:    "
set /a VAR_Calcul_Un=1+10
set /a VAR_Calcul_Deux"=2+20"
set /a "VAR_Calcul_Trois=3+30"
echo.
echo %VAR_Espace_Un%
echo %VAR_Espace_Deux%
echo %VAR_Espace_Trois%
echo.
set VAR_Saisie
echo.
set VAR_Calcul
echo.
pause

Comme vous pouvez le constater, les guillemets occupent une place prépondérante dans ce script ; observez bien où ils sont placés. De la ligne 2 à la ligne 4, les valeurs des variables sont des chaînes de caractères avec des espaces. La déclaration de la variable VAR_Espace_Un se fait avec des guillemets placés de part et d'autre de la chaîne, la déclaration de la variable VAR_Espace_Deux se fait avec des guillemets : un placé avant le signe égal et l'autre à la fin de la chaîne ; la déclaration de la troisième variable VAR_Espace_Trois se fait avec des guillemets : un placé avant le nom de la variable et l'autre à la fin de la ligne. Si on se reporte à l'affichage obtenu, on remarque que la première et la troisième variables affichent une sortie correcte ; la deuxième variable quant à elle ne fonctionne pas ; on déduit donc facilement que si les guillemets s'ouvrent avant l'identifiant de la variable et se ferment après la valeur de la variable, ils ne font pas partie de la variable ; et si les guillemets s'ouvrent avant la valeur de la variable et se ferment après la valeur de la variable, ils font partie de la variable.

Les deux saisies de l'utilisateur donnent aussi un résultat intéressant, la ligne de commande qui déclare VAR_Saisie_Un n'utilise pas de guillemets ; par contre la ligne de commande qui déclare VAR_Saisie_Deux, elle, en utilise. Lors de l'affichage des invites de saisie utilisateur, les espaces se trouvant avant les chaînes d'invites ont disparu, et ceux se trouvant après sont affichés. On en déduit que les espaces en début de ligne sont ignorés et que ceux de la fin sont considérés comme faisant partie de la chaîne d'invite.

En ce qui concerne les variables VAR_Calcul_XXX, elles donnent toutes un résultat valide cependant il est toujours préférable de respecter les règles de syntaxe ; c'est-à-dire toujours mettre l'expression numérique entre guillemets. Cela sera utile dans la suite du chapitre.

Ce sont, à mon sens, les plus utilisées en batch. Ce sont toutes les variables composées de caractères alphanumériques et autres caractères. Les chaînes de caractères sont déclarées via la commande set et il n'est pas nécessaire d'utiliser des guillemets pour que les espaces soient pris en compte comme faisant partie de la chaîne, et ce, où qu'ils soient placés dans la chaîne.

Elles offrent aussi d'autres possibilités comme la substitution de chaîne dans l'expansion de la variable. Ainsi avec la syntaxe suivante, il est possible de modifier la variable lors de son expansion sans que cela n'altère sa valeur (où <variable> est l'identifiant de la variable, <old_string> est la chaîne à remplacer et <new_string> est la chaîne à insérer à la place de <old_string>). Exemple avec le script 10.

%<variable>:<old_string>=<new_string>%

@echo off
set "X=une chaîne"
echo La variable avec substitution: %X:une=ma%
echo La valeur réelle de la variable: %X%
echo.
pause

<old_string> peut aussi être une chaîne précédée d'un astérisque (*), dans ce cas, la substitution commencera du début de la valeur de la variable et se finira après la première occurrence de la chaîne spécifiée dans la substitution. Exemple avec le script 11.

@echo off
set "X=string"
echo Substitution avec astérisque: %X:*t=d%
echo.
pause

Il ne faut jamais utiliser un astérisque seul dans la substitution, sans quoi, l'interpréteur de commande se fermera sans autres formes de procès. L'astérisque en fin de chaîne ne provoque pas d'erreur, mais ne permet pas la substitution, la variable est expansée avec sa valeur d'origine.

La substitution ne modifie pas la valeur de la variable, elle transforme juste la variable au moment de son expansion. Pour modifier la valeur de la variable, il faut le faire avec la commande set. Exemple avec le script 12.

@echo off
set "VAR=ma chaîne"
echo %VAR%
set "VAR=%VAR:chaîne=voiture%"
echo %VAR%
pause

Vous pouvez aussi ne développer qu'une partie d'une chaîne en sélectionnant les caractères voulus. Cela se fait via la syntaxe suivante (où <variable> est l'identifiant de la variable, <index> est l'index du premier caractère en partant de 0 et <longueur> est la longueur de la sélection). Exemple avec le script 13.

%<variable>:~<index>,<longueur>%

@echo off
set "VAR=ma chaîne"
echo %VAR:~0,2%
set "VAR=%VAR:~3,6%"
echo %VAR%
pause

Si la <longueur> n'est pas spécifiée, tout le reste de la chaîne est sélectionné, en partant du caractère fourni en <index>. Si une des valeurs données est négative, alors la valeur utilisée est la longueur totale de la chaîne ajoutée à la valeur négative.

@echo off
rem Dans ce script, les caractères ^^ servent à échapper les caractères spéciaux.
set "VAR=ma chaîne"
rem longueur de var :  9 caractères
echo %VAR:~-6%
rem   9+^(-6^) = 9-6 = 3
rem la chaîne sera développée à partir de l'index 3 et jusqu'à la fin ^(aucune longueur n'est donnée^).
echo %VAR:~0,-7%
rem    9+^(-7^) = 9-7 = 2
rem la chaîne sera développée à partir de l'index 0 et sur une longueur de 2 caractères
pause

La commande set /a permet d'utiliser les nombres entiers signés allant de -2 147 483 648 à +2 147 483 647 (codés sur 32bits). Si vous n'utilisez pas le paramètre /a dans la commande, alors la séquence de chiffres sera considérée comme étant une chaîne de caractères, et non un nombre. La syntaxe de la commande set /a est la suivante.

set /a <expression>

<expression> utilise, quant à elle, la syntaxe suivante.

["]<identifiant>[<attribution>[{<immédiate>|<sous-expression>}]]["]

Les expressions numériques doivent être placées entre des guillemets si elles contiennent des opérateurs logiques ou de groupement (détaillé plus loin dans ce chapitre). Ces différentes constituantes sont :

• <identifiant> qui est l'identifiant de la variable de destination ;
• <attribution> qui est l'opérateur d'attribution de l'expression, comme le signe égal qui effectue l'opération d'attribuer une valeur à une variable, d'autres opérateurs d'attribution seront détaillés dans cette section ;
• puis soit <immédiate> qui est une valeur immédiate (un nombre quelconque), soit <sous-expression> qui est une sous-expression, ces dernières seront détaillées dans le reste de cette section.

Vous pouvez spécifier plusieurs expressions en les séparant par des virgules.

@echo off
set /a "VAR1=1", "VAR2=2"
echo VAR1: %VAR1%
echo VAR2: %VAR2%
pause

Les chaînes de caractères présentes dans l'expression sont considérées comme des variables et sont expansées (à l'exception de l'identifiant de la variable de destination), cela permet de faire des opérations sur des variables sans avoir à utiliser de symbole % pour leur expansion.

@echo off
set /a "VAR1=1"
set /a "VAR2=VAR1"
echo VAR1: %VAR1%
echo VAR2: %VAR2%
pause

Si un nom de variable inexistante ou indéfinie est utilisé, alors elle prend la valeur 0.

@echo off
rem La variable VAR1 n'existe pas.
set /a "VAR2=VAR1"
echo VAR2: %VAR2%
pause

Les sous-expressions sont constituées de nombres, d'opérateurs et éventuellement de parenthèses, ces dernières s'utilisent de la même manière qu'en mathématiques et elles n'ont pas besoin d'être échappées si, et seulement si, les guillemets sont utilisés. Toutes les constituantes d'une sous-expression sont soumises à la préséance, c'est-à-dire l'ordre dans lequel les diverses constituantes vont être évaluées. L'ordre de préséance utilisé est le suivant (dans l'ordre décroissant d'évaluation) :

• le groupement soit ( ) ;
• les opérateurs unaires ! ~ - ;
• les opérateurs arithmétiques * / % ;
• les opérateurs arithmétiques + - ;
• le décalage logique << >> ;
• le ET au niveau du bit & ;
• le OU exclusif au niveau du bit ^ ;
• le OU inclusif au niveau du bit | ;
• l''attribution = *= /= %= += -= &= ^= |= <<= >>= ;
• le séparateur d'expression ,.

Il faut également noter que l'utilisation du nombre -2 147 483 648 tel quel dans une expression provoque une erreur, c'est dû au transtypage effectué par l'interpréteur. Ce dernier évalue d'abord la chaîne 2 147 483 648 afin de la transtyper puis lui applique l'opérateur unaire -. Mais comme le nombre 2 147 483 648 va au-delà de la définition d'un nombre sur 32bits, l'opération génère une erreur, exemple avec le script suivant.

@echo off
echo Nombre brute:
set /a "ParseError=-2147483648"
echo %ParseError%
echo.
echo Nombre avec évaluation:
set /a "ParseError=-2147483647 - 1"
echo %ParseError%
echo.
pause

Une autre méthode qui fonctionne pour ce cas est la suivante.

@echo off
set "SInt32=-2147483648"
set /a "SInt32"
echo %SInt32%
pause

II-D-1. Les opérations arithmétiques▲

La commande set /a prend en charge les cinq opérations arithmétiques suivantes :

• l'addition ;
• la soustraction ;
• la multiplication ;
• la division ;
• et le modulo (le modulo est une opération qui sert à récupérer le reste d'une division).

Opérateur arithmétique	Opérateur d'attribution	Opération effectuée
+	+=	Addition
-	-=	Soustraction
*	*=	Multiplication
/	/=	Division
%	%=	Modulo

Tableau 4 : Opérations arithmétiques

Une note particulière pour le modulo : dans un script de commande, le symbole du modulo % doit être préfixé du caractère d'échappement %. Dans ce cas, c'est un piège dans lequel le novice peut se perdre, le premier symbole % est un caractère d'échappement qui permet au deuxième symbole %, le modulo, d'être pris en compte à l'exécution du script. Dans l'interpréteur de commande, le modulo (%) n'as pas besoin d'être échappé, c'est une spécificité du script. Ainsi la commande suivante fonctionne dans l'interpréteur.

set /a "Mod=5 % 2"

Alors que celle-ci ne fonctionne pas.

set /a "Mod=5 %% 2"

Dans un script, par contre, c'est l'inverse.

Script 20

Sélectionnez

1.
2.
3.
4.
5.
6.

@echo off
set /a "Mod=5 % 2"
echo Mod1: %Mod%
set /a "Mod=5 %% 2"
echo Mod2: %Mod%
pause

Ainsi, les opérations arithmétiques s'utilisent de manière « classique » dans les sous-expressions. Si une variable inexistante ou indéfinie est utilisée dans une sous-expression, elle prend la valeur 0, exemple avec le script 21.

Script 21

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

@echo off
set /a "Un=1"
set /a "Deux=1 + 1"
set /a "Trois=4 - 1"
set /a "Quatre=2 * 2"
set /a "Cinq=10 / 2"
set /a "Six=26 %% 10"
set /a "Sept=(( 2 + 1 ) * 2 ) + 1"
rem La variable Dix n'existe pas.
set /a "Huit=8+Dix","Neuf=10-Un"
echo %Un%, %Deux%, %Trois%, %Quatre%, %Cinq%, %Six%, %Sept%, %Huit%, %Neuf%
echo.
pause

L'attribution permet d'effectuer des opérations sur des variables existantes, si une variable inexistante ou indéfinie est utilisée, elle prend la valeur 0.

Script 22

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

@echo off
set /a "Attrib1=1","Attrib2=2","Attrib3=3","Attrib4=4","Attrib5=5"
rem La variable Attrib0 n'existe pas.
set /a "Attrib0+=1"
set /a "Attrib1+=1"
set /a "Attrib2*=2"
set /a "Attrib3-=2"
set /a "Attrib4/=2"
set /a "Attrib5%%=2"
echo %Attrib0%, %Attrib1%, %Attrib2%, %Attrib3%, %Attrib4%, %Attrib5%
echo.
pause

II-D-2. Les opérations logiques▲

Elles ne peuvent s'effectuer que sur des nombres et suivent les règles de l'algèbre de Boole. Les opérations logiques prises en charge par la commande set /a possèdent, elles aussi, des opérateurs d'attribution. Exemple avec le script 23.

Opérateur logique	Opérateur d'attribution	Description
&	&=	ET logique au niveau du bit. (Bitwise AND)
^	^=	OU exclusif au niveau du bit. (Bitwise XOR)
|	|=	OU inclusif au niveau du bit. (Bitwise OR)
<<	<<=	Décalage logique vers la gauche. Le bit entrant est à zéro (pour l'élévation par puissances de deux).
>>	>>=	Décalage logique vers la droite. Le bit entrant est égal au bit de signe (pour la propagation du bit de signe).

Tableau 5 : Les opérateurs logiques

Script 23

Sélectionnez

@echo off
set /a "Val1=-2147483647 - 1"
set /a "Val2=1"
set /a "Val1SwitchL01=Val1<<1","Val1SwitchL15=Val1<<15","Val1SwitchL31=Val1<<31"
set /a "Val2SwitchL01=Val2<<1","Val2SwitchL15=Val2<<15","Val2SwitchL31=Val2<<31"
set /a "Val1SwitchR01=Val1>>1","Val1SwitchR15=Val1>>15","Val1SwitchR31=Val1>>31"
set /a "Val2SwitchR01=Val2>>1","Val2SwitchR15=Val2>>15","Val2SwitchR31=Val2>>31"
set /a "Val1AttribSwitchR=Val1","Val1AttribSwitchR>>=15"
set /a "Val2AttribSwitchL=Val2","Val2AttribSwitchL<<=15"
echo %Val1% ^<^< 1: %Val1SwitchL01%
echo %Val1% ^<^< 15: %Val1SwitchL15%
echo %Val1% ^<^< 31: %Val1SwitchL31%
echo.
echo %Val2% ^<^< 1: %Val2SwitchL01%
echo %Val2% ^<^< 15: %Val2SwitchL15%
echo %Val2% ^<^< 31: %Val2SwitchL31%
echo.
echo %Val1% ^>^> 1: %Val1SwitchR01%
echo %Val1% ^>^> 15: %Val1SwitchR15%
echo %Val1% ^>^> 31: %Val1SwitchR31%
echo.
echo %Val2% ^>^> 1: %Val2SwitchR01%
echo %Val2% ^>^> 15: %Val2SwitchR15%
echo %Val2% ^>^> 31: %Val2SwitchR31%
echo.
echo %Val1% ^>^>= 15: %Val1AttribSwitchR%
echo %Val2% ^<^<= 15: %Val2AttribSwitchL%
echo.
set /a "Val3=1431655765"
set /a "Val4=-858993460"
set /a "Val3LogicalOrVal4=Val3 | Val4"
set /a "Val3LogicalXorVal4=Val3 ^ Val4"
set /a "Val3LogicalAndVal4=Val3 & Val4"
set /a "Val3AttribOrVal4=Val3","Val3AttribOrVal4|=Val4"
set /a "Val3AttribXorVal4=Val3","Val3AttribXorVal4^=Val4"
set /a "Val3AttribAndVal4=Val3","Val3AttribAndVal4&=Val4"
echo %Val3% ^| %Val4%: %Val3LogicalOrVal4%
echo %Val3% ^|= %Val4%: %Val3AttribOrVal4%
echo.
echo %Val3% ^^ %Val4%: %Val3LogicalXorVal4%
echo %Val3% ^^= %Val4%: %Val3AttribXorVal4%
echo.
echo %Val3% ^& %Val4%: %Val3LogicalAndVal4%
echo %Val3% ^&= %Val4%: %Val3AttribAndVal4%
echo.
pause

II-D-3. Les opérateurs unaires▲

N.B. : Dans les sections II.D.3, II.ELes nombres entiers signés en notation hexadécimale et II.FLes nombres entiers signés en notation octale de ce document, sont abordés différents concepts de représentation numérique communément utilisés en informatique, tels que :

• l'écriture de nombre en binaire ;
• l'écriture de nombre en hexadécimal ;
• l'écriture de nombre en octal ;
• la représentation des nombres en complément à un ;
• la représentation des nombres entiers signés en complément à deux.

Il est donc nécessaire, si vous ne les connaissez pas, de faire des recherches sur Wikipédia.

• Système binaire, complément à un et complément à deux ;
• Notation octale ;
• Notation hexadécimale.

Les opérateurs unaires ne s'appliquent qu'aux nombres qu'ils précèdent, ils ne possèdent donc pas d'opérateur d'attribution. Leur syntaxe est la suivante (où <unaire> est l'opérateur unaire et <nombre> est le nombre auquel il s'applique).

<unaire><nombre>

Opérateur unaire	Description
!	NON logique, renvoie 1 si le nombre est égal à 0 et 0 sinon. (Logical NOT).
~	NON au niveau du bit, complément à un. (Bitwise NOT)
-	Renvoie la valeur inverse, soit un nombre négatif si le nombre d'origine est positif, complément à deux. (NEG)

Tableau 6 : Les opérateurs unaires

Exemple avec le script 24.

Script 24

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

@echo off

rem Veuillez vous assurer d'utiliser le bon encodage, sans quoi l'affichage ne sera pas celui attendu.

set /a "Val1=2147483647"
set /a "Val2=1"
set /a "Val3=0"

set /a "LogicalNOT_Val1=!Val1"
set /a "LogicalNOT_Val2=!Val2"
set /a "LogicalNOT_Val3=!Val3"

set /a "BitwiseNOT_Val1=~Val1"
set /a "BitwiseNOT_Val2=~Val2"
set /a "BitwiseNOT_Val3=~Val3"

set /a "NEG_Val1=-Val1"
set /a "NEG_Val2=-Val2"
set /a "NEG_Val3=-Val3"

echo              ╔════════════════════════════════════════╗
echo              ║                 Nombre                 ║
echo ╔════════════╬═════════════╦═════════════╦════════════╣
echo ║ Opérateur  ║ %Val1%  ║      %Val2%      ║     %Val3%      ║
echo ╠════════════╬═════════════╬═════════════╬════════════╣
echo ║ LogicalNOT ║ %LogicalNOT_Val1%           ║ %LogicalNOT_Val2%           ║ %LogicalNOT_Val3%          ║
echo ╠════════════╬═════════════╬═════════════╬════════════╣
echo ║ BitwiseNOT ║ %BitwiseNOT_Val1% ║ %BitwiseNOT_Val2%          ║ %BitwiseNOT_Val3%         ║
echo ╠════════════╬═════════════╬═════════════╬════════════╣
echo ║ NEG        ║ %NEG_Val1% ║ %NEG_Val2%          ║ %NEG_Val3%          ║
echo ╚════════════╩═════════════╩═════════════╩════════════╝

echo.
pause

Les nombres en notation hexadécimale doivent être déclarés comme des nombres entiers en notation décimale (ce que nous avons utilisé jusqu'à maintenant) avec la commande set /a "<expression>" et toujours être préfixés par 0x (chiffre zéro suivi de la lettre « x »). La commande set /a a pour effet de transformer toutes les valeurs entrées en valeurs numériques. Si c'est une chaîne de caractères alors la commande cherchera une variable portant ce nom, si c'est un nombre hexadécimal alors la commande set /a codera le nombre tel quel en binaire. Cependant, même si un nombre est fourni en notation hexadécimale, l'interpréteur l'expanse toujours en notation décimale, exemple avec le script 25.

@echo off
rem le nombre 0x1 vaut 1 et le nombre 0x3 vaut 3.
set /a "Hexa=0x1 + 0x3"
echo Résultat:    %Hexa%
pause

Le résultat du script 25 nous montre que le calcul s'effectue correctement, de même avec le script 26.

@echo off
rem le nombre 0x5 vaut 5 et le nombre 0x8 vaut 8.
set /a "Hexa=0x5 + 0x8"
rem Le résultat doit donc être 0xD qui vaut 13.
echo Résultat:    %Hexa%
pause

Jusque-là tout va bien même si le résultat n'est pas en notation hexadécimale, il est quand même celui attendu. Le problème c'est que l'interpréteur de commande utilise toujours la représentation en complément à deux pour coder un nombre entier signé. Ainsi, dès lors que l'on utilise un nombre en notation hexadécimale supérieur à 0x7FFFFFFF (soit 2 147 483 647 en notation décimale), ce nombre est en fait un nombre négatif comme le montre le script 27.

@echo off
set /a "Hexa=0x80000000"
echo Résultat:    %Hexa%
pause

Un résultat plutôt déroutant pour quiconque ne s'y attend pas, en effet la représentation en complément à deux code les nombres négatifs de 0xFFFFFFFF, soit -1, à 0x80000000, soit -2 147 483 648. Exemple avec le script 28.

@echo off
rem 0x80000000 vaut -2147483648 et 0x7FFFFFFF vaut 2147483647
set /a "Hexa=0x80000000 + 0x7FFFFFFF"
rem Le résultat doit donc être 0xFFFFFFFF qui vaut -1.
echo Résultat:    %Hexa%
pause

Comme vous pouvez le voir, on additionne 0x80000000 (soit -2 147 483 648 en représentation hexadécimale en complément à deux) à 0x7FFFFFFF (soit +2 147 483 647, toujours dans la même représentation) ce qui nous donne le résultat de -1, le résultat est un nombre entier signé décimal utilisant la représentation en complément à deux codé sur 32bits soit 0xFFFFFFFF. Pour récupérer un nombre hexadécimal, il faut le calculer à l'aide d'un algorithme de divisions successives ; et pour les nombres négatifs, de l'opérateur unaire « Bitwise NOT » dont dispose la commande set /a, voir le script 29.

@echo off
rem On récupère un nombre sous forme de chaîne et le place dans SInt32.
set "SInt32=-2147483648"
rem On transtype SInt32 en nombre pour qu'il soit évalué correctement.
set /a "SInt32"
rem Puis on effectue un NON au niveau du bit pour obtenir son complément à un ^(nombre négatif^).
set /a "SInt32=~SInt32"
rem On utilise un algorithme de divisions successives par 16 pour obtenir des 
rem nombres en base 16 ^(hexadécimale^), chaque nombre obtenu forme un quartet.
set /a "Nibble0= SInt32 %% 16","HighOrder0= SInt32 / 16"
set /a "Nibble1=HighOrder0 %% 16","HighOrder1=HighOrder0 / 16"
set /a "Nibble2=HighOrder1 %% 16","HighOrder2=HighOrder1 / 16"
set /a "Nibble3=HighOrder2 %% 16","HighOrder3=HighOrder2 / 16"
set /a "Nibble4=HighOrder3 %% 16","HighOrder4=HighOrder3 / 16"
set /a "Nibble5=HighOrder4 %% 16","HighOrder5=HighOrder4 / 16"
set /a "Nibble6=HighOrder5 %% 16"
set /a "Nibble7=HighOrder5 / 16"
rem On retranche chaque valeur à 15 pour récupérer le nombre original.
set /a "Nibble0=15 - Nibble0"
set /a "Nibble1=15 - Nibble1"
set /a "Nibble2=15 - Nibble2"
set /a "Nibble3=15 - Nibble3"
set /a "Nibble4=15 - Nibble4"
set /a "Nibble5=15 - Nibble5"
set /a "Nibble6=15 - Nibble6"
set /a "Nibble7=15 - Nibble7"
rem Les quartets 0 à 3 forment le Least Significant Word ^(LSW^) ou mot de poids faible dans la langue de Molière.
set "LSW=%Nibble3% %Nibble2% %Nibble1% %Nibble0%"
rem Les quartets 4 à 7 forment le Most Significant Word ^(MSW^) ou mot de poids fort toujours dans la langue de Molière.
set "MSW=%Nibble7% %Nibble6% %Nibble5% %Nibble4%"
echo %MSW% %LSW%
rem On récupère un nouveau nombre ^(nombre positif^).
set "SInt32=2147483647"
set /a "SInt32"
set /a "Nibble0= SInt32 %% 16","HighOrder0= SInt32 / 16"
set /a "Nibble1=HighOrder0 %% 16","HighOrder1=HighOrder0 / 16"
set /a "Nibble2=HighOrder1 %% 16","HighOrder2=HighOrder1 / 16"
set /a "Nibble3=HighOrder2 %% 16","HighOrder3=HighOrder2 / 16"
set /a "Nibble4=HighOrder3 %% 16","HighOrder4=HighOrder3 / 16"
set /a "Nibble5=HighOrder4 %% 16","HighOrder5=HighOrder4 / 16"
set /a "Nibble6=HighOrder5 %% 16"
set /a "Nibble7=HighOrder5 / 16"
set "LSW=%Nibble3% %Nibble2% %Nibble1% %Nibble0%"
set "MSW=%Nibble7% %Nibble6% %Nibble5% %Nibble4%"
echo %MSW% %LSW%
pause

La sortie du script 29 nous donne bien des nombres hexadécimaux, mais dans une représentation décimale (8 0 0 0 0 0 0 0 soit -2 147 483 648 codé 0x80000000 et 7 15 15 15 15 15 15 15 soit 2 147 483 647 codé 0x7FFFFFFF), pour pouvoir les convertir dans une notation hexadécimale ; il nous faut utiliser les conditions que nous étudierons au prochain chapitre.

Les nombres en notation octale fonctionnent comme les autres et supportent les mêmes opérations. Pour être considérés par l'interpréteur comme des nombres en notation octale, ils doivent être préfixés par 0 (chiffre zéro). Ils vont donc de -2 147 483 648 à 2 147 483 647 (codés sur 32bits) soit en notation octale -020000000000 à +017777777777. Les nombres en notation octale sont codés tels quels en binaire, mais le principe selon lequel tout nombre est expansé en entier signé en notation décimale codé en complément à deux s'applique aussi pour eux. Notez aussi qu'ils ont le même problème de transtypage que les nombres décimaux, exemple avec le script 30.

@echo off
set /a "Octal1=-017777777777 - 1"
set /a "Octal2=017777777777"
set /a "Octal3=Octal1 + Octal2"
echo Octal1: %Octal1%
echo Octal2: %Octal2%
echo Octal3: %Octal3%
pause

Notez aussi que l'utilisation des nombres « 08 » et « 09 » génère toujours une erreur du fait qu'ils sont préfixés par « 0 » ; et, que « 8 » et « 9 » ne sont pas des chiffres octaux. Lorsque la commande set /a rencontre un « 0 » en début de nombre, elle considère que tous les chiffres qui se trouvent après sont des octaux et lorsqu'elle rencontre « 8 » ou « 9 », le transtypage ne peut s'effectuer et la commande se termine sur une erreur. Exemple avec le script 31.

@echo off
echo Nombre 08:
set /a "Octal1=08"
echo.
echo Nombre 09:
set /a "Octal1=09"
echo.
pause

La commande if se traduit simplement par « si » : « si » la condition est vraie, fais ceci ; elle peut être accompagnée par le paramètre else qui se traduit par « sinon » : « si » la condition est vraie, fais ceci, « sinon » fais cela. La syntaxe de la commande if est la suivante.

if <condition> <commande1> [else <commande2>]

Comme vous pouvez le voir sur la syntaxe de la commande if, if vient en premier suivi de sa <condition> et d'une commande (<commande1>), puis vient else et une commande (<commande2>), on peut le traduire par :

• si (if) la <condition> se vérifie alors la <commande1> s'exécute ;
• sinon (else) c'est la <commande2> qui s'exécute.

Le paramètre else ne peut être utilisé seul, il doit toujours être utilisé avec la commande if, et être sur la même ligne. Il y a deux règles importantes à garder en tête lorsqu'on utilise des conditions :

• la première est que l'on ne peut utiliser qu'un maximum de 2048 caractères (sous Windows XP et inférieur) ou un peu plus de 4096 caractères (sous Windows Vista et supérieur) par ligne de commande, limite très vite atteinte avec plusieurs conditions, plus leurs commandes et leurs paramètres ;
• et la deuxième est que les parenthèses sont prises en compte par l'interpréteur de commande comme des opérateurs de bloc, c'est pour cela qu'il faut les échapper lorsque l'on ne s'en sert pas à cette fin.

Les opérateurs de bloc permettent d'utiliser un bloc de commande en lieu et place d'une commande. Ainsi, chaque fois que la syntaxe autorise l'utilisation d'une commande, celle-ci peut être remplacée par un bloc de commandes.

Ainsi la syntaxe de la commande if peut être modifiée de la manière suivante.

if <condition> (
    <commande1>
    <commande2>
) else (
    <commande3>
    <commande4>
)

L'utilisation des parenthèses comme opérateurs de bloc permet d'exécuter plusieurs commandes, par condition vérifiée, au lieu d'une seule. La parenthèse ouvrante associée à une condition doit se trouver sur la même ligne que cette dernière ; si une autre condition est utilisée conjointement, alors elle doit se trouver sur la même ligne que la parenthèse fermante associée à la condition qui la précède.

La commande if autorise aussi le paramètre else if qui se traduit par « sinon si », ce dernier permet de poser une condition supplémentaire avant l'exécution éventuelle du else. La syntaxe serait la suivante.

if <condition1> <cmd1> [else if <condition2> <cmd2>] [else <cmd3>]

Les opérateurs de bloc fonctionnent de la même manière avec le paramètre else if en plus. Il faut aussi noter que le paramètre else if peut être utilisé autant de fois que l'on veut dans la commande if.

if <condition1> (
    <commande1>
    <commande2>
) else if <condition2> (
    <commande3>
    <commande4>
) else if <condition3> (
    <commande5>
    <commande6>
) else (
    <commande7>
    <commande8>
)

La syntaxe ci-dessus pourrait être traduite par :

• si (if) la <condition1> est vraie : exécuter <commande1> et <commande2> ;
• sinon si (else if) <condition2> est vraie : exécuter <commande3> et <commande4> ;
• sinon si (else if) <condition3> est vraie : exécuter <commande5> et <commande6> ;
• sinon (else) : exécuter <commande7> et <commande8>.

Les conditions associées à la commande if et au paramètre else if prennent le modificateur not qui permet d'exécuter une commande si la condition est fausse. Le modificateur not ne s'applique pas à toutes les conditions de la même structure de contrôle. Si le paramètre else if est utilisé conjointement, son comportement dépendra de la présence, ou non, du modificateur not à l'intérieur de la condition.

if not <condition1> <cmd1> else if <condition2> <cmd2> else <cmd3>

La commande ci-dessus se traduit par :

• si (if) la <condition1> est fausse : exécuter la <cmd1> ;
• sinon (else if), si la <condition2> est vraie : exécuter la <cmd2> ;
• sinon (else), si la <condition1> est vraie et que la <condition2> est fausse, exécuter la <cmd3>.

Les conditions associées à la commande if et au paramètre else if prennent le modificateur /i qui permet de ne pas tenir compte de la casse lorsque la condition traite des chaînes de caractères. Ce modificateur ne fonctionne que sur les conditions qui traitent des chaînes de caractères. Si le paramètre else if est utilisé conjointement, son comportement dépendra de la présence, ou non, du modificateur /i à l'intérieur de la condition.

if /i <condition1> <cmd1> else if /i <condition2> <cmd2> else <cmd3>

Se traduit par :

• si (if) la <condition1> est vraie, sans tenir compte de la casse, exécuter la <cmd1> ;
• sinon si (else if) la <condition2> est vraie, sans tenir compte de la casse, exécuter la <cmd2> ;
• sinon (else), si la <condition1> est fausse sans tenir compte de la casse et que la <condition2> est fausse sans tenir compte de la casse, exécuter la <cmd3>.

Nous allons maintenant voir quelles sont les conditions supportées par la commande if et le paramètre else if.

La condition exist <path> permet de tester si un chemin d'accès ou un fichier existe. Elle peut être utilisée avec le paramètre else if et le modificateur not. Le modificateur /i ne fonctionne pas sur cette condition. Sa syntaxe est la suivante, où <path> est le chemin d'accès ou le fichier à tester. Si le chemin d'accès contient des espaces, il doit être placé entre guillemets.

if [not] exist ["]<path>["] <commande>

Exemple avec le script 32.

@echo off
if exist "%cd%" echo %cd% existe bien.
pause

La condition defined <variable> permet de tester si une variable a une valeur définie. Elle peut être utilisée avec le paramètre else if, et le modificateur not. Le modificateur /i ne fonctionne pas sur cette condition. Voir le script 33.

if [not] defined <variable> <commande>

@echo off
set "Def1="
set "Def2=abcd"
if defined Def1 (
    echo Def1 est définie.
) else (
    echo Def1 n'est pas définie.
)
if defined Def2 (
    echo Def2 est définie.
) else (
    echo Def2 n'est pas définie.
)
if not defined Def3 (
    echo Def3 n'est pas définie.
) else (
    echo Def3 est définie.
)
pause

La condition errorlevel <opérande> permet de tester si le code d'erreur de la dernière commande exécutée est égal ou supérieur au nombre donné en <opérande>. Le code d'erreur est un nombre renvoyé par une commande pour donner des informations sur le déroulement de son exécution, il est aussi accessible via la variable ErrorLevel. En général, le code d'erreur est 0 si aucune erreur ne s'est produite ; et il est égal ou supérieur à 1 si une erreur s'est produite, chaque code d'erreur correspondant à une erreur précise. Le nom de variable ErrorLevel est un nom de variable réservé, vous pouvez la modifier en l'écrasant avec une nouvelle valeur, cependant, elle prendra la valeur donnée jusqu'à la fin du script. Attention toutefois, il arrive que des commandes ne modifient pas la variable ErrorLevel ou bien qu'elle lui donne toujours le code 0, ceci est souvent dû à de mauvaises pratiques de programmation, fiez-vous à des codes d'erreurs connues et ayant une valeur concrète, ne traitez pas les autres, pour ce faire, consultez le manuel ou l'aide de la commande concernée. Si le modificateur not est utilisé, la <commande> seras exécutée seulement si ErrorLevel est inférieur à l'<opérande>. Le modificateur /i n'est pas supporté par la condition errorlevel <opérande>.

if [not] errorlevel <opérande> <commande>

@echo off
rem La commande « setlocal » crée un environnement local pour ne pas générer d'erreur si le script est appelé depuis l'interpréteur.
setlocal
set "TestError1=Un petit test"
if not errorlevel 1 echo Aucune erreur dans la première commande.
echo.
set /a "TestError2=09"
echo.
if errorlevel 1 echo Le code d'erreur des nombres invalides est %ErrorLevel%.
pause
rem  La commande « endlocal » supprime l'environnement local.
endlocal

La condition cmdextversion <opérande> permet de tester si le numéro de version des extensions de commande est égal ou supérieur au nombre donné en <opérande>. Le numéro de version des extensions de commande est à prendre en compte, car selon la version des extensions, le traitement des commandes peut être modifié. Reportez-vous à l'aide concernant les commandes citées dans le tableau 7 pour plus de détails. Chaque commande modifiée l'est d'une manière qui lui est propre ; ainsi la commande assoc ne sera pas modifiée de la même manière que la commande start, tout simplement parce qu'elle n'exécute pas du tout la même opération.

Tableau 7 : Commandes soumises aux extensions

La condition cmdextversion <opérande> est toujours fausse si les extensions de commande sont désactivées ; la première version des extensions est la version « 1 » et le numéro de version est incrémenté de 1 à chaque nouvelle version. Si le numéro de version des extensions est égal ou supérieur à la valeur donnée dans la condition cmdextversion <opérande> alors la condition est vraie ; les extensions de commande étant rétrocompatibles d'une version à l'autre. Si le modificateur not est utilisé, la condition est vraie si le numéro de version des extensions de commande est inférieur au nombre donné en <opérande>. La condition cmdextversion <opérande> ne prend pas le modificateur /i. Le tableau 8 donne la liste des révisions d'extensions de commande en fonction du système d'exploitation.

Tableau 8 : Révisions des extensions de commande

if [not] cmdextversion <opérande> <commande>

@echo off
rem La commande « setlocal enableextensions » active les extensions de commande.
setlocal enableextensions
if not cmdextversion 1 (
    echo CmdExtVersion 1:  Not Detected.
) else (
    echo CmdExtVersion 1:  Detected. 
)
if cmdextversion 2 (
    echo CmdExtVersion 2:  Detected.
) else (
    echo CmdExtVersion 2:  Not Detected. 
)
if cmdextversion 3 (
    echo CmdExtVersion 3:  Detected.
) else (
    echo CmdExtVersion 3:  Not Detected. 
)
pause

La condition <chaîne1> <comparateur> <chaîne2> permet d'effectuer des comparaisons sur des chaînes et des nombres. La comparaison de chaînes est effectuée au moyen d'un XOR au niveau du bit entre chaque octet d'une chaîne puis les résultats obtenus sur les différentes chaînes sont comparés numériquement. Si les deux chaînes ne sont constituées que de chiffres alors elles sont transtypées en nombre puis évaluées numériquement. Les comparateurs, pris en compte par la condition <chaîne1> <comparateur> <chaîne2>, sont listés dans le tableau 9. La condition <chaîne1> <comparateur> <chaîne2> prend les modificateurs not et /i. Sa syntaxe est la suivante, si les chaînes contiennent des espaces, elles doivent être placées entre guillemets.

if [/i] [not] ["]<chaîne1>["] <comparateur> ["]<chaîne2>["] <cmd>

Tableau 9 : Opérateurs de comparaison

@echo off
cls
set "Chaîne1=Un Petit test"
rem Encodage de la Chaîne1 :55 6E 20 50 65 74 69 74 20 74 65 73 74
set /a "C1X=0x55^0x6E^0x20^0x50^0x65^0x74^0x69^0x74^0x20^0x74^0x65^0x73^0x74"
set "Chaîne2=Un petit test"
rem Encodage de la Chaîne2 : 55 6E 20 70 65 74 69 74 20 74 65 73 74
set /a "C2X=0x55^0x6E^0x20^0x70^0x65^0x74^0x69^0x74^0x20^0x74^0x65^0x73^0x74"
set "Chaîne3=Un grand test"
rem Encodage de la Chaîne3 : 55 6E 20 67 72 61 6E 64 20 74 65 73 74
set /a "C3X=0x55^0x6E^0x20^0x67^0x72^0x62^0x6E^0x64^0x20^0x74^0x65^0x73^0x74"
set "Chaîne4=41"
set "Chaîne5=12"
echo               Chaîne 1         Chaîne 2          Chaîne 3
echo =============================================================
echo Chaîne        %Chaîne1%    %Chaîne2%    %Chaîne3%
echo Évaluation    %C1X%              %C2X%               %C3X%
echo.
if "%Chaîne1%" GTR "%Chaîne2%" (
    echo "%Chaîne1%" est supérieur à "%Chaîne2%".
) else if "%Chaîne1%" EQU "%Chaîne2%" (
    echo "%Chaîne1%" est égal à "%Chaîne2%".
) else if "%Chaîne1%" LSS "%Chaîne2%" (
    echo "%Chaîne1%" est inférieur à "%Chaîne2%".
)
if /i "%Chaîne1%" GTR "%Chaîne2%" (
    echo "%Chaîne1%" est supérieur à "%Chaîne2%".
) else if /i "%Chaîne1%" EQU "%Chaîne2%" (
    echo "%Chaîne1%" est égal à "%Chaîne2%".
) else if /i "%Chaîne1%" LSS "%Chaîne2%" (
    echo "%Chaîne1%" est inférieur à "%Chaîne2%".
)
if "%Chaîne1%" GTR "%Chaîne3%" (
    echo "%Chaîne1%" est supérieur à "%Chaîne3%".
) else if "%Chaîne1%" EQU "%Chaîne3%" (
    echo "%Chaîne1%" est égal à "%Chaîne3%".
) else if "%Chaîne1%" LSS "%Chaîne3%" (
    echo "%Chaîne1%" est inférieur à "%Chaîne3%".
)
if /i "%Chaîne1%" GTR "%Chaîne3%" (
    echo "%Chaîne1%" est supérieur à "%Chaîne3%".
) else if /i "%Chaîne1%" EQU "%Chaîne3%" (
    echo "%Chaîne1%" est égal à "%Chaîne3%".
) else if /i "%Chaîne1%" LSS "%Chaîne3%" (
    echo "%Chaîne1%" est inférieur à "%Chaîne3%".
)
if "%Chaîne3%" GTR "%Chaîne2%" (
    echo "%Chaîne3%" est supérieur à "%Chaîne2%".
) else if "%Chaîne3%" EQU "%Chaîne2%" (
    echo "%Chaîne3%" est égal à "%Chaîne2%".
) else if "%Chaîne3%" LSS "%Chaîne2%" (
    echo "%Chaîne3%" est inférieur à "%Chaîne2%".
)
if /i "%Chaîne3%" GTR "%Chaîne2%" (
    echo "%Chaîne3%" est supérieur à "%Chaîne2%".
) else if /i "%Chaîne3%" EQU "%Chaîne2%" (
    echo "%Chaîne3%" est égal à "%Chaîne2%".
) else if /i "%Chaîne3%" LSS "%Chaîne2%" (
    echo "%Chaîne3%" est inférieur à "%Chaîne2%".
)
echo.
echo.
echo               Chaîne 4    Chaîne 5         
echo =============================================================
echo Chaîne        %Chaîne4%          %Chaîne5%
echo.
if %Chaîne4% GTR %Chaîne5% (
    echo %Chaîne4% est supérieur à %Chaîne5%.
) else if %Chaîne4% EQU %Chaîne5% (
    echo %Chaîne4% est égal à %Chaîne5%.
) else if %Chaîne4% LSS %Chaîne5% (
    echo %Chaîne4% est inférieur à %Chaîne5%.
)
echo.
pause

La condition "<chaîne1>"=="<chaîne2>" permet de tester une égalité entre des chaînes de caractères. Les chaînes doivent être placées entre guillemets si elles sont susceptibles de contenir des espaces. Cette condition prend les modificateurs not et /i.

@echo off
cls
set "Un=Une Chaîne"
set "Deux=une chaîne"
if "%Un%"=="%Deux%" (
    echo If:      "%Un%"    est égale à    "%Deux%".
) else (
    echo If:      "%Un%" n'est pas égale à "%Deux%".
)
if not "%Un%"=="%Deux%" (
    echo If Not:  "%Un%" n'est pas égale à "%Deux%".
) else (
    echo If Not:  "%Un%"    est égale à    "%Deux%".
)
if /i "%Un%"=="%Deux%" (
    echo If /i:   "%Un%"    est égale à    "%Deux%".
) else (
    echo If /i:   "%Un%" n'est pas égale à "%Deux%".
)
pause

Dans cette section, nous allons reprendre le script 29 qui permettait de transformer un entier en sa représentation hexadécimale en notation en complément à deux. Grâce à la commande if, nous allons faire en sorte de traiter les nombres négatifs et positifs avec la même fonction de calcul et d'afficher le résultat dans une forme hexadécimale correcte.

@echo off
rem On crée un environnement local pour ne pas générer d'erreur.
setlocal
rem On récupère un nombre sous forme de chaîne et on le place dans SInt32.
set /p "SInt32=Entrez un nombre entre -2147483648 et 2147483647:    "
rem On transtype SInt32 en nombre pour qu'il soit évalué correctement.
set /a "SInt32"
rem On utilise une variable témoin pour savoir si le nombre est 
rem négatif ou pas sans avoir à le réévaluer à chaque fois.
rem Par défaut, on considère que le nombre est positif.
set "NegNum=false"
rem Si SInt32 est inférieur à zéro, il est négatif,
rem     alors on effectue un NON au niveau du bit pour obtenir son complément à un
rem     et on met NegNum à "true" pour définir le nombre comme négatif.
if %SInt32% LSS 0 (
    set /a "SInt32=~SInt32"
    set "NegNum=true"
)
rem On utilise un algorithme de divisions successives par 16 pour obtenir des 
rem nombres en base 16, chaque nombre obtenu forme un quartet.
set /a "Nibble0= SInt32 %% 16","HighOrder0= SInt32 / 16"
set /a "Nibble1=HighOrder0 %% 16","HighOrder1=HighOrder0 / 16"
set /a "Nibble2=HighOrder1 %% 16","HighOrder2=HighOrder1 / 16"
set /a "Nibble3=HighOrder2 %% 16","HighOrder3=HighOrder2 / 16"
set /a "Nibble4=HighOrder3 %% 16","HighOrder4=HighOrder3 / 16"
set /a "Nibble5=HighOrder4 %% 16","HighOrder5=HighOrder4 / 16"
set /a "Nibble6=HighOrder5 %% 16"
set /a "Nibble7=HighOrder5 / 16"
rem Si c'est un nombre négatif ^("%NegNum%"=="true"^),
rem     on retranche chaque valeur à 15 pour récupérer le nombre original.
if "%NegNum%"=="true" (
    set /a "Nibble0=15 - Nibble0"
    set /a "Nibble1=15 - Nibble1"
    set /a "Nibble2=15 - Nibble2"
    set /a "Nibble3=15 - Nibble3"
    set /a "Nibble4=15 - Nibble4"
    set /a "Nibble5=15 - Nibble5"
    set /a "Nibble6=15 - Nibble6"
    set /a "Nibble7=15 - Nibble7"
)
rem On transforme chaque quartet en notation hexadécimale.
if %Nibble0% GTR 9 (
    if %Nibble0% EQU 10 set "Nibble0=A"
    if %Nibble0% EQU 11 set "Nibble0=B"
    if %Nibble0% EQU 12 set "Nibble0=C"
    if %Nibble0% EQU 13 set "Nibble0=D"
    if %Nibble0% EQU 14 set "Nibble0=E"
    if %Nibble0% EQU 15 set "Nibble0=F"
)
if %Nibble1% GTR 9 (
    if %Nibble1% EQU 10 set "Nibble1=A"
    if %Nibble1% EQU 11 set "Nibble1=B"
    if %Nibble1% EQU 12 set "Nibble1=C"
    if %Nibble1% EQU 13 set "Nibble1=D"
    if %Nibble1% EQU 14 set "Nibble1=E"
    if %Nibble1% EQU 15 set "Nibble1=F"
)
if %Nibble2% GTR 9 (
    if %Nibble2% EQU 10 set "Nibble2=A"
    if %Nibble2% EQU 11 set "Nibble2=B"
    if %Nibble2% EQU 12 set "Nibble2=C"
    if %Nibble2% EQU 13 set "Nibble2=D"
    if %Nibble2% EQU 14 set "Nibble2=E"
    if %Nibble2% EQU 15 set "Nibble2=F"
)
if %Nibble3% GTR 9 (
    if %Nibble3% EQU 10 set "Nibble3=A"
    if %Nibble3% EQU 11 set "Nibble3=B"
    if %Nibble3% EQU 12 set "Nibble3=C"
    if %Nibble3% EQU 13 set "Nibble3=D"
    if %Nibble3% EQU 14 set "Nibble3=E"
    if %Nibble3% EQU 15 set "Nibble3=F"
)
if %Nibble4% GTR 9 (
    if %Nibble4% EQU 10 set "Nibble4=A"
    if %Nibble4% EQU 11 set "Nibble4=B"
    if %Nibble4% EQU 12 set "Nibble4=C"
    if %Nibble4% EQU 13 set "Nibble4=D"
    if %Nibble4% EQU 14 set "Nibble4=E"
    if %Nibble4% EQU 15 set "Nibble4=F"
)
if %Nibble5% GTR 9 (
    if %Nibble5% EQU 10 set "Nibble5=A"
    if %Nibble5% EQU 11 set "Nibble5=B"
    if %Nibble5% EQU 12 set "Nibble5=C"
    if %Nibble5% EQU 13 set "Nibble5=D"
    if %Nibble5% EQU 14 set "Nibble5=E"
    if %Nibble5% EQU 15 set "Nibble5=F"
)
if %Nibble6% GTR 9 (
    if %Nibble6% EQU 10 set "Nibble6=A"
    if %Nibble6% EQU 11 set "Nibble6=B"
    if %Nibble6% EQU 12 set "Nibble6=C"
    if %Nibble6% EQU 13 set "Nibble6=D"
    if %Nibble6% EQU 14 set "Nibble6=E"
    if %Nibble6% EQU 15 set "Nibble6=F"
)
if %Nibble7% GTR 9 (
    if %Nibble7% EQU 10 set "Nibble7=A"
    if %Nibble7% EQU 11 set "Nibble7=B"
    if %Nibble7% EQU 12 set "Nibble7=C"
    if %Nibble7% EQU 13 set "Nibble7=D"
    if %Nibble7% EQU 14 set "Nibble7=E"
    if %Nibble7% EQU 15 set "Nibble7=F"
)
rem Les quartets 0 à 3 forment le Least Significant Word.
set "LSW=%Nibble3%%Nibble2%%Nibble1%%Nibble0%"
rem Les quartets 4 à 7 forment le Most Significant Word.
set "MSW=%Nibble7%%Nibble6%%Nibble5%%Nibble4%"
rem on affiche le résultat.
echo 0x%MSW%%LSW%
rem Fin de l'environnement local.
endlocal
pause

Ce script sera un script témoin que nous ferons évoluer tout au long de ce document, il nous permettra de comparer les différentes approches et ce qu'elles impliquent comme contrainte d'utilisation.

En son état actuel, ce script est gourmand en ressource système, car à chaque ligne de commande correspond un appel vers l'interpréteur augmentant d'autant son temps de traitement. Les boucles for devraient nous permettre de réduire considérablement son coût en temps d'exécution et la taille du script par la même occasion.

Les labels sont des adresses relatives se présentant sous forme de chaînes de caractères préfixées par : et terminées par un caractère blanc (l'espace, la tabulation ou le retour à la ligne). Ces adresses relatives pointent vers le premier caractère situé après le retour à la ligne qui termine le label. Elles peuvent être utilisées pour adresser une portion de code. Chaque nom de label devrait être unique dans le script. La syntaxe d'un label est la suivante, où <Label>est le nom du label :

:<Label>

La commande goto effectue un saut inconditionnel vers le label spécifié en paramètre, permettant ainsi de continuer l'exécution du programme dans une portion de code située n'importe où dans le script. Une fois le saut effectué, l'exécution continue à la ligne qui suit le label spécifié :

goto [:]<Label>

@echo off

goto :MonLabel
echo Une phrase qui ne sera jamais affichée.

:MonLabel
echo Une phrase qui sera affichée.
pause

Dans le script 39, la commande echo Une phrase qui ne sera jamais affichée. n'est pas traitée, l'exécution étant redirigée par la commande goto :MonLabel vers la ligne suivant le label :MonLabel soit la commande echo Une phrase qui sera affichée.

L'exécution de l'interpréteur ou d'un script s'effectue dans un processus hôte auquel le système d'exploitation alloue un espace mémoire. Cet espace mémoire est appelé la pile. Une pile est une zone de mémoire dans laquelle les données sont placées les unes à la suite des autres. Les données qui y sont placées doivent être récupérées dans un ordre particulier : la dernière donnée placée doit être la première à être récupérée. Sur cette pile, le système y « place » ce que l'on appelle un contexte.

Lors de sa création, le contexte se voit attribuer, par le système, une série de variables : les variables d'environnement du système, des variables contenant la commande et les paramètres de la commande ayant généré le contexte et une adresse de sortie du contexte. Ainsi créé, le contexte représente l'environnement dans lequel le script va s'exécuter en lui permettant de disposer de données qui lui sont propres. À chaque nouvelle exécution d'un script ou d'une commande, l'interpréteur crée un nouveau contexte et le place sur la pile. Ce nouveau contexte est appelé contexte descendant.

Les variables d'environnement sont héritées du système lors de la création du processus hôte et se propagent par ascendance successive aux différents contextes descendants. Les variables contenant la commande et les arguments d'appels, elles, sont propres au contexte et ne se propagent jamais aux contextes descendants. L'adresse de sortie du contexte n'est pas accessible en tant que variable et, tout comme les arguments d'appel, est propre au contexte. Son rôle est plus amplement détaillé dans le reste du chapitre.

Certaines commandes s'exécutent dans le contexte en cours alors que d'autres créent leurs propres contextes. C'est, en partie, ce qui fait la différence entre commande interne et externe : les commandes internes sont en fait des fonctions internes de l'interpréteur qu'il est possible d'appeler via un alias de type « nom de commande », alors que les commandes externes sont des exécutables distincts de l'interpréteur. L'exécution d'une commande externe ou d'un script générera toujours un nouveau contexte. Les commandes internes s'exécutent toujours dans le contexte courant. Il faut cependant noter que les commandes internes, même si elles exécutent toujours leurs fonctions principales dans le contexte courant, peuvent créer des contextes descendants afin d'exécuter certaines fonctions comme la boucle for qui génère un contexte initial dans lequel se trouve l'ensemble à traiter et un contexte secondaire, créé à chaque itération de la boucle, dans lequel s'opère le traitement.

IV-C-1. La portée des variables▲

Les fonctions sont des portions de code « isolées », commençant par un label et finissant par un saut à une adresse spécifique : l'adresse de retour. La vraie différence avec une simple portion de code réside dans le fait qu'un nouveau contexte est créé, permettant ainsi aux fonctions de disposer de paramètres de commande et, dans certains cas, d'un code de sortie.

IV-D-1. L'appel de fonction▲

La commande call permet d'effectuer des appels de fonction. Elle a la particularité de créer un contexte dans lequel va s'exécuter la fonction appelée (la portion de code) ; lors de la création du contexte descendant, une adresse de retour et les arguments d'appel vont être empilés. La syntaxe de la commande call est la suivante, où <Label> est le nom de la fonction à appeler et <paramètre> est le ou les paramètres à passer à la fonction.

call :<label> [<paramètre> [...]]

Lors d'un appel à une fonction, si l'exécution est redirigée vers une autre adresse que l'adresse de retour et que, par la suite, d'autres appels sont effectués vers cette même fonction, alors la première adresse ne sera pas dépilée, occasionnant une fuite de mémoire. Si un script comporte ce cas, son exécution peut être stoppée par l'interpréteur (si l'utilisation de la pile atteint 90 %) comme le montre le script 40.

Script 40

Sélectionnez

1.
2.
3.
4.
5.

@echo off
:LabelUn
call :LabelDeux
:LabelDeux
goto :LabelUn

IV-D-2. Sortie de fonction▲

@echo off
rem On ajoute un compteur pour visualiser le parcours effectué.
set /a "Counter=0"
:LabelUn
call :LabelDeux
set /a "Counter+=1"
goto :LabelUn
:LabelDeux
echo %Counter%
goto :eof

Ils sont passés au contexte lors de sa création et sont accessibles sous la forme de variables spéciales : %n, n étant le numéro d'index du paramètre. En effet, chaque contexte étant généré suite à l'appel d'un script, d'une fonction ou d'une commande, il possède une commande d'appel et, la plupart du temps, de paramètres d'appel. L'index %0 contient le nom du script, de la fonction ou de la commande, l'index %1 contient le paramètre 1, l'index %2 contient le paramètre 2 et ainsi de suite. Le paramètre %* expanse tous les paramètres passés au contexte (%0 n'est pas un paramètre, mais une commande d'appel et n'est donc pas renvoyée par %*). Exemple avec le script 42 :

@echo off

call :MonLabel Param1 Param2
pause
rem Si tous les contextes créés pendant l'exécution du script ont
rem correctement été dépilés, alors le label «:eof » prend comme
rem valeur l'adresse de sortie du processus hôte.
goto :eof

:MonLabel
echo %*
echo %0
echo %1
echo %2
goto :eof

L'utilisation des paramètres suit plusieurs règles :

• les paramètres ne sont pas limités en nombre dans la commande d'appel, mais la règle des 2048/4096 caractères maximum par ligne de commande s'applique ;
• par souci de compatibilité avec les systèmes Windows XP et antérieurs, il est préférable de ne pas utiliser des paramètres avec un index supérieur à 9, qui restent cependant accessibles via la commande shift (voir section IV.E.2La commande shift).

IV-E-1. Les modificateurs de paramètres de commande▲

Les paramètres de commande supportent plusieurs modificateurs permettant de les parser, en voici la liste exhaustive :

Modificateur	Description
%~1	renvoie %1 en supprimant les guillemets (") de début et de fin.
%~f1	renvoie le chemin d'accès vérifié du fichier désigné par %1, si le fichier n'est pas trouvé, alors ce modificateur s'expanse en une chaîne vide.
%~d1	renvoie la lettre de lecteur du fichier désigné par %1.
%~p1	renvoie le chemin d'accès du fichier désigné par %1.
%~n1	renvoie le nom du fichier désigné par %1.
%~x1	renvoie l'extension du fichier désigné par %1.
%~s1	renvoie le chemin d'accès, sous forme de noms courts, du fichier désigné par %1.
%~a1	renvoie les attributs du fichier désigné par %1.
%~t1	renvoie la date et l'heure de création du fichier désigné par %1.
%~z1	renvoie la taille du fichier désigné par %1.
%~$<variable>:1	<variable> est parcourue à la recherche d'occurrence de %1, si aucune occurrence de %1 n'est trouvée ou que <variable> n'est pas défini dans le contexte en cours, alors ce modificateur s'expanse en une chaîne vide. Si <variable> est composé de plusieurs chaînes, elles doivent être séparées par des points-virgules (;) afin que le modificateur puisse les distinguer correctement.

Tableau 10 : Les modificateurs de paramètres de commande.

Les modificateurs de paramètres de commande fonctionnent pour tous les index. Ils peuvent être utilisés conjointement pour obtenir plusieurs informations en même temps, comme le montre le script 43 :

Script 43

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

@echo off
rem Ce script doit être lancé depuis « cmd.exe » pour obtenir le bon résultat.
cls
call :MonLabel %cmdcmdline%
pause
goto :eof
:MonLabel
echo %~dpnx$ComSpec:1
goto :eof

IV-E-2. La commande shift▲

La commande shift permet de décaler l'index de tous les paramètres de -1, afin d'accéder aux index supérieurs à neuf, ou de créer un mécanisme de gestion des paramètres (voir la mise en application de ce chapitreMise en application des contextes). Si les extensions de commande sont activées, la commande shift prend le paramètre /n, où n est le numéro d'index à partir duquel commence le décalage des paramètres, tous les index égaux ou supérieurs à n seront décalés de -1.

shift [/n]

Dans le script 44, le commande shift /1 permet d'accéder au deuxième paramètre via l'index 1 :.

Script 44

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

@echo off
cls
call :MonLabel "rien" %cmdcmdline%
pause
exit /b
:MonLabel
shift /1
echo %~dpnx$ComSpec:1
goto :eof

La sortie d'un contexte ou d'un processus peut s'effectuer via les commandes exit et goto :eof. Dans le cas de goto :eof, si tous les contextes ont correctement été dépilés, alors la dernière adresse dépilée est :

• soit l'adresse de sortie du processus dans le cas d'un script appelé en cliquant dessus ;
• soit l'adresse de retour à l'interpréteur si le script a été lancé depuis celui-ci.

La commande exit, elle, permet de sortir du processus hôte, quel que soit le nombre de contextes empilés. Si la commande exit est utilisée avec le paramètre /b, alors la sortie s'effectuera à l'adresse de sortie du contexte et non à l'adresse de sortie du processus hôte. L'intérêt de la commande exit est qu'un code numérique de sortie peut être spécifié, contrairement à goto :eof. La syntaxe de la commande exit est la suivante, où <CodeSortie> est le code de sortie.

exit [/b] [<CodeSortie>]

Dans le script 45, la sortie de la fonction :LabelDeux s'effectue à l'aide d'un goto:eof et la sortie de la fonction :LabelQuatre s'effectue à l'aide d'exit /b ; dans les deux cas, le retour vers la procédure appelante s'opère correctement, car c'est la bonne adresse de retour qui est dépilée. Dans la fonction :LabelSix du script 45, la commande exit /b provoque la fin du script, car la fonction :LabelSix a été appelée avec la commande goto :LabelSix qui n'a rien empilé. Comme tous les contextes précédents ont été dépilés correctement, seule la dernière adresse de retour subsiste. Cette adresse correspond à l'adresse de retour à l'interpréteur si le script a été appelé depuis celui-ci ou à l'adresse de sortie du processus, si le script a été appelé par un double-clic.

@echo off
cls
set /a "CounterGoto=0"
set /a "CounterExit=0"
set /a "CounterCounter=0"
:LabelUn
call :LabelDeux
set /a "CounterGoto+=1"
echo CounterGoto: %CounterGoto% sur affichage Goto 1.
if %CounterGoto% EQU 6 goto :LabelTrois
goto :LabelUn
:LabelDeux
set /a "CounterGoto+=1"
echo CounterGoto: %CounterGoto% sur affichage Goto 2.
goto :eof

:LabelTrois
call :LabelQuatre
set /a "CounterExit+=1"
echo CounterExit: %CounterExit% sur affichage Exit 1.
if %CounterExit% EQU 6 goto :LabelCinq
goto :LabelTrois
:LabelQuatre
set /a "CounterExit+=1"
echo CounterExit: %CounterExit% sur affichage Exit 2.
exit /b

:LabelCinq
goto :LabelSix
set /a "CounterCounter+=1"
echo CounterCounter: %CounterCounter% sur affichage Counter 1.
if %CounterCounter% EQU 6 exit /b
goto :LabelCinq
:LabelSix
set /a "CounterCounter+=1"
echo CounterCounter: %CounterCounter% sur affichage Counter 2.
exit /b

Comme expliqué précédemment, un code de sortie peut être spécifié pour une fonction ou pour un script. Cela se fait via la commande exit [/b] <Code> où <Code> est un code de sortie numérique. Les codes de sortie sont régis par les mêmes règles que les nombres entiers et sont codés sur 32 bits en arithmétique signée. Ce code de sortie est fixé dans la variable ErrorLevel afin de pouvoir être utilisé par la suite. Exemple avec le script 46 :

@echo off

echo %ErrorLevel%
call :UnLabel
echo %ErrorLevel%
pause
exit /b
:UnLabel
exit /b 1

L'appel d'un script depuis l'interpréteur ou en cliquant dessus génère toujours un contexte complet. Cependant l'appel d'un script en ligne de commande depuis un autre script génère un contexte ne possédant pas d'adresse de retour. Exemple avec le script 47 :

@echo off

if exist test.bat del /q test.bat
rem "^>^>test.bat" est une redirection et sera expliquée au chapitre VII.
call :WriteTestBat >>test.bat

test.bat

echo Retour à %~nx0.
del /q test.bat
pause
exit /b

:WriteTestBat
echo @echo off
echo echo Une phrase affichée dans test.bat
echo pause
goto :eof

Lorsqu'on exécute le script 47, celui-ci crée un second script, test.bat. L'appel en ligne de commande Test.bat affiche alors Une phrase affichée depuis test.bat et met en pause l'exécution. Lorsqu'on appuie sur une touche, cela provoque la fin des deux scripts. En effet, quand l'interpréteur arrive à la fin d'un script et que celui-ci ne se termine pas par goto :eof ou exit [/b], il effectue de lui-même le saut à l'adresse de retour. Sauf que l'appel de test.bat n'a pas empilé d'adresse de retour et de ce fait, l'adresse qui est dépilée est celle du premier script. Pour parer à ce problème, il faut s'assurer que l'adresse de retour soit effectivement empilée en utilisant la commande call. Ainsi, en modifiant le script 47 de la manière suivante (script 48), l'appel et la sortie s'effectuent sans erreur.

@echo off

if exist test.bat del /q test.bat
rem "^>^>test.bat" est une redirection et sera expliquée au chapitre VII.
call :WriteTestBat >>test.bat

call test.bat

echo Retour à %~nx0.
del /q test.bat
pause
exit /b

:WriteTestBat
echo @echo off
echo echo Une phrase affichée dans test.bat
echo pause
goto :eof

La commande start permet de lancer un script ou une commande dans un nouveau processus, permettant ainsi d'exécuter des commandes dans un environnement modifié. Ainsi, toute variable créée ou modifiée dans le script appelant est passée à ce nouveau processus.

start ["<caption>"] [/d <path>] [/i] [/min] [/max] [/separate|/shared]
      [/low|/normal|/high|/realtime|/abovenormal|/belownormal] [/affinity <hexa>]
      [/wait] [/b] [<commande>] [<paramètres>]

Tableau 11 : Les paramètres de la commande start.

Le script 49 appelle une nouvelle instance de lui-même avec le paramètre foo après avoir défini la variable X, la seconde instance affiche bien la valeur de X alors qu'elle n'a pas déclaré X. Notez bien qu'il s'agit d'un nouveau processus, il est donc possible de le quitter avec la commande exit sans aucun paramètre.

@echo off
if "%1"=="foo" goto SecondInstance
set "X=bar"
start %~nx0 foo
pause
exit /b
:SecondInstance
echo %X%
pause
exit

Première instance :

Seconde instance :

Si l'on modifie le script 49 en ajoutant le paramètre /i dans la commande start (script 50), alors le nouveau processus sera créé en héritant du contexte original du processus hôte dans lequel la variable X n'a pas été déclarée.

@echo off
if "%1"=="foo" goto SecondInstance
set "X=bar"
start /i %~nx0 foo
pause
exit /b
:SecondInstance
echo %X%
pause
exit

Première instance :

Seconde instance :

Une autre application intéressante de la commande start est l'exécution parallèle à l'aide du paramètre /b comme dans le script 51.

N.B. : la commande timeout n'est pas fournie en standard sur tous les systèmes Windows. Si vous ne l'avez pas, veuillez supprimer la commande timeout du script, dé-commenter les commandes echo, ping et supprimer le caractère d'échappement dans la commande ping.

@echo off
if "%1"=="foo" goto SecondInstance
start /b %~nx0 foo
::echo Attendez quelques instant ...
::ping -n 15 localhost^>nul
timeout /t 10 /nobreak
pause
exit /b
:SecondInstance
echo %1
exit

Cette commande permet de modifier partiellement les contextes en créant un contexte local. Les variables et leurs valeurs, dans ce nouveau contexte local, sont soumises aux règles inhérentes à la création de contexte. L'avantage de cette commande est que l'on peut créer un contexte sans passer par un appel. Ce contexte local ne possède pas d'adresse de retour ni de paramètres d'appel. Seules les variables, et éventuellement les extensions de commande, sont affectées. Ainsi, toutes les variables créées ou modifiées dans ce contexte local y sont propres. Cette modification prend fin lorsque l'exécution rencontre la commande endlocal. La commande setlocal prend aussi les paramètres :

• enabledelayedexpansion qui active l'expansion retardée ;
• disabledelayedexpansion qui désactive l'expansion retardée ;
• enableextensions qui active les extensions de commande ;
• disableextensions qui désactive les extensions de commande.

setlocal [enableextensions|disableextensions] [enabledelayedexpansion|disabledelayedexpansion]

Cette commande termine le contexte local généré par la commande setlocal correspondante. Plusieurs contextes locaux pouvant être empilés les uns au-dessus des autres, toutes les modifications apportées dans le contexte local qui se termine sont perdues, y compris les modifications apportées par les paramètres de la commande setlocal. La commande endlocal ne prend aucun paramètre. Exemple pour setlocal et endlocal avec le script 52 :

@echo off
setlocal
set "X=foo"
echo %X%
endlocal
echo %X%
pause
exit

@echo off

set "ScriptName=%~nx0"
set "NegNum=false"
set /a "PrefixEnable=0"
set /a "UpperPrefix=0"

setlocal

:ParseArgs
if "%~1"=="" goto Init
if /i "%~1"=="/?" goto Help
if /i "%~1"=="-?" goto Help
if /i "%~1"=="/h" goto Help
if /i "%~1"=="-h" goto Help
if /i "%~1"=="/help" goto Help
if /i "%~1"=="-help" goto Help
if /i "%~1"=="/hex" (
    set "SInt32=%~2"
    set /a "SInt32"
    if errorlevel 1 (
        shift /1
        goto BadSyntax
    )
    shift /1
    shift /1
    goto ParseArgs
)
if /i "%~1"=="/p" (
    set /a "PrefixEnable=1"
    if %~1 EQU /P set /a "UpperPrefix=1"
    shift /1
    goto ParseArgs
)
:BadSyntax
echo.
rem La commande 'net helpmsg' affiche un message prédéfini dans
rem la langue d'installation du système d'exploitation
net helpmsg 87
echo [ %~1 ]
echo.
if not "%~0"==":BadSyntax" endlocal
exit /b 1

:Init
if defined SInt32 goto Exec
:UnknowError
call :BadSyntax /hex
call :Help
endlocal
exit /b 2

:Exec
rem Si le nombre est négatif, on utilise son complément à un et on le définit comme négatif.
if %SInt32% LSS 0 (
    set "NegNum=true"
    set /a "SInt32=~SInt32"
)
rem On utilise un algorithme de divisions successives par 16 pour obtenir des 
rem nombres en base 16, chaque nombre obtenu forme un quartet.
set /a "Nibble0= SInt32 %% 16","HighOrder0= SInt32 / 16"
set /a "Nibble1=HighOrder0 %% 16","HighOrder1=HighOrder0 / 16"
set /a "Nibble2=HighOrder1 %% 16","HighOrder2=HighOrder1 / 16"
set /a "Nibble3=HighOrder2 %% 16","HighOrder3=HighOrder2 / 16"
set /a "Nibble4=HighOrder3 %% 16","HighOrder4=HighOrder3 / 16"
set /a "Nibble5=HighOrder4 %% 16","HighOrder5=HighOrder4 / 16"
set /a "Nibble6=HighOrder5 %% 16"
set /a "Nibble7=HighOrder5 / 16"
rem Si c'est un nombre négatif^ ("%NegNum%"=="true"^),
rem     on retranche chaque valeur à 15 pour récupérer le nombre original.
if "%NegNum%"=="true" (
    set /a "Nibble0=15 – Nibble0"
    set /a "Nibble1=15 – Nibble1"
    set /a "Nibble2=15 – Nibble2"
    set /a "Nibble3=15 – Nibble3"
    set /a "Nibble4=15 – Nibble4"
    set /a "Nibble5=15 – Nibble5"
    set /a "Nibble6=15 – Nibble6"
    set /a "Nibble7=15 – Nibble7"
)
rem On transforme chaque quartet en notation hexadécimale.
if %Nibble0% GTR 9 (
    if %Nibble0% EQU 10 set "Nibble0=A"
    if %Nibble0% EQU 11 set "Nibble0=B"
    if %Nibble0% EQU 12 set "Nibble0=C"
    if %Nibble0% EQU 13 set "Nibble0=D"
    if %Nibble0% EQU 14 set "Nibble0=E"
    if %Nibble0% EQU 15 set "Nibble0=F"
)
if %Nibble1% GTR 9 (
    if %Nibble1% EQU 10 set "Nibble1=A"
    if %Nibble1% EQU 11 set "Nibble1=B"
    if %Nibble1% EQU 12 set "Nibble1=C"
    if %Nibble1% EQU 13 set "Nibble1=D"
    if %Nibble1% EQU 14 set "Nibble1=E"
    if %Nibble1% EQU 15 set "Nibble1=F"
)
if %Nibble2% GTR 9 (
    if %Nibble2% EQU 10 set "Nibble2=A"
    if %Nibble2% EQU 11 set "Nibble2=B"
    if %Nibble2% EQU 12 set "Nibble2=C"
    if %Nibble2% EQU 13 set "Nibble2=D"
    if %Nibble2% EQU 14 set "Nibble2=E"
    if %Nibble2% EQU 15 set "Nibble2=F"
)
if %Nibble3% GTR 9 (
    if %Nibble3% EQU 10 set "Nibble3=A"
    if %Nibble3% EQU 11 set "Nibble3=B"
    if %Nibble3% EQU 12 set "Nibble3=C"
    if %Nibble3% EQU 13 set "Nibble3=D"
    if %Nibble3% EQU 14 set "Nibble3=E"
    if %Nibble3% EQU 15 set "Nibble3=F"
)
if %Nibble4% GTR 9 (
    if %Nibble4% EQU 10 set "Nibble4=A"
    if %Nibble4% EQU 11 set "Nibble4=B"
    if %Nibble4% EQU 12 set "Nibble4=C"
    if %Nibble4% EQU 13 set "Nibble4=D"
    if %Nibble4% EQU 14 set "Nibble4=E"
    if %Nibble4% EQU 15 set "Nibble4=F"
)
if %Nibble5% GTR 9 (
    if %Nibble5% EQU 10 set "Nibble5=A"
    if %Nibble5% EQU 11 set "Nibble5=B"
    if %Nibble5% EQU 12 set "Nibble5=C"
    if %Nibble5% EQU 13 set "Nibble5=D"
    if %Nibble5% EQU 14 set "Nibble5=E"
    if %Nibble5% EQU 15 set "Nibble5=F"
)
if %Nibble6% GTR 9 (
    if %Nibble6% EQU 10 set "Nibble6=A"
    if %Nibble6% EQU 11 set "Nibble6=B"
    if %Nibble6% EQU 12 set "Nibble6=C"
    if %Nibble6% EQU 13 set "Nibble6=D"
    if %Nibble6% EQU 14 set "Nibble6=E"
    if %Nibble6% EQU 15 set "Nibble6=F"
)
if %Nibble7% GTR 9 (
    if %Nibble7% EQU 10 set "Nibble7=A"
    if %Nibble7% EQU 11 set "Nibble7=B"
    if %Nibble7% EQU 12 set "Nibble7=C"
    if %Nibble7% EQU 13 set "Nibble7=D"
    if %Nibble7% EQU 14 set "Nibble7=E"
    if %Nibble7% EQU 15 set "Nibble7=F"
)
rem Les quartets 0 à 3 forment le Least Significant Word.
set "LSW=%Nibble3%%Nibble2%%Nibble1%%Nibble0%"
rem Les quartets 4 à 7 forment le Most Significant Word.
set "MSW=%Nibble7%%Nibble6%%Nibble5%%Nibble4%"
rem On affiche le résultat.
if %PrefixEnable% EQU 1 (
    if %UpperPrefix% EQU 1 (
        echo 0X%MSW%%LSW%
    ) else (
        echo 0x%MSW%%LSW%
    )
) else (
    echo %MSW%%LSW%
)
goto End


:Help
echo.
echo %ScriptName% [/p^|/P] /hex ^<number^>
echo %ScriptName% {/?^|-?^|/h^|-h^|/help^|-help}
echo.
echo     /hex    Définit le ^<number^> qui doit être exprimé en hexadécimal.
echo     /p      Définit que le préfixe doit être affiché en minuscules.
echo     /P      Définit que le préfixe doit être affiché en majuscules.
echo.    /?      Affiche cette aide.
echo.

:End
if not "%~0"==":Help" endlocal
exit /b 0

Le script 53 doit être appelé avec des paramètres afin de fonctionner. Ainsi, quand on appelle ce script avec l'un des paramètres suivants : /?, -?, /h, -h, /help ou -help, l'aide est affichée. Si on appelle le script avec les paramètres /hex n (ou n est le nombre voulu), il affiche la représentation hexadécimale de ce nombre. Notez également l'utilisation du paramètre %~nx0 pour définir le nom du script, ici, la fonction :Help est appelée via un call au label :UnknowError (la commande exit /b 0 du label :End fournit le saut à l'adresse de retour), %0 aurait été, alors, la chaîne :Help.

Un script devrait toujours avoir un squelette similaire à celui du script 53. Pour en connaître la raison, examinons ses différentes parties :

• le script commence par @echo off pour rendre plus net l'affichage, puis les variables de configuration sont initialisées avec leurs valeurs par défaut, ce qui permet au script de fonctionner même si ces valeurs ne sont pas modifiées par la suite. La commande setlocal est utilisée pour les cas d'erreur, par exemple si le nombre donné via l'argument /hex dépasse 32 bits. La variable ErrorLevel n'est pas remise à jour suite à une erreur dans une commande interne, ainsi, si l'on appelle le script depuis l'interpréteur avec en paramètre un nombre invalide, tous les appels du script qui suivront, même avec un nombre valide, se termineront sur une erreur. Pensez à utiliser la commande endlocal avant chaque point de sortie du script ;
• vient ensuite le label :ParseArgs dans lequel les paramètres d'appel vont être vérifiés, chaque fois qu'un paramètre est trouvé, sa valeur est définie dans la variable correspondante puis les paramètres d'appel sont décalés avant le retour au label :ParseArgs. Si le paramètre fourni dans la commande d'appel n'est pas trouvé, l'exécution continue jusqu'au label :BadSyntax qui affiche un message d'erreur et quitte le script avec le code d'erreur 1 ;
• une fois tous les paramètres lus, l'exécution est redirigée vers le label :Init, qui a pour fonction de vérifier que les données de travail ont bien été fournies dans la commande d'appel. En effet, ce script appelé sans paramètre s'exécute au moins jusqu'au label :Init. Dans ce label, il convient, en général, de modifier les variables de configuration en fonction des valeurs fournies dans la commande d'appel. Si les données fournies ne sont pas valides, l'exécution continue au label :UnknowError qui, dans notre cas, va afficher où se trouve l'erreur ainsi que l'aide ;
• si les données de travail sont valides, l'exécution est redirigée vers le label :Exec qui va exécuter le travail requis puis afficher le résultat avant d'être redirigée vers le label :End ;
• le label  :Help fournit une aide en ligne de commande (c'est toujours utile). Celui-ci se trouvant juste devant le label :End, il peut à la fois être utilisé comme une fonction ou comme une portion de code classique. Notez l'échappement de la commande echo avec le point à la ligne echo. /? Affiche cette aide. sans quoi l'interpréteur aurait affiché l'aide de la commande echo.

Les boucles pour chemin d'accès permettent d'effectuer des recherches de dossiers ou de fichiers. La recherche de dossier s'effectue avec le paramètre /d tandis que la recherche de fichier s'effectue avec le paramètre /r. Leurs syntaxes sont les suivantes :

for /d %<paramètre> in (["][<chemin_d'accès>\]{*|<motif>}["]) do <cmd>

for /r ["][<chemin_d'accès>\]["] %<paramètre> in (["]{*|<motif>|.}["]) do <cmd>

Tableau 12 : Paramètres des boucles pour chemins d'accès

Exemple avec le script 55.

@echo off
mkdir "%cd%\foo"
mkdir "%cd%\foo\bar"
mkdir "%cd%\foo\beer"
call :WriteFile >>"%cd%\foo\bar\bar.bat"
call :WriteFile >>"%cd%\foo\bar\bar.txt"
call :WriteFile >>"%cd%\foo\beer\beer.bat"
call :WriteFile >>"%cd%\foo\beer\beer.txt"
echo Liste des dossiers:
for /d %%A in ("%cd%\foo\*") do echo %%A
echo.
echo Liste des scripts batch:
for /r "%cd%\foo" %%B in ("*.bat") do echo %%~B
echo.
pause
rd /s /q "%cd%\foo"
exit /b
:WriteFile
echo @echo off
echo pause
goto :eof

Le paramètre /l permet d'effectuer une boucle avec comme paramètre un compteur numérique, ainsi l'<ensemble> prend la forme : <origine>, <pas_incrémentiel>, <fin>. La boucle commencera le traitement avec comme paramètre un nombre ayant pour valeur <origine> puis, après chaque itération de la boucle, sera ajouté <pas_incrémentiel> tant que <fin> n'est pas atteinte. Lorsque <fin> est atteinte la boucle exécute sa dernière itération. <origine>, <pas_incrémentiel> et <fin> peuvent être séparés, soit par des espaces, soit par des virgules.

for /l %<paramètre> in (<origine> <pas_incrémentiel> <fin>) do <cmd>

for /l %<paramètre> in (<origine>,<pas_incrémentiel>,<fin>) do <cmd>

@echo off
for /l %%A in (1 1 20) do echo Le paramètre A a pour valeur %%A.
pause
exit /b

Comme les nombres dans l'interpréteur ont une définition de 32 bits et utilisent tous l'arithmétique signée, les limites de la boucle for /l sont celles des nombres entiers signés. Ainsi l'<origine>, le <pas_incrémentiel> et la <fin> peuvent tous être compris entre -2147483648 et +2147483647. Le script 57 fonctionne donc parfaitement, mais, comme vous pouvez l'imaginer, son exécution est très longue.

@echo off
for /l %%A in (2147483647 -1 -2147483648) do echo Le paramètre A a pour valeur %%A.
pause
exit /b

Le paramètre /f indique à la boucle for que le traitement peut s'opérer sur des chaînes de caractères, des fichiers ou des commandes, mais à des fins de recherche. Ce paramètre a la particularité de prendre des options supplémentaires permettant de parser l'<ensemble>.

for /f ["<options>"] %<paramètre> in (<ensemble>) do <commande>

Les options prises en charge par for /f sont les suivantes :

Tableau 13 : Paramètres de la boucle « for /f »

@echo off
setlocal enabledelayedexpansion
:: La chaîne « 1^>^>"%cd%\test.txt" » est une redirection et sera expliquée au chapitre VII.
1>"%cd%\test.txt" echo Ligne 1
1>>"%cd%\test.txt" echo Ligne 2
1>>"%cd%\test.txt" echo Ligne 3
1>>"%cd%\test.txt" echo Ligne 4
1>>"%cd%\test.txt" echo Ligne 5
1>>"%cd%\test.txt" echo ;un petit commentaire

for /f "eol=; delims=" %%A in ('type test.txt') do echo %%A
echo.
for /f "eol=; skip=4 delims=" %%A in ('type test.txt') do echo %%A
del /Q test.txt
echo.
for /f "tokens=1-5*" %%A in ("1 2 3 4 5 6 7 8 9") do (
    echo %%A
    echo %%B
    echo %%C
    echo %%D
    echo %%E
    echo %%F
)
echo.
for /f "usebackq delims=" %%A in (`type "%cd%\%~nx0"`) do (
    echo %%A
)
echo.
pause
exit /b

Plusieurs points sont à noter dans le script 58 :

• le premier est l'utilisation de l'option eol=; qui supprime la chaîne ;un petit commentaire des résultats obtenus des deux premières boucles ;
• le second est l'utilisation de l'option skip=4 qui supprime les quatre premières lignes du résultat de la seconde boucle ;
• le troisième est l'absence de l'option delims dans la troisième boucle, en effet l'espace et la tabulation sont les délimiteurs par défaut ;
• le dernier est l'utilisation de l'option usebackq et des caractères ` (guillemet simple inversé) qui permet l'utilisation de guillemets doubles pour le chemin d'accès.

La boucle for possède un certain nombre de caractères significatifs tel que " ' ` ,. Si les guillemets et autres apostrophes peuvent être gérés avec un bon jeu d'options dans la boucle, il n'en est pas de même avec la virgule. Ainsi, considérons le script suivant qui devrait permettre de trouver les volumes qui sont des lecteurs de CD/DVD.

@echo off
for /f "usebackq skip=1 tokens=1,2" %%A in (`wmic volume where "DriveType=\"5\"" get DriveLetter,Capacity`) do (
    echo %%A %%B
)
pause
exit /b 0

Ce script se finit sur une erreur, car les guillemets simples inversés modifient la façon dont la chaîne de l'ensemble est prise en compte et de ce fait, la virgule provoque l'erreur. Il faut donc échapper la virgule avec le caractère ^ pour qu'elle soit incluse dans la chaîne sans être traitée par la boucle comme le montre le script 60.

@echo off
for /f "usebackq skip=1 tokens=1,2" %%A in (`wmic volume where "DriveType=\"5\"" get DriveLetter^,Capacity`) do (
    echo %%A %%B
)
pause
exit /b 0

L'<ensemble>, qu'il soit une commande ou autre chose, est toujours traité dans un premier temps comme une chaîne. Ainsi les opérateurs de redirection (voir chapitre VIILa gestion des flux) doivent aussi être échappés.

@echo off
1>test.txt echo foo
1>>test.txt echo bar
1>>test.txt echo foobar
for /f "usebackq delims=" %%A in (`type test.txt ^| find "foo"`) do (
    echo %%A
)
del /q test.txt
pause
exit /b 0

@echo off

set "ScriptName=%~nx0"
set "NegNum=false"
set /a "PrefixEnable=0"
set /a "UpperPrefix=0"

setlocal

:ParseArgs
if "%~1"=="" goto Init
if /i "%~1"=="/?" goto Help
if /i "%~1"=="-?" goto Help
if /i "%~1"=="/h" goto Help
if /i "%~1"=="-h" goto Help
if /i "%~1"=="/help" goto Help
if /i "%~1"=="-help" goto Help
if /i "%~1"=="/hex" (
    set "Nibble7=%~2"
    set /a "Nibble7"
    if errorlevel 1 (
        shift /1
        goto BadSyntax
    )
    shift /1
    shift /1
    goto ParseArgs
)
if /i "%~1"=="/p" (
    set /a "PrefixEnable=1"
    if %~1 EQU /P set /a "UpperPrefix=1"
    shift /1
    goto ParseArgs
)
:BadSyntax
echo.
for /f "delims=" %%A in ('net helpmsg 87') do echo [ %~1 ] %%A
echo.
if not "%~0"==":BadSyntax" endlocal
exit /b 1

:Init
if defined Nibble7 goto Exec
:UnknowError
call :BadSyntax /hex
call :Help
endlocal
exit /b 2

:Exec
rem Si le nombre est négatif, on utilise son complément à un et on le définit comme négatif.
if %Nibble7% LSS 0 (
    set /a "Nibble7=~Nibble7"
    set "NegNum=true"
)
rem Divisions successives par 16
for /l %%A in (0 1 6) do set /a "Nibble%%A=Nibble7 %% 16", "Nibble7/=16"
rem Si le nombre est négatif, la valeur de chaque chiffre ^(Nibble^) est retranchée à 15.
if /i "%NegNum%"=="true" for /l %%A in (0 1 7) do set /a "Nibble%%A=15 - Nibble%%A"
rem Chaque chiffre ayant une valeur supérieure à 9 est transformé en sa représentation hexadécimale.
if %Nibble0% GTR 9 (
    if %Nibble0% EQU 10 set "Nibble0=A"
    if %Nibble0% EQU 11 set "Nibble0=B"
    if %Nibble0% EQU 12 set "Nibble0=C"
    if %Nibble0% EQU 13 set "Nibble0=D"
    if %Nibble0% EQU 14 set "Nibble0=E"
    if %Nibble0% EQU 15 set "Nibble0=F"
)
if %Nibble1% GTR 9 (
    if %Nibble1% EQU 10 set "Nibble1=A"
    if %Nibble1% EQU 11 set "Nibble1=B"
    if %Nibble1% EQU 12 set "Nibble1=C"
    if %Nibble1% EQU 13 set "Nibble1=D"
    if %Nibble1% EQU 14 set "Nibble1=E"
    if %Nibble1% EQU 15 set "Nibble1=F"
)
if %Nibble2% GTR 9 (
    if %Nibble2% EQU 10 set "Nibble2=A"
    if %Nibble2% EQU 11 set "Nibble2=B"
    if %Nibble2% EQU 12 set "Nibble2=C"
    if %Nibble2% EQU 13 set "Nibble2=D"
    if %Nibble2% EQU 14 set "Nibble2=E"
    if %Nibble2% EQU 15 set "Nibble2=F"
)
if %Nibble3% GTR 9 (
    if %Nibble3% EQU 10 set "Nibble3=A"
    if %Nibble3% EQU 11 set "Nibble3=B"
    if %Nibble3% EQU 12 set "Nibble3=C"
    if %Nibble3% EQU 13 set "Nibble3=D"
    if %Nibble3% EQU 14 set "Nibble3=E"
    if %Nibble3% EQU 15 set "Nibble3=F"
)
if %Nibble4% GTR 9 (
    if %Nibble4% EQU 10 set "Nibble4=A"
    if %Nibble4% EQU 11 set "Nibble4=B"
    if %Nibble4% EQU 12 set "Nibble4=C"
    if %Nibble4% EQU 13 set "Nibble4=D"
    if %Nibble4% EQU 14 set "Nibble4=E"
    if %Nibble4% EQU 15 set "Nibble4=F"
)
if %Nibble5% GTR 9 (
    if %Nibble5% EQU 10 set "Nibble5=A"
    if %Nibble5% EQU 11 set "Nibble5=B"
    if %Nibble5% EQU 12 set "Nibble5=C"
    if %Nibble5% EQU 13 set "Nibble5=D"
    if %Nibble5% EQU 14 set "Nibble5=E"
    if %Nibble5% EQU 15 set "Nibble5=F"
)
if %Nibble6% GTR 9 (
    if %Nibble6% EQU 10 set "Nibble6=A"
    if %Nibble6% EQU 11 set "Nibble6=B"
    if %Nibble6% EQU 12 set "Nibble6=C"
    if %Nibble6% EQU 13 set "Nibble6=D"
    if %Nibble6% EQU 14 set "Nibble6=E"
    if %Nibble6% EQU 15 set "Nibble6=F"
)
if %Nibble7% GTR 9 (
    if %Nibble7% EQU 10 set "Nibble7=A"
    if %Nibble7% EQU 11 set "Nibble7=B"
    if %Nibble7% EQU 12 set "Nibble7=C"
    if %Nibble7% EQU 13 set "Nibble7=D"
    if %Nibble7% EQU 14 set "Nibble7=E"
    if %Nibble7% EQU 15 set "Nibble7=F"
)
if %PrefixEnable% EQU 1 (
    if %UpperPrefix% EQU 1 (
        echo 0X%Nibble7%%Nibble6%%Nibble5%%Nibble4%%Nibble3%%Nibble2%%Nibble1%%Nibble0%
    ) else (
        echo 0x%Nibble7%%Nibble6%%Nibble5%%Nibble4%%Nibble3%%Nibble2%%Nibble1%%Nibble0%
    )
) else (
    echo %Nibble7%%Nibble6%%Nibble5%%Nibble4%%Nibble3%%Nibble2%%Nibble1%%Nibble0%
)
goto End


:Help
echo.
echo %ScriptName% [/p^|/P] /hex ^<number^>
echo %ScriptName% {/?^|-?^|/h^|-h^|/help^|-help}
echo.
echo     /hex    Définit le ^<number^> qui doit être exprimé en hexadécimal.
echo     /p      Définit que le préfixe doit être affiché en minuscules.
echo     /P      Définit que le préfixe doit être affiché en majuscules.
echo.    /?      Affiche cette aide.
echo.

:End
if not "%~0"==":Help" endlocal
exit /b 0

Comme vous pouvez le constater, le script a vu sa taille réduite, les plus malins auront sûrement compris que la transformation en représentation hexadécimale peut se faire via une boucle, mais nous verrons cela au prochain chapitre. Les boucles auront, quand même, permis de condenser les opérations répétitives. La variable SInt32 a été remplacée par Nibble7 afin de traiter les divisions successives via une boucle for sans avoir à rajouter une ligne pour traiter le dernier quartet. Le script 62 peut facilement être utilisé dans un autre script grâce à la boucle for /f, comme avec le script 63 (remplacer <scriptname> par le nom donné au script 62).

@echo off
for /f "delims=" %%A in ('<scriptname> /p /hex -1') do set "Result=%%A"
echo Résultat:    %Result%
echo.
pause 
exit /b

Dans le script 63, l'option "delims=" est utilisée pour récupérer la sortie de la commande echo 0x%Nibble7%%Nibble6%… du script 62, car toutes les commandes echo se finissent par un retour à la ligne, le délimiteur doit donc être un retour à la ligne. Si plusieurs lignes doivent être récupérées en sortie d'un script, il est possible d'ajouter un compteur de ligne, comme dans le script 64.

@echo off
setlocal enabledelayedexpansion

rem Dans ce script, l'expansion retardée des variables est utilisée, elle sera cependant abordée au chapitre VI.

1>"%cd%\test.bat" echo @echo off
1>>"%cd%\test.bat" echo echo Ligne 1
1>>"%cd%\test.bat" echo echo Ligne 2
1>>"%cd%\test.bat" echo echo Ligne 3
set /a "Counter=1"
for /f "delims=" %%A in ('test.bat') do (
    set "Result!Counter!=%%A"
    set /a "Counter+=1"
)
del /Q test.bat
for /l %%B in (1 1 !Counter!) do (
    if not "!Result%%B!"=="" echo Résultat %%B:    !Result%%B!
)
pause 
exit /b

Dans une boucle for, la dernière exécution du corps de for est « fixée » dans le contexte d'appel de la boucle. Ainsi, dans le script 65, seule la dernière valeur est ajoutée à la variable Var.

@echo off
for %%A in (a,z) do (
    set "Var=%Var% %%A"
)
echo %Var%
pause
exit /b 0

Si l'on modifie le script 65 en ajoutant l'expansion retardée, l'opération s'effectue sans erreur (script 66).

@echo off
setlocal enabledelayedexpansion
for %%A in (a,z) do (
    set "Var=!Var! %%A"
)
echo %Var%
pause
exit /b 0

Une autre application intéressante de l'expansion retardée des variables est de pouvoir créer des noms de variables en fonction de paramètres tel qu'un index numérique ou une chaîne de caractères. Des noms de variables ainsi construits permettent de créer une abstraction de tableau qu'il sera par la suite possible de parcourir rapidement avec une boucle for. Du fait de la syntaxe des paramètres de la boucle for, si l'on venait à placer le paramètre variable (l'index numérique ou la chaîne de caractères) entre des caractères %, le parsage de la ligne de commande générerait forcément une erreur. Par exemple avec un paramètre %%A ayant une valeur de 1, si l'on veut obtenir la variable ayant le nom Index1, il faudrait l'écrire %Index%%A%,mais l'interpréteur comprendrait qu'il y a une variable %Index% et une variable %A%. Si, avec le même exemple, on utilise l'expansion retardée, la variable s'écrirait !Index%%A!, ainsi plus d'erreur de parsage possible.

@echo off
setlocal enabledelayedexpansion
1>>test.txt echo Ligne1
1>>test.txt echo Ligne2
1>>test.txt echo Ligne3
set /a "Counter=1"
for /f "delims=" %%A in ('type test.txt') do (
    set "Var!Counter!=%%A"
    set /a "Counter+=1"
)
del /Q test.txt
for /l %%B in (1 1 !Counter!) do if not "!Var%%B!"=="" echo !Var%%B!
pause
exit /b 0

Afin de rendre plus intuitive la lecture du script, il est possible de prendre des habitudes syntaxiques pour représenter de telles abstractions de tableau. Les caractères qui viennent tout de suite à l'esprit sont sûrement les caractères [ et ], ainsi une entrée de tableau pourrait s'écrire NomTableau[i] ou i est l'index numérique de position dans le tableau. Il suffit alors de parcourir le tableau indexé avec une boucle for /l ou de modifier directement la variable contenant la valeur à l'index voulu.

Les abstractions de tableaux littéraux peuvent être créées sur le même principe, ainsi une entrée de tableau serait accessible via l'identifiant NomTableau[NomEntrée]. Le parcours d'un tel tableau peut se faire avec une boucle for basique comme dans le script 68.

@echo off
setlocal enabledelayedexpansion

set "Array[One]=Entrée 1"
set "Array[Two]=Entrée 2"
set "Array[Three]=Entrée 3"

for %%A in (One,Two,Three) do echo !Array[%%A]!

pause
exit /b 0

Il faut savoir que l'interpréteur, par défaut, n'autorise que 8192 octets de données pour l'ensemble des valeurs des variables, mais autorise 64Ko de données pour l'ensemble des définitions de variables. Chaque définition de variable est composée du nom de la variable, du signe égal et de la valeur de la variable. Il reste donc 57344 octets (56Ko) pour placer les noms de variables et le signe égal, ce qui permet d'utiliser les noms de variables comme valeur significative et de récréer des structures de données ou des abstractions de tableaux.

L'expansion retardée permet une quantité d'actions sur les variables en modifiant l'évaluation syntaxique par l'interpréteur, la seule limite est la syntaxe. Par exemple, il est possible de vouloir connaître la taille d'une chaîne de caractères lorsqu'un script formate son affichage (ASCII Art, mini jeu en batch, etc.). Exemple avec le script 69.

@echo off
setlocal enabledelayedexpansion
set "X=xyz"
set "Y="
echo X:
call :strlen "%X%"
call :print "%X%" %ErrorLevel%
echo Y:
call :strlen "%Y%"
call :print "%Y%" %ErrorLevel%
echo.
pause
exit /b 0
:strlen
set "str=%~1"
for /l %%A in (0 1 4096) do (
    if "!str:~%%A,1!"=="" exit /b %%A
)
exit /b 0
:print
if %~2 GEQ 1 (
    echo La chaîne '%~1' a une taille de %~2 caractère^(s^).
) else (
    echo La chaîne est vide.
)
goto :eof

Vous reconnaissez notre script témoin, celui-ci a encore été modifié pour le rendre plus efficient. La transformation en notation hexadécimale reprend le concept de génération dynamique de nom de variable. Dans le cas des divisions successives, l'utilisation de l'expansion retardée n'est pas nécessaire, car la commande set le gère automatiquement. De même, lors de l'expansion des variables NibbleX dans la commande echo, celles-ci n'ayant jamais été déclarées dans le contexte courant et l'expansion retardée étant activée depuis le début du script, elles sont donc implicitement adressées dans le tas. Nibble7 a été déclarée dans le contexte du script, cependant c'est toujours la dernière qui est traitée dans les boucles, donc ses valeurs successives sont toujours fixées dans le contexte du script.

@echo off

set "ScriptName=%~nx0"
set "NegNum=false"
set /a "PrefixEnable=0"
set /a "UpperPrefix=0"

:: La commande setlocal utilisée avec des paramètres ne créée pas de contexte local, mais modifie simplement celui-ci, d'où la double utilisation de setlocal.
setlocal
setlocal enabledelayedexpansion

:ParseArgs
if "%~1"=="" goto Init
if /i "%~1"=="/?" goto Help
if /i "%~1"=="-?" goto Help
if /i "%~1"=="/h" goto Help
if /i "%~1"=="-h" goto Help
if /i "%~1"=="/help" goto Help
if /i "%~1"=="-help" goto Help
if /i "%~1"=="/hex" (
    set "Nibble7=%~2"
    set /a "Nibble7"
    if errorlevel 1 (
        shift /1
        goto BadSyntax
    )
    shift /1
    shift /1
    goto ParseArgs
)
if /i "%~1"=="/p" (
    set /a "PrefixEnable=1"
    if %~1 EQU /P set /a "UpperPrefix=1"
    shift /1
    goto ParseArgs
)
:BadSyntax
echo.
for /f "delims=" %%A in ('net helpmsg 87') do echo [ %~1 ] %%A
echo.
if not "%~0"==":BadSyntax" endlocal
exit /b 1

:Init
if defined Nibble7 goto Exec
:UnknowError
call :BadSyntax /hex
call :Help
endlocal
exit /b 2

:Exec
rem Si le nombre est négatif, on utilise son complément à un et on le définit comme négatif.
if %Nibble7% LSS 0 (
    set /a "Nibble7=~Nibble7"
    set "NegNum=true"
)
rem Divisions successives par 16
for /l %%A in (0 1 6) do set /a "Nibble%%A=Nibble7 %% 16", "Nibble7/=16"
rem Si le nombre est négatif, la valeur de chaque chiffre ^(Nibble^) est retranché à 15.
if /i "%NegNum%"=="true" for /l %%A in (0 1 7) do set /a "Nibble%%A=15 - Nibble%%A"
rem Chaque chiffre ayant une valeur supérieure à 9 est transformé en sa représentation hexadécimale.
for /l %%A in (0 1 7) do (
    if !Nibble%%A! EQU 10 set "Nibble%%A=A"
    if !Nibble%%A! EQU 11 set "Nibble%%A=B"
    if !Nibble%%A! EQU 12 set "Nibble%%A=C"
    if !Nibble%%A! EQU 13 set "Nibble%%A=D"
    if !Nibble%%A! EQU 14 set "Nibble%%A=E"
    if !Nibble%%A! EQU 15 set "Nibble%%A=F"
)
if %PrefixEnable% EQU 1 (
    if %UpperPrefix% EQU 1 (
        echo 0X%Nibble7%%Nibble6%%Nibble5%%Nibble4%%Nibble3%%Nibble2%%Nibble1%%Nibble0%
    ) else (
        echo 0x%Nibble7%%Nibble6%%Nibble5%%Nibble4%%Nibble3%%Nibble2%%Nibble1%%Nibble0%
    )
) else (
    echo %Nibble7%%Nibble6%%Nibble5%%Nibble4%%Nibble3%%Nibble2%%Nibble1%%Nibble0%
)
goto End


:Help
echo.
echo %ScriptName% [/p^|/P] /hex ^<number^>
echo %ScriptName% {/?^|-?^|/h^|-h^|/help^|-help}
echo.
echo     /hex    Définit le ^<number^> qui doit être exprimé en hexadécimal.
echo     /p      Définit que le préfixe doit être affiché en minuscules.
echo     /P      Définit que le préfixe doit être affiché en majuscules.
echo.    /?      Affiche cette aide.
echo.

:End
if not "%~0"==":Help" endlocal
exit /b 0

Lors de l'exécution d'une commande, l'interpréteur alloue un espace de mémoire supplémentaire pour cette commande. Cet espace de mémoire est appelé « canal standard », il permet aux commandes exécutées de recevoir des données et de renvoyer des messages d'erreurs ou de réussites. Le canal standard a une entrée (aussi appelée « entrée standard » ou « STDIN »), une sortie (aussi appelée « sortie standard » ou « STDOUT ») et une troisième partie réservée aux messages d'erreurs (appelés « erreurs standards » ou « STDERR »). Le flux de données arrive dans l'entrée standard, il est traité par la commande puis un message de réponse est envoyé dans la sortie standard. Si une erreur survient pendant l'exécution de la commande, le message d'erreur (s'il y en a un) est placé dans l'erreur standard. Par défaut, dès qu'une donnée est placée dans la sortie standard ou dans l'erreur standard, elle est affichée par l'interpréteur. Chaque partie du canal standard est désignée par un numéro qui lui est propre, ce numéro est appelé « handle ». Il permet à l'interpréteur d'identifier la zone de mémoire réservée à chaque partie du canal. Notez qu'un handle désigne un fichier chargé en mémoire, l'interpréteur traite les constituants du canal standard comme des fichiers chargés en mémoire. Dans la suite de ce chapitre, nous utiliserons le terme « tampon » pour désigner un fichier chargé en mémoire afin de ne pas induire le lecteur en erreur. Le schéma ci-dessous représente le déroulement de l'exécution d'une commande.

Afin de pouvoir contrôler les « mouvements » d'un flux, l'interpréteur fournit les opérateurs de redirection qui permettent, par exemple, d'envoyer des données dans un fichier ou de lire les données contenues dans un fichier. Le tableau ci-dessous donne une liste des différents opérateurs de redirection, leur syntaxe ainsi qu'une courte description.

Tableau 14 : Opérateurs de redirection

Cet opérateur permet d'exécuter plusieurs commandes, les unes à la suite des autres, sans tenir compte de ce qui s'est passé durant l'exécution de la commande précédente. Ainsi, chaque fois que l'interpréteur rencontre l'opérateur &, il sait qu'une autre commande est à exécuter, on parle d'exécution séquentielle.

@echo off & cls
echo Affichage:
echo. & echo. & echo 1 & echo 2
echo. &  echo.
pause & exit /b 0

La sortie standard (à ne pas confondre avec l'affichage standard que l'on a vu au chapitre I) reçoit les messages d'une commande exécutée dans l'interpréteur. Le meilleur exemple d'utilisation de la sortie standard est la commande echo qui ne fait qu'envoyer les données qui lui sont passées en paramètres dans la sortie standard. Chaque fois qu'une chaîne de caractères est envoyée dans la sortie standard, l'interpréteur l'affiche aussitôt. Il est possible de rediriger la sortie standard vers un fichier ou dans l'entrée d'une autre commande. Si la sortie standard est redirigée, tout ce qui est envoyé dans la sortie standard est ensuite placé dans sa nouvelle destination et rien n'est affiché dans l'interpréteur. La sortie standard peut-être désignée par son handle (1) ou de façon implicite si le caractère > est utilisé dans l'opérateur de redirection. Les redirections peuvent être placées avant ou après la commande, cela ne change rien à leurs significations. Le schéma ci-dessous représente l'exécution d'une commande avec redirection de la sortie standard.

Ces opérateurs permettent de rediriger la sortie standard ou le contenu d'un tampon vers un fichier. Seul le mode d'ouverture du fichier de destination diffère entre ces deux opérateurs. Ainsi, avec l'opérateur >, le fichier de destination n'est pas lu, les données sont donc effacées par l'écriture des nouvelles données. Avec l'opérateur >>, le fichier de destination est lu puis les nouvelles données sont ajoutées à la suite de celles déjà contenues dans le fichier de destination. Dans le script 72, la chaîne foo n'est pas dans le fichier Output.txt lorsqu'il est affiché par la commande type Output.txt, car le fichier n'a pas été lu lors de l'ajout de la chaîne bar.

@echo off
echo foo>Output.txt
echo bar>Output.txt
echo foobar>>Output.txt
type Output.txt
del /Q Output.txt
pause
exit /b 0