Obtenir la liste des arguments passés dans le script batch Windows (.bat)

Je voudrais trouver une contrepartie par lots de Windows à Bash $@qui contient une liste de tous les arguments passés dans un script.

Ou je dois m'embêter shift?

dancavallaro a raison, %*pour tous les paramètres de ligne de commande (à l'exception du nom du script lui-même). Vous pourriez aussi trouver cela utile:

%0- la commande utilisée pour appeler le fichier batch (pourrait être foo, ..\foo, c:\bats\foo.bat, etc.)
%1est le premier paramètre de ligne de commande,
%2est le deuxième paramètre de ligne de commande,
et ainsi de suite jusqu'à %9(et SHIFTpeut être utilisé pour ceux après le 9).

%~nx0- le nom réel du fichier de commandes, quelle que soit la méthode d'appel (some-batch.bat)
%~dp0- lecteur et chemin d'accès au script (d: \ scripts)
%~dpnx0- est le nom de chemin d'accès complet du script (d: \ scripts \ some -batch.bat)

Plus d'informations sur https://www.ss64.com/nt/syntax-args.html et https://www.robvanderwoude.com/parameters.html

%* semble contenir tous les arguments passés au script.

%1... %net %*contient les arguments, mais il peut être difficile d'y accéder, car le contenu sera interprété.
Par conséquent, il est impossible de gérer quelque chose comme ça avec des instructions normales

myBatch.bat "&"^&

Chaque ligne échoue, car cmd.exe essaie d'exécuter l'une des esperluettes (le contenu de% 1 est "&"&)

set var=%1
set "var=%1"
set var=%~1
set "var=%~1"

Mais il existe une solution de contournement avec un fichier temporaire

@echo off
SETLOCAL DisableDelayedExpansion

SETLOCAL
for %%a in (1) do (
    set "prompt=$_"
    echo on
    for %%b in (1) do rem * #%1#
    @echo off
) > param.txt
ENDLOCAL

for /F "delims=" %%L in (param.txt) do (
  set "param1=%%L"
)
SETLOCAL EnableDelayedExpansion
set "param1=!param1:*#=!"
set "param1=!param1:~0,-2!"
echo %%1 is '!param1!'

L'astuce consiste à activer echo onet à développer le %1après une reminstruction (fonctionne également avec% 2 ..% *).
Mais pour pouvoir rediriger la sortie de echo on, vous avez besoin des deux FOR-LOOPS.

Les caractères supplémentaires * #sont utilisés pour être sûrs contre des contenus comme /?(montrerait l'aide pour REM).
Ou un signe d'insertion ^ à la fin de la ligne pourrait fonctionner comme un caractère multiligne.

Le FOR / F devrait fonctionner avec une expansion retardée, sinon le contenu avec "!" serait détruit.
Après avoir supprimé les caractères supplémentaires param1et vous l'avez obtenu.

Et pour une utilisation param1sûre, activez l'expansion retardée.

Modifier: une remarque à% 0

%0contient la commande utilisée pour appeler le lot, préservant également la casse comme dans FoO.BaT
Mais après un appel à une fonction %0et %~0contient également le nom de la fonction (ou mieux la chaîne qui a été utilisée pour appeler la fonction).
Mais avec %~f0vous, vous pouvez toujours rappeler le nom du fichier.

@echo off
echo main %0, %~0, %~f0
call :myLabel+xyz
exit /b

:MYlabel
echo func %0, %~0, %~f0
exit /b

Production

main test.bat, test.bat, C:\temp\test.bat
func :myLabel+xyz, :myLabel+xyz, C:\temp\test.bat

J'ai trouvé cela la prochaine fois que vous devez rechercher ces informations. Au lieu d'ouvrir un navigateur et de le rechercher sur Google, vous pouvez simplement taper call /?votre cmd et vous l'obtiendrez:

...

%* in a batch script refers to all the arguments (e.g. %1 %2 %3
    %4 %5 ...)

Substitution of batch parameters (%n) has been enhanced.  You can
now use the following optional syntax:

    %~1         - expands %1 removing any surrounding quotes (")
    %~f1        - expands %1 to a fully qualified path name
    %~d1        - expands %1 to a drive letter only
    %~p1        - expands %1 to a path only
    %~n1        - expands %1 to a file name only
    %~x1        - expands %1 to a file extension only
    %~s1        - expanded path contains short names only
    %~a1        - expands %1 to file attributes
    %~t1        - expands %1 to date/time of file
    %~z1        - expands %1 to size of file
    %~$PATH:1   - searches the directories listed in the PATH
                   environment variable and expands %1 to the fully
                   qualified name of the first one found.  If the
                   environment variable name is not defined or the
                   file is not found by the search, then this
                   modifier expands to the empty string

The modifiers can be combined to get compound results:

    %~dp1       - expands %1 to a drive letter and path only
    %~nx1       - expands %1 to a file name and extension only
    %~dp$PATH:1 - searches the directories listed in the PATH
                   environment variable for %1 and expands to the
                   drive letter and path of the first one found.
    %~ftza1     - expands %1 to a DIR like output line

In the above examples %1 and PATH can be replaced by other
valid values.  The %~ syntax is terminated by a valid argument
number.  The %~ modifiers may not be used with %*

La façon de récupérer tous les arguments d'un script est ici:

@ECHO off
ECHO The %~nx0 script args are...
for %%I IN (%*) DO ECHO %%I
pause

Voici un moyen assez simple d'obtenir les arguments et de les définir comme vars env. Dans cet exemple, je vais simplement les appeler clés et valeurs.

Enregistrez l'exemple de code suivant sous "args.bat". Appelez ensuite le fichier de commandes que vous avez enregistré à partir d'une ligne de commande. exemple: arg.bat --x 90 --y 120

J'ai fourni quelques commandes d'écho pour vous guider à travers le processus. Mais le résultat final est que --x aura une valeur de 90 et --y aura une valeur de 120 (c'est-à-dire si vous exécutez l'exemple comme spécifié ci-dessus ;-)).

Vous pouvez ensuite utiliser l'instruction conditionnelle «si définie» pour déterminer si vous souhaitez ou non exécuter votre bloc de code. Disons donc run: "arg.bat --x hello-world" Je pourrais alors utiliser la déclaration "IF DEFINED --x echo% - x%" et les résultats seraient "hello-world". Cela devrait avoir plus de sens si vous exécutez le lot.

@setlocal enableextensions enabledelayedexpansion
@ECHO off
ECHO.
ECHO :::::::::::::::::::::::::: arg.bat example :::::::::::::::::::::::::::::::
ECHO :: By:      User2631477, 2013-07-29                                   ::
ECHO :: Version: 1.0                                                         ::
ECHO :: Purpose: Checks the args passed to the batch.                        ::
ECHO ::                                                                      ::
ECHO :: Start by gathering all the args with the %%* in a for loop.          ::
ECHO ::                                                                      ::
ECHO :: Now we use a 'for' loop to search for our keys which are identified  ::
ECHO :: by the text '--'. The function then sets the --arg ^= to the next    ::
ECHO :: arg. "CALL:Function_GetValue" ^<search for --^> ^<each arg^>         ::
ECHO ::                                                                      ::
ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

ECHO.

ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO :: From the command line you could pass... arg.bat --x 90 --y 220       ::
ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO.
ECHO.Checking Args:"%*"

FOR %%a IN (%*) do (
    CALL:Function_GetValue "--","%%a" 
)

ECHO.
ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO :: Now lets check which args were set to variables...                   ::
ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO.
ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO :: For this we are using the CALL:Function_Show_Defined "--x,--y,--z"   ::
ECHO ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO.
CALL:Function_Show_Defined "--x,--y,--z"
endlocal
goto done

:Function_GetValue

REM First we use find string to locate and search for the text.
echo.%~2 | findstr /C:"%~1" 1>nul

REM Next we check the errorlevel return to see if it contains a key or a value
REM and set the appropriate action.

if not errorlevel 1 (
  SET KEY=%~2
) ELSE (
  SET VALUE=%~2
)
IF DEFINED VALUE (
    SET %KEY%=%~2
    ECHO.
    ECHO ::::::::::::::::::::::::: %~0 ::::::::::::::::::::::::::::::
    ECHO :: The KEY:'%KEY%' is now set to the VALUE:'%VALUE%'                     ::
    ECHO :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    ECHO.
    ECHO %KEY%=%~2
    ECHO.
    REM It's important to clear the definitions for the key and value in order to
    REM search for the next key value set.
    SET KEY=
    SET VALUE=
)
GOTO:EOF

:Function_Show_Defined 
ECHO.
ECHO ::::::::::::::::::: %~0 ::::::::::::::::::::::::::::::::
ECHO :: Checks which args were defined i.e. %~2
ECHO :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
ECHO.
SET ARGS=%~1
for %%s in (%ARGS%) DO (
    ECHO.
    ECHO :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    ECHO :: For the ARG: '%%s'                         
    IF DEFINED %%s (
        ECHO :: Defined as: '%%s=!%%s!'                                             
    ) else (
        ECHO :: Not Defined '%%s' and thus has no value.
    )
    ECHO :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    ECHO.
)
goto:EOF

:done

Pour utiliser le bouclage pour obtenir tous les arguments et en batch pur:

Obs: Pour une utilisation sans:?*&<>

@echo off && setlocal EnableDelayedExpansion

for %%Z in (%*)do set "_arg_=%%Z" && set/a "_cnt+=1+0" && call set "_arg_[!_cnt!]=!_arg_!")

