 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
Mise à jour:
Version: 1.0
Author: Jean-Louis Bicquelet-Salaün
Location:
Copyright: (c) 2012 Jean-Louis BICQUELET-SALAÜN
subroutines en batch dos
Le mode batch a toujours été présenté comme restreint. C'est sans doute le cas en comparaison des shells sous Unix.
Il est cependant possible de définir des sous-routines ou des fonctions en batch dos. C'est ce que nous allons voir.
Etude de fonctions
sous-routine
Le premier cas présenté est celui de la sous-routine.
Elle se définie par un label, c'est à dire une ligne commençant par le caractère : suivi d'un nom.Elle se termine par la ligne goto:eof. En temps normal, cette ligne fait sortir du batch. Maissi on fait précéder l'appel de la sous-routine par call, il y aura un appel à la sous-routine età la fin de celle-ci le programme reprend où il en était.
C'est ce que montre l'exemple qui suit.
@echo off
echo appel de la fonction call:sous_routine echo apres appel
echo.&pause&goto:eof
::-------------------------------------------------------- :: section fonctions ::--------------------------------------------------------
:sous_routine echo. de la execution subroutine goto:eof
fonction avec passage d'argument par valeur
La sous-routine présentée, possède des limitations. On aime pouvoir passer des variables et écrire des fonctions. Dans le cas où l'on passe des variables par valeur, il suffit d'écrire sur la ligne du call les paramètres à passer. La limite est de 9 arguments.
Dans la fonction le premier paramètre s'appelle %~1, le second %~ et ainsi de suite. Ilseuvent alors s'utiliser comme n'importe quelle variable.
@echo off
echo appel de la fonction call:fonction argument1 argument2 echo apres appel
echo.&pause&goto:eof
::-------------------------------------------------------- :: Fonction avec passage par valeur les arguments sont :: %~1 %~2 %~3 %~4 .. ::--------------------------------------------------------
:fonction echo. de la execution subroutine echo. arguments : %~1 %~2 goto:eof
fonction avec retourn d'argument
En batch en règle générale on utilise une variable globale que l'on affecte et qui revient modifié au programme principal. C'est le mode classique.
@echo off
echo avant appel de la fonction var = %var% call:fonction echo apres appel de la fonction var = %var%
echo.&pause&goto:eof
::-------------------------------------------------------- :: fonction changement de valeur classique ::--------------------------------------------------------
:fonction echo. de la execution subroutine set "var=valeur" goto:eof
fonction avec passage par reference
Une façon élégante de faire est de passer le nom de la variable à modifier à la fonction. A l'intérieur de la fonction on ferra une affectation de la manière suivante:
set %~1=valeur.
@echo off
set var= echo avant appel de la fonction var = %var% call:fonction var echo apres appel de la fonction var = %var%
echo.&pause&goto:eof
::-------------------------------------------------------- :: fonction changement de valeur par reference ::--------------------------------------------------------
:fonction echo. execution de la subroutine
set %~1=valeur goto:eof
variables locales
Il est possible d'utiliser des variables locales en définissant des sections
SETLOCAL ENDLOCAL
C'est un point que je développerai peut-être plus tard.