Fichiers Batch

Une compétence complète pour créer, éditer, déboguer et maintenir des fichiers batch Windows (.bat/.cmd) en utilisant cmd.exe. S'applique au développement d'outils CLI, à l'automatisation de l'administration système, aux tâches planifiées, aux scripts d'opérations fichiers et aux scripts exécutables basés sur PATH.

Quand utiliser cette compétence

• Créer ou éditer des fichiers .bat ou .cmd
• Automatiser des tâches Windows (opérations fichiers, déploiements, sauvegardes)
• Construire des outils CLI destinés à un dossier bin/ sur PATH
• Écrire des scripts de tâches planifiées (SCHTASKS, Task Scheduler)
• Déboguer les problèmes de scripts batch (expansion de variables, niveaux d'erreur, guillemets)
• Intégrer des scripts batch avec des outils externes (curl, git, Node.js, Python)
• Créer des projets batch avec des modèles structurés

Prérequis

• Système d'exploitation basé sur Windows NT (Windows 7 ou ultérieur)
• cmd.exe (intégré)
• Optionnel : un répertoire bin/ sur PATH pour distribuer les scripts comme des commandes
• Optionnel : PATHEXT configuré pour inclure .BAT;.CMD (par défaut sur Windows)

Interprétation des commandes

cmd.exe traite chaque ligne selon quatre étapes dans l'ordre :

1. Substitution de variables — Les jetons %VAR% sont remplacés par les valeurs des variables d'environnement. %0–%9 font référence aux arguments du batch. %* se développe en tous les arguments.
2. Guillemets et échappement — Le caret ^ échappe les caractères spéciaux (& | < > ^). Les guillemets empêchent l'interprétation des caractères spéciaux qu'ils contiennent. Dans les fichiers batch, %% produit un % littéral.
3. Analyse syntaxique — Les lignes sont scindées en pipelines (|), commandes composées (&, &&, ||) et groupes entre parenthèses ( ).
4. Redirection — > écrase, >> ajoute, < lit l'entrée, 2> redirige stderr, 2>&1 fusionne stderr dans stdout, >NUL ignore la sortie.

Variables

Variables d'environnement

set _MY_VAR=Hello World
echo %_MY_VAR%
set _MY_VAR=

• set sans arguments affiche toutes les variables
• set _PREFIX affiche les variables commençant par _PREFIX
• Pas d'espaces autour de = — set name = val définit la variable "name " à " val"

Variables spéciales

Portée avec SETLOCAL / ENDLOCAL

setlocal
set _LOCAL_VAR=scoped value
endlocal
REM _LOCAL_VAR n'est plus défini ici

Pour retourner une valeur d'un bloc avec portée :

endlocal & set _RESULT=%_LOCAL_VAR%

Expansion différée

Les variables à l'intérieur de blocs entre parenthèses sont développées au moment de l'analyse. Utilisez l'expansion différée pour l'évaluation à l'exécution :

setlocal EnableDelayedExpansion
set _COUNT=0
for /l %%i in (1,1,5) do (
    set /a _COUNT+=1
    echo !_COUNT!
)
endlocal

• !VAR! se développe à l'exécution (différé)
• %VAR% se développe à l'analyse (immédiat)

Flux de contrôle

Exécution conditionnelle

if exist "output.txt" echo File found
if not defined _MY_VAR echo Variable not set
if "%_STATUS%"=="ready" (echo Go) else (echo Wait)
if %ERRORLEVEL% neq 0 echo Command failed

Opérateurs de comparaison : equ, neq, lss, leq, gtr, geq. Utilisez /i pour les comparaisons de chaînes insensibles à la casse.

Commandes composées

command1 & command2        & REM Toujours exécuter les deux
command1 && command2       & REM Exécuter command2 seulement si command1 réussit
command1 || command2       & REM Exécuter command2 seulement si command1 échoue

Boucles FOR

REM Itérer sur un ensemble de valeurs
for %%i in (alpha beta gamma) do echo %%i

REM Plage numérique : début, pas, fin
for /l %%i in (1,1,10) do echo %%i

REM Fichiers dans un répertoire
for %%f in (*.txt) do echo %%f

REM Recherche de fichiers récursive
for /r %%f in (*.log) do echo %%f

REM Répertoires seulement
for /d %%d in (*) do echo %%d

REM Analyser la sortie de commande
for /f "tokens=1,2 delims=:" %%a in ('ipconfig ^| findstr "IPv4"') do echo %%b

REM Analyser les lignes du fichier
for /f "usebackq tokens=*" %%a in ("data.txt") do echo %%a

GOTO et labels

goto :main_logic
:usage
echo Usage: %~nx0 [options]
exit /b 1

:main_logic
echo Running main logic...
goto :eof

goto :eof quitte le batch courant ou la subroutine. Les labels commencent par :.

Arguments de ligne de commande

Modèle d'analyse des arguments

:parse_args
if "%~1"=="" goto :args_done
if /i "%~1"=="--help" goto :usage
if /i "%~1"=="--output" (
    set "_OUTPUT_DIR=%~2"
    shift
)
shift
goto :parse_args
:args_done

Traitement de chaînes

Sous-chaînes

set _STR=Hello World
echo %_STR:~0,5%       & REM "Hello"
echo %_STR:~6%         & REM "World"
echo %_STR:~-5%        & REM "World"
echo %_STR:~0,-6%      & REM "Hello"

Recherche et remplacement

set _STR=Hello World
echo %_STR:World=Earth%       & REM "Hello Earth"
echo %_STR:Hello=%            & REM " World" (supprimer "Hello")

Test de contenance de sous-chaîne

if not "%_STR:World=%"=="%_STR%" echo Contains "World"

Fonctions

Les fonctions utilisent des labels, CALL et SETLOCAL/ENDLOCAL :

@echo off
call :greet "Jane Doe"
echo Result: %_GREETING%
exit /b 0

:greet
setlocal
set "_MSG=Hello, %~1"
endlocal & set "_GREETING=%_MSG%"
exit /b 0

• call :label args invoque une fonction
• exit /b revient de la fonction (pas du script)
• Utilisez l'astuce endlocal & set pour passer les valeurs hors d'un bloc avec portée

Arithmétique

set /a effectue une arithmétique entière signée sur 32 bits :

set /a _RESULT=10 * 5 + 3
set /a _COUNTER+=1
set /a _REMAINDER=14 %% 3       & REM Utiliser %% pour le modulo dans les fichiers batch
set /a _BITS="255 & 0x0F"       & REM ET au niveau du bit

Opérateurs supportés : + - * / %% ( ) et au niveau du bit & | ^ ~ << >>.

Les littéraux hexadécimaux (0xFF) et octaux (077) sont supportés.

Gestion des erreurs

Conventions de niveau d'erreur

• 0 = succès
• Non-zéro = échec (généralement 1)

mycommand.exe
if %ERRORLEVEL% neq 0 (
    echo ERROR: mycommand failed with code %ERRORLEVEL%
    exit /b %ERRORLEVEL%
)

Modèle fail-fast

command1 || (echo command1 failed & exit /b 1)
command2 || (echo command2 failed & exit /b 1)

Définition des codes de sortie

exit /b 0        & REM Retourner un succès d'un batch/fonction
exit /b 1        & REM Retourner un échec
cmd /c "exit /b 42"   & REM Définir ERRORLEVEL à 42 en ligne

Référence des commandes essentielles

Opérations fichiers

Recherche et traitement de texte

Informations système

Réseau

Planification et automatisation

Utilitaires Shell

Syntaxe Shell et expressions

Parenthèses pour le regroupement

Les parenthèses transforment les commandes composées en une seule unité pour la redirection ou l'exécution conditionnelle :

(echo Line 1 & echo Line 2) > output.txt
if exist "data.csv" (
    echo Processing...
    call :process "data.csv"
) else (
    echo No data found.
)

Caractères d'échappement

Le caret ^ échappe le caractère suivant :

echo Total ^& Summary          & REM Affiche : Total & Summary
echo 100%% complete            & REM Affiche : 100% complete (dans batch)
echo Line one^
Line two                       & REM Le caret échappe la nouvelle ligne

Après un pipe, le triple caret est nécessaire : echo x ^^^& y | findstr x

Caractères génériques

• * correspond à n'importe quelle séquence de caractères
• ? correspond à un seul caractère (ou zéro à la fin d'un segment sans point)

dir *.txt           & REM Tous les fichiers .txt
ren *.jpeg *.jpg    & REM Renommage en masse

Résumé de redirection

command > file.txt          & REM Écrase stdout dans le fichier
command >> file.txt         & REM Ajoute stdout au fichier
command 2> errors.log       & REM Rédiriger stderr
command > all.log 2>&1      & REM Fusionner stderr dans stdout
command < input.txt         & REM Lire stdin depuis le fichier
command > NUL 2>&1          & REM Ignorer toute la sortie

Écrire des fichiers batch de qualité production

Structure de script standard

@echo off
setlocal EnableDelayedExpansion

REM ============================================================
REM  Script: example.bat
REM  Purpose: Describe what this script does
REM ============================================================

call :main %*
exit /b %ERRORLEVEL%

:main
    call :parse_args %*
    if not defined _TARGET (
        echo ERROR: --target is required. 1>&2
        call :usage
        exit /b 1
    )
    echo Processing: %_TARGET%
    exit /b 0

:parse_args
    if "%~1"=="" exit /b 0
    if /i "%~1"=="--target" set "_TARGET=%~2" & shift
    if /i "%~1"=="--help"   call :usage & exit /b 0
    shift
    goto :parse_args

:usage
    echo Usage: %~nx0 --target ^<path^> [--help]
    echo.
    echo Options:
    echo   --target   Path to process (required)
    echo   --help     Show this help message
    exit /b 0

Bonnes pratiques

1. Toujours commencer par @echo off et setlocal — Prévient la sortie bruyante et la fuite de variables vers l'appelant.
2. Valider les entrées avant le traitement — Vérifier les arguments requis et l'existence des fichiers tôt. Utiliser if not defined et if not exist.
3. Mettre entre guillemets les chemins et variables — Utiliser "%~1" et "%_MY_PATH%" pour gérer en toute sécurité les espaces et les caractères spéciaux.
4. Utiliser exit /b au lieu de exit — Évite de fermer la fenêtre de la console parent.
5. Retourner des codes de sortie significatifs — exit /b 0 pour le succès, non-zéro pour les échecs spécifiques.
6. Utiliser %~dp0 pour les chemins relatifs au script — Garantit que le script fonctionne quel que soit le répertoire de travail de l'appelant.
7. Préférer ROBOCOPY à XCOPY — Plus fiable, supporte les retries, le mirroring et le logging.
8. Utiliser EnableDelayedExpansion lors de la modification de variables dans les boucles ou les blocs entre parenthèses.
9. Écrire les erreurs vers stderr — echo ERROR: message 1>&2 garde stdout propre pour le piping.
10. Utiliser REM pour les commentaires — :: peut causer des problèmes dans les corps de boucles FOR.

Considérations de sécurité

• Ne jamais stocker les identifiants dans les fichiers batch — Utiliser les variables d'environnement, les magasins d'identifiants ou les invites.
• Valider l'entrée de l'utilisateur — Les variables non guillemets contenant &, | ou > peuvent injecter des commandes. Toujours mettre entre guillemets : "%_USER_INPUT%".
• Utiliser SETLOCAL — Empêche les valeurs de variables de fuir vers les processus parents.
• Nettoyer les chemins de fichiers — Valider les chemins avant les passer à DEL, RD ou ROBOCOPY pour prévenir la suppression involontaire.
• Éviter SET /P pour l'entrée sensible — L'entrée est visible et stockée dans l'historique de la console. Utiliser un outil d'identifiants dédié si possible.

Débogage et dépannage

Outils multiplates-formes et étendus

Quand le scripting batch atteint ses limites, ces outils étendent les capacités de cmd.exe :

Utiliser batch quand vous avez besoin : démarrage rapide, opérations fichiers simples, outils CLI basés sur PATH, ou intégration de Task Scheduler. Envisager PowerShell ou WSL pour le traitement de données complexes, les API REST ou le scripting orienté objet.

Raccourcis clavier CMD

Fichiers de référence

Le dossier references/ contient la documentation détaillée :

Modèles de ressources

Le dossier assets/ contient les données de modèle de fichier batch de démarrage, mais sous forme de fichiers texte :