:: write/test these arguments/parameters ::
for /l %%l in (1 1 !_cnt!)do echo/ The argument n:%%l is: !_arg_[%%l]!

goto :eof 

Votre code est prêt à faire quelque chose avec le numéro d'argument dont il a besoin, comme ...

@echo off && setlocal EnableDelayedExpansion

for %%Z in (%*)do set "_arg_=%%Z" && set/a "_cnt+=1+0" && call set "_arg_[!_cnt!]=!_arg_!"

echo= !_arg_[1]! !_arg_[2]! !_arg_[2]!> log.txt

Le code suivant simule un tableau (' params') - prend les paramètres reçus par le script et les stocke dans les variables params_1.. params_n, où n= params_0= le nombre d'éléments du tableau:

@echo off

rem Storing the program parameters into the array 'params':
rem Delayed expansion is left disabled in order not to interpret "!" in program parameters' values;
rem however, if a parameter is not quoted, special characters in it (like "^", "&", "|") get interpreted at program launch
set /a count=0
:repeat
    set /a count+=1
    set "params_%count%=%~1"
    shift
    if defined params_%count% (
        goto :repeat
    ) else (
        set /a count-=1
    )    
set /a params_0=count

rem Printing the program parameters stored in the array 'params':
rem After the variables params_1 .. params_n are set with the program parameters' values, delayed expansion can
rem be enabled and "!" are not interpreted in the variables params_1 .. params_n values
setlocal enabledelayedexpansion
    for /l %%i in (1,1,!params_0!) do (
        echo params_%%i: "!params_%%i!"
    )
