batch-file
Variables dans des fichiers batch

Déclaration

Pour créer une variable simple et l'assigner à une valeur ou à une chaîne, utilisez la commande SET :

SET var=10

Ici, le code déclare une nouvelle variable var d'une valeur de 10 . Par défaut, toutes les variables sont stockées en interne sous forme de chaînes. cela signifie que la valeur 10 n'est pas différente de foo1234 ou Hello, World!

Notes sur les guillemets

Les guillemets utilisés seront inclus dans la valeur de la variable:

SET var="new value"             <-- %var% == '"new value"'

Espaces dans les variables

Le langage par lots considère les espaces comme des parties acceptables des noms de variables. Par exemple, set var = 10 donnera une variable appelée var contenant la valeur 10 (notez l'espace supplémentaire à droite de var et la gauche du 10).

Utiliser des guillemets pour éliminer les espaces

Afin d'éviter les espaces, utilisez des guillemets autour de l'assignation entière; le nom et la valeur de la variable. Cela évite également les espaces de fin de ligne accidentels à la fin de la ligne (le caractère ␣ indique un espace):

SET␣var=my␣new␣value␣           <-- '%var%' == 'my new value '
SET␣"var=my␣new␣value"␣         <-- '%var%' == 'my new value'

Utilisez également des guillemets lorsque vous associez plusieurs instructions avec & ou | - sinon, placez le symbole directement après la fin de la valeur de la variable:

SET var=val & goto :next        <-- '%var%' == 'val '
SET "var=val" & goto :next      <-- '%var%' == 'val'
SET var=val& goto :next         <-- '%var%' == 'val'

Usage

echo %var%

Ce code fera écho à la valeur de var

Si setLocal EnableDelayedExpansion est utilisé, ce qui suit fera écho à la valeur de var (l'expression standard% var% ne fonctionnera pas dans ce contexte).

echo !var!

Dans les fichiers de commandes, les variables peuvent être utilisées dans n'importe quel contexte, y compris en tant que parties de commandes ou parties d'autres variables. Vous ne pouvez pas appeler une variable avant de la définir.

Utiliser des variables comme commandes:

set var=echo
%var% This will be echoed

Utilisation de variables dans d'autres variables:

set var=part1
set %var%part2=Hello
echo %part1part2%

Substitution variable

Contrairement à d'autres langages de programmation, une variable est remplacée par sa valeur réelle dans un fichier de commandes avant l'exécution du script de traitement par lots. En d'autres termes, la substitution est effectuée lorsque le script est lu en mémoire par le processeur de commandes, et non lors de l' exécution ultérieure du script.

Cela permet d'utiliser des variables comme commandes dans le script, et dans le cadre d'autres noms de variables dans le script, etc. Le "script" dans ce contexte est une ligne ou un bloc de code, entouré de parenthèses: () .

Mais ce comportement signifie que vous ne pouvez pas modifier la valeur d'une variable dans un bloc!

SET VAR=Hello
FOR /L %%a in (1,1,2) do (
    ECHO %VAR%
    SET VAR=Goodbye
)

imprimera

Hello
Hello

car (comme vous le voyez, lorsque vous regardez le script exécuté dans la fenêtre de commande), il est évalué comme suit:

SET VAR=Hello
FOR /L %%a in (1,1,2) do (
    echo Hello
    SET VAR=Goodbye
)

Dans l'exemple ci-dessus, la commande ECHO est évaluée en tant que Hello lorsque le script est lu en mémoire, de sorte que le script fera écho à Hello pour toujours, même si de nombreux passages sont effectués via le script.

La manière d'obtenir le comportement de variable le plus "traditionnel" (de la variable en cours d'expansion pendant l'exécution du script) est de permettre une "extension retardée". Cela implique d'ajouter cette commande dans le script avant l'instruction de boucle (généralement une boucle FOR, dans un script de traitement par lots) et d'utiliser un point d'exclamation (!) Au lieu du signe de pourcentage (%) dans le nom de la variable:

setlocal enabledelayedexpansion 
SET VAR=Hello
FOR /L %%a in (1,1,2) do (
    echo !VAR!
    SET VAR=Goodbye
)
endlocal

imprimera

Hello
Goodbye

La syntaxe %%a in (1,1,2) provoque l'exécution de la boucle 2 fois: à la première occasion, la variable porte sa valeur initiale «Hello», mais lors de la seconde, elle passe par la boucle - après avoir exécuté la seconde SET instruction comme la dernière action sur la 1ère passe - cela a changé à la valeur révisée «Au revoir».

Substitution de variable avancée

Maintenant, une technique avancée. L'utilisation de la commande CALL permet au processeur de commandes par lots d'étendre une variable située sur la même ligne du script. Cela peut fournir une expansion à plusieurs niveaux, en utilisant CALL et l'utilisation de modificateurs.

Ceci est utile, par exemple, dans une boucle FOR. Comme dans l'exemple suivant, où nous avons une liste numérotée de variables:

"c:\MyFiles\test1.txt" "c:\MyFiles\test2.txt" "c:\MyFiles\test3.txt"

Nous pouvons y parvenir en utilisant la boucle FOR suivante:

setlocal enabledelayedexpansion
for %%x in (%*) do (
    set /a "i+=1"
    call set path!i!=%%~!i!
    call echo %%path!i!%%
)
endlocal

Sortie:

c:\MyFiles\test1.txt
c:\MyFiles\test2.txt
c:\MyFiles\test3.txt

Notez que la variable !i! est d'abord étendu à sa valeur initiale, 1, puis la variable résultante,% 1, est étendue à sa valeur réelle de c:\MyFiles\test1.txt . C'est la double expansion de la variable i . Sur la ligne suivante, i nouveau double, en utilisant la commande CALL ECHO avec le préfixe de la variable %% , puis imprimée à l'écran (c'est-à-dire affichée à l'écran).

A chaque passage successif de la boucle, le nombre initial est augmenté de 1 (à cause du code i+=1 ). Ainsi, il augmente à 2 au 2ème passage dans la boucle et à 3 au 3ème passage. Ainsi, la chaîne qui résonne à l'écran se modifie à chaque passage.

Déclarer plusieurs variables

Lorsque plusieurs variables sont définies au début du lot, une forme de définition courte peut être utilisée en utilisant une chaîne de remplacement .

@echo off
set "vars=_A=good,_B=,_E=bad,_F=,_G=ugly,_C=,_H=,_I=,_J=,_K=,_L=,_D=6
set "%vars:,=" & set "%"

for /f %%l in ('set _') do echo %%l
exit /b

_A=good
_D=6
_E=bad
_G=ugly

Notez que dans l'exemple ci-dessus, les variables sont triées en ordre alphabétique en mode natif, lorsqu'elles sont imprimées sur l'écran.

Utiliser une variable comme tableau

Il est possible de créer un ensemble de variables pouvant agir de manière similaire à un tableau (bien qu'il ne s'agisse pas d'un objet de tableau réel) en utilisant des espaces dans l'instruction SET :

@echo off
SET var=A "foo bar" 123
for %%a in (%var%) do (
    echo %%a
)
echo Get the variable directly: %var%

Résultat:

A
"foo bar"
123
Get the variable directly: A "foo bar" 123

Il est également possible de déclarer votre variable à l'aide d'index afin de pouvoir récupérer des informations spécifiques. Cela créera plusieurs variables, avec l'illusion d'un tableau:

@echo off
setlocal enabledelayedexpansion
SET var[0]=A
SET var[1]=foo bar
SET var[2]=123
for %%a in (0,1,2) do (
    echo !var[%%a]!
)
echo Get one of the variables directly: %var[1]%

Résultat:

A
foo bar
123
Get one of the variables directly: foo bar

Notez que dans l'exemple ci-dessus, vous ne pouvez pas référencer var sans indiquer ce qu'est l'index souhaité, car var n'existe pas dans ses propres. Cet exemple utilise également setlocal enabledelayedexpansion conjointement avec les points d'exclamation à !var[%%a]! . Vous pouvez afficher plus d'informations à ce sujet dans la documentation de portée de substitution de variable .

Opérations sur les variables

set var=10
set /a var=%var%+10
echo %var%

La valeur finale de var est 20.

La deuxième ligne ne fonctionne pas dans un bloc de commande utilisé, par exemple, sur une condition IF ou sur une boucle FOR , car une extension retardée serait nécessaire au lieu d'une extension de variable d'environnement standard.

Voici un autre moyen plus efficace de travailler dans un bloc de commandes:

set var=10
set /A var+=10
echo %var%

L'environnement d'invite de commandes prend en charge les valeurs entières signées sur 32 bits:

• addition + et +=
• soustraction - et -=
• multiplication * et *=
• division / et /=
• division de module % et %=
• bitwise ET &
• bit à bit OU |
• bitwise NON ~
• binaire XOR ^
• décalage binaire gauche <<
• décalage au niveau du bit >>
• logique non !
• unaire moins -
• grouper avec ( et )

L'interpréteur de commandes Windows ne prend pas en charge les valeurs entières 64 bits ni les valeurs à virgule flottante dans les expressions arithmétiques.

Remarque: L'opérateur % doit être écrit dans un fichier de commandes sous la forme %% pour être interprété comme opérateur.

Dans une fenêtre d'invite de commandes exécutant le set /A Value=8 % 3 lignes de commandes set /A Value=8 % 3 la valeur 2 est 2 à la variable d'environnement Value et les sorties 2 .

Dans un fichier de commandes doit être écrit set /A Value=8 %% 3 pour affecter la valeur 2 à la variable d'environnement Value et rien n'est sorti respectivement écrit pour gérer STDOUT (sortie standard). Un set /A Value=8 % 3 lignes set /A Value=8 % 3 dans un fichier de commandes entraînerait un message d'erreur Opérateur manquant lors de l'exécution du fichier de commandes.

L'environnement nécessite le commutateur /A pour les opérations arithmétiques uniquement, pas pour les variables de chaîne ordinaires.

Chaque chaîne de l'expression arithmétique après set /A si un numéro ou un opérateur est automatiquement interprété comme le nom d'une variable d'environnement.

Pour cette raison, en référençant la valeur d'une variable avec %variable% ou avec !variable! n'est pas nécessaire lorsque le nom de la variable ne comprend que des caractères verbaux (0-9A-Za-z_), le premier caractère n'étant pas un chiffre particulièrement utile dans un bloc de commandes commençant par ( et se terminant par une correspondance ) .

Les nombres sont convertis de chaîne en entier avec la fonction C / C ++ strtol, la base étant zéro, ce qui signifie que la détermination automatique de la base peut facilement donner des résultats inattendus.

Exemple:

set Divided=11
set Divisor=3

set /A Quotient=Divided / Divisor
set /A Remainder=Divided %% Divisor

echo %Divided% / %Divisor% = %Quotient%
echo %Divided% %% %Divisor% = %Remainder%

set HexValue1=0x14
set HexValue2=0x0A
set /A Result=(HexValue1 + HexValue2) * -3

echo (%HexValue1% + %HexValue2%) * -3 = (20 + 10) * -3 = %Result%

set /A Result%%=7
echo -90 %%= 7 = %Result%

set OctalValue=020
set DecimalValue=12
set /A Result=OctalValue - DecimalValue

echo %OctalValue% - %DecimalValue% = 16 - 12 = %Result%

La sortie de cet exemple est la suivante:

11 / 3 = 3
11 % 3 = 2
(0x14 + 0x0A) * -3 = (20 + 10) * -3 = -90
-90 %= 7 = -6
020 - 12 = 16 - 12 = 4

Les variables non définies lors de l'évaluation de l'expression arithmétique sont remplacées par la valeur 0.

Définition de variables à partir d'une entrée

En utilisant le commutateur /p avec la commande SET vous pouvez définir des variables à partir d'une entrée.

Cette entrée peut être une entrée utilisateur (clavier):

echo Enter your name : 
set /p name=
echo Your name is %name%

Ce qui peut être simplifié comme ceci:

set /p name=Enter your name :
echo Your name is %name%

Ou vous pouvez obtenir l'entrée d'un fichier:

set /p name=< file.txt

dans ce cas, vous obtenez la valeur de la première ligne à partir de file.txt

Obtenir la valeur de différentes lignes dans un fichier:

(
   set /p line1=
   set /p line2=
   set /p line3=

) < file.txt