endlocal

pause
goto :eof

Si vous avez des paramètres entre guillemets contenant des espaces, %*ne fonctionnera pas correctement. La meilleure solution que j'ai trouvée est d'avoir une boucle qui joint tous les arguments: https://serverfault.com/a/22541

set args=%1
shift
:start
if [%1] == [] goto done
set args=%args% %1
shift
goto start

:done
(use %args% here)

Vous pouvez utiliser ForCommad, pour obtenir la liste des Arg.

Aide: For /? Aide:Setlocal /?

Voici ma voie =

@echo off
::For Run Use This = cmd /c ""Args.cmd" Hello USER Scientist etc"
setlocal EnableDelayedExpansion
set /a Count=0
for %%I IN (%*) DO (
 Echo Arg_!Count! = %%I
 set /a Count+=1 
)
Echo Count Of Args = !Count!
Endlocal

Pas besoin de la commande Shift.

@Écho off
:début

:: Insérez votre code ici
écho. %% 1 est maintenant:% ~ 1
:: Fin insérez votre code ici

si "% ~ 2" NEQ "" (
    décalage
    goto: start
)

Beaucoup d'informations ci-dessus m'ont amené à poursuivre mes recherches et finalement ma réponse, je voulais donc contribuer à ce que j'ai fini par faire dans l'espoir que cela aide quelqu'un d'autre:

• Je voulais également transmettre un nombre varié de variables à un fichier batch afin qu'elles puissent être traitées dans le fichier.

• J'étais d'accord pour les transmettre au fichier de commandes à l'aide de guillemets

• Je voudrais qu'ils soient traités comme ci-dessous - mais en utilisant une boucle au lieu d'écrire manuellement:

Je voulais donc exécuter ceci:

prog_ZipDeleteFiles.bat "_appPath=C:\Services\Logs\PCAP" "_appFile=PCAP*.?"

Et via la magie des boucles for, faites-le dans le fichier batch:

set "_appPath=C:\Services\Logs\PCAP"
set "_appFile=PCAP*.?"

Le problème que je rencontrais est que toutes mes tentatives d'utilisation d'une boucle for ne fonctionnaient pas. L'exemple ci-dessous:

for /f "tokens* delims= " in %%A (%*) DO (
   set %%A
)

ferait juste:

set "_appPath=C:\Services\Logs\PCAP"

et pas:

set "_appPath=C:\Services\Logs\PCAP"
set "_appFile=PCAP*.?"

même après le réglage

SETLOCAL EnableDelayedExpansion

La raison était que la boucle for lisait la ligne entière et affectait mon deuxième paramètre à %% B lors de la première itération de la boucle. Parce que% * représente tous les arguments, il n'y a qu'une seule ligne à traiter - ergo une seule passe de la boucle for se produit. C'est par conception que cela s'avère, et ma logique était fausse.

J'ai donc arrêté d'essayer d'utiliser une boucle for et simplifié ce que j'essayais de faire en utilisant if, shift et une instruction goto. D'accord, c'est un peu un hack mais c'est plus adapté à mes besoins. Je peux parcourir tous les arguments, puis utiliser une instruction if pour abandonner la boucle une fois que je les ai tous traités.

La déclaration gagnante pour ce que j'essayais d'accomplir:

echo on
:processArguments
:: Process all arguments in the order received
if defined %1 then (
    set %1
    shift
    goto:processArguments
) ELSE (
    echo off 
)

MISE À JOUR - J'ai dû modifier à la place ci-dessous, j'exposais toutes les variables d'environnement en essayant de référencer% 1 et en utilisant shift de cette manière:

echo on
shift
:processArguments
:: Process all arguments in the order received
if defined %0 then (
    set %0
    shift
    goto:processArguments
) ELSE (
    echo off 
)

Parfois, j'ai besoin d'extraire plusieurs paramètres de ligne de commande, mais pas tous et pas du premier. Supposons l'appel suivant:

Test.bat uno dos tres cuatro cinco seis siete

Bien sûr, l'extension ".bat" n'est pas nécessaire au moins vous avez test.exe dans le même dossier. Ce que nous voulons, c'est obtenir la sortie "tres cuatro cinco" (que ce soit une ou trois lignes). Le but est que seulement j'ai besoin de trois paramètres et de commencer par le troisième. Afin d'avoir un exemple simple, l'action pour chacun est juste "écho", mais vous pouvez penser dans une autre action plus complexe sur les paramètres sélectionnés.

J'ai produit quelques exemples, (options) afin que vous puissiez voir celui que vous considérez le mieux pour vous. Malheureusement, il n'y a pas de méthode sympa (ou je ne sais pas) basée sur une boucle for sur la plage comme "for %% i in (% 3, 1,% 5)".

@echo off 
setlocal EnableDelayedExpansion

echo Option 1: one by one (same line)
echo %3, %4, %5
echo.

echo Option 2: Loop For one by one
for %%a in (%3, %4, %5) do echo %%a
echo.

echo Option 3: Loop For with check of limits
set i=0
for %%a in (%*) do (
    set /A i=i+1
    If !i! GTR 2 if !i! LSS 6 echo %%a
)
echo.

echo Option 4: Loop For with auxiliary list
for /l %%i in (3,1,5) do  (
    set a=%%i
    set b=echo %%
    set b=!b!!a!
    call !b!
)
echo.

echo Option 5: Assigning to an array of elements previously
set e[0]=%0
set i=0 
for %%a in (%*) do (
    set /A i=i+1
    set e[!i!]=%%a
)
for  /l %%i in (3,1,5) do (
    echo !e[%%i]!
)
echo.

echo Option 6: using shift and goto loop. It doesn't work with for loop
set i=2
:loop6
    set /A i=i+1
    echo %3
    shift
    If %i% LSS 5 goto :loop6

Vous pouvez probablement trouver plus d'options ou en combiner plusieurs. Profites-en.

Version Windows (nécessite cependant socat)

C:\Program Files (x86)\Git\bin>type gitproxy.cmd
socat STDIO PROXY:proxy.mycompany.de:%1:%2,proxyport=3128

configuration:

C:\Users\exhau\AppData\Roaming\npm>git config --global core.gitproxy gitproxy.cmd