Obter lista de argumentos passados ​​no script em lote do Windows (.bat)

405

Gostaria de encontrar uma contrapartida em lote do Windows para a Bash $@que contém uma lista de todos os argumentos passados ​​para um script.

Ou eu tenho que me preocupar shift?

wheleph
fonte

Respostas:

622

dancavallaro está certo, %*para todos os parâmetros de linha de comando (excluindo o próprio nome do script). Você também pode achar úteis:

%0- o comando usado para chamar o arquivo de lote (poderia ser foo, ..\foo, c:\bats\foo.bat, etc.)
%1é o primeiro parâmetro de linha de comando,
%2é o segundo parâmetro de linha de comando,
e assim por diante até %9(e SHIFTpode ser usado para aqueles que depois da 9ª).

%~nx0- o nome real do arquivo em lotes, independentemente do método de chamada (some-batch.bat)
%~dp0- unidade e caminho para o script (d: \ scripts)
%~dpnx0- é o nome completo do caminho do script (d: \ scripts \ some -batch.bat)

Mais exemplos de informações em https://www.ss64.com/nt/syntax-args.html e https://www.robvanderwoude.com/parameters.html

wilkie mate
fonte
11
Observe que o SHIFT não afeta% *, impossibilitando o uso do SHIFT [/ n] de maneira um pouco intuitiva, como acessar toda a linha de comando a partir do n-ésimo parâmetro.
22613 Van Jone
4
Outra coisa que descobri é que %~dpn0retornará a unidade e o caminho para o script mais o nome do arquivo em lotes, mas não a extensão. Achei isso particularmente útil ao criar scripts em lote que chamam um .ps1arquivo com o mesmo nome. Essencialmente, drefere-se à unidade, prefere-se ao caminho, nrefere-se ao nome do arquivo e xrefere-se à extensão. Com essa informação, você pode fazer bastante.
9309 Dan Atkinson #
Por curiosidade, supondo que eu queira usar o ECHO para imprimir o caminho do arquivo, mas substituindo sua extensão, como isso aconteceria?
Matheus Rocha
2
@MatheusRocha@echo %~n0.my_ext
matt wilkie
@mattwilkie Obrigado, descobri usando o ECHO para ver o que seria impresso como resultado.
Matheus Rocha
149

%* parece conter todos os argumentos passados ​​para o script.

dancavallaro
fonte
alguma idéia de por que ele não lida com alguns personagens como &? Quando tento recuperar vários o caminho de vários arquivos selecionados (usando o menu Enviar para e "% *" que passa os argumentos para um .py), ele interrompe a listagem nos caracteres. Assim, se, por exemplo, o segundo arquivo contém um &em seu nome, a parte do nome após o &serão ignorados, e também os arquivos remainng).
JinSnow
1
@JinSnow O &é um caractere especial que significa stop this command and start another one. Um nome de arquivo contendo & DEVE ser citado.
Jesse Chisholm
65

%1... %ne %*mantém os argumentos, mas pode ser difícil acessá-los, porque o conteúdo será interpretado.
Portanto, é impossível lidar com algo assim com declarações normais

myBatch.bat "&"^&

Cada linha falha, pois o cmd.exe tenta executar um dos e comercial (o conteúdo de% 1 é "&"&)

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

Mas existe uma solução alternativa com um arquivo temporário

@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!'

O truque é ativar echo one expandir a instrução %1after rem(funciona também com% 2 ..% *).
Mas para poder redirecionar a saída de echo on, você precisa dos dois FOR-LOOPS.

Os caracteres extras * #são usados ​​para proteger contra conteúdos como /?(mostraria a ajuda do REM).
Ou um sinal de intercalação ^ no final da linha pode funcionar como um caractere de múltiplas linhas.

O FOR / F deve funcionar com a expansão atrasada, caso contrário, o conteúdo com "!" seria destruído.
Depois de remover os caracteres extras param1e você conseguiu.

E para usar de param1maneira segura, habilite a expansão atrasada.

Editar: uma observação para% 0

%0contém o comando usado para chamar o lote, preservando também o caso, como em FoO.BaT
But after a call to a function %0e também in %~0contém o nome da função (ou melhor, a string usada para chamar a função).
Mas com %~f0você ainda pode se lembrar do nome do arquivo.

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

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

Resultado

main test.bat, test.bat, C:\temp\test.bat
func :myLabel+xyz, :myLabel+xyz, C:\temp\test.bat
jeb
fonte
6
+++ 1 OMG - O %~f0truque é totalmente inesperado, muito interessante e potencialmente muito útil :-) Não surpreendentemente, os outros modificadores funcionam da mesma maneira, sempre operando no arquivo em lote pai, mesmo quando em uma sub-rotina chamada. Isso parece digno de suas próprias perguntas e respostas - "Como acessar o nome do lote em execução quando em uma sub-rotina chamada?"
dbenham
Se bem me lembro, você pode usar call com argumentos, e esses serão armazenados em% 1,% 2, ...% n, exatamente como quando você executa um script.
Nulano
49

Descobri isso na próxima vez em que você precisar procurar essas informações. Em vez de abrir um navegador e pesquisá-lo no Google, você pode digitar call /?seu cmd e obtê-lo:

...

%* 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 %*
KFL
fonte
20

A maneira de recuperar todos os argumentos para um script é aqui:

@ECHO off
ECHO The %~nx0 script args are...
for %%I IN (%*) DO ECHO %%I
pause
djangofan
fonte
2
Na verdade, não, %%Iseja interpretado e pode quebrar seu script.
Boris Brodski
5

Aqui está uma maneira bastante simples de obter os argumentos e configurá-los como env vars. Neste exemplo, vou apenas me referir a eles como Chaves e Valores.

Salve o seguinte exemplo de código como "args.bat". Em seguida, chame o arquivo em lotes que você salvou em uma linha de comando. exemplo: arg.bat --x 90 --y 120

Forneci alguns comandos de eco para orientá-lo no processo. Mas o resultado final é que --x terá um valor de 90 e --y terá um valor de 120 (ou seja, se você executar o exemplo conforme especificado acima ;-)).

Você pode usar a instrução condicional 'se definida' para determinar se deve ou não executar seu bloco de código. Então, digamos, execute: "arg.bat --x hello-world" Eu poderia usar a declaração "SE DEFINIDO --x echo% - x%" e os resultados seriam "hello-world". Deve fazer mais sentido se você executar o lote.

@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

fonte
Isso é muito útil!
robe007
3

insira a descrição da imagem aqui

Para usar looping para obter todos os argumentos e em lote puro:

Obs: Para uso sem:?*&<>


@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 

Seu código está pronto para fazer algo com o número do argumento onde ele precisa, como ...

@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
Não era eu
fonte
2

O código a seguir simula uma matriz (' params') - pega os parâmetros recebidos pelo script e os armazena nas variáveis params_1.. params_n, onde n= params_0= o número de elementos da matriz:

@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

fonte
1

Se você tiver parâmetros entre aspas que contenham espaços, %*não funcionará corretamente. A melhor solução que encontrei é ter um loop que une todos os argumentos: 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)
Speedstone
fonte
1

Você pode usar o ForCommad, para obter a lista de Arg.

Ajuda: For /? Ajuda:Setlocal /?

Aqui está o meu caminho =

@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

Não precisa do comando Shift.

scientist_7
fonte
0
@echo off
:começar

:: Insira seu código aqui
echo. %% 1 está agora:% ~ 1
:: Fim insira seu código aqui

se "% ~ 2" NEQ "" (
    mudança
    goto: start
)
user298107
fonte
0

Muitas das informações acima me levaram a mais pesquisas e, finalmente, a minha resposta, então eu queria contribuir com o que acabei fazendo, na esperança de ajudar outras pessoas:

  • Eu também queria passar um número variado de variáveis ​​para um arquivo em lotes para que elas pudessem ser processadas dentro do arquivo.

  • Eu estava bem em passá-los para o arquivo em lotes usando aspas

  • Gostaria que eles fossem processados ​​de maneira semelhante à abaixo - mas usando um loop em vez de escrever manualmente:

Então, eu queria executar isso:

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

E, através da mágica dos loops for, faça isso no arquivo em lotes:

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

O problema que eu estava tendo é que todas as minhas tentativas de usar um loop for não estavam funcionando. O exemplo abaixo:

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

faria apenas:

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

e não:

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

mesmo após a configuração

SETLOCAL EnableDelayedExpansion

O motivo foi que o loop for leu toda a linha e atribuiu meu segundo parâmetro a %% B durante a primeira iteração do loop. Como% * representa todos os argumentos, existe apenas uma linha para processar - portanto, apenas uma passagem do loop for acontece. Isso ocorre por design e minha lógica estava errada.

Então parei de tentar usar um loop for e simplifiquei o que estava tentando fazer usando if, shift e uma instrução goto. Concordou que é um pouco complicado, mas é mais adequado às minhas necessidades. Posso percorrer todos os argumentos e usar uma instrução if para sair do loop depois de processá-los todos.

A declaração vencedora do que eu estava tentando realizar:

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

UPDATE - Eu tive que modificar para o abaixo, em vez disso, estava expondo todas as variáveis ​​de ambiente ao tentar fazer referência a% 1 e usar o shift dessa maneira:

echo on
shift
:processArguments
:: Process all arguments in the order received
if defined %0 then (
    set %0
    shift
    goto:processArguments
) ELSE (
    echo off 
)
John Ahearn
fonte
Estou errado, fiz mais algumas checagens e após a 3ª iteração, meu comando shift expõe todas as variáveis ​​de ambiente, o que interrompe o exposto acima. Ainda estou investigando se há uma maneira de contornar isso.
precisa
Tive que fazer uma modificação, em vez de usar% 1, tive que mudar uma vez inicialmente e usar% 0, ou então tive um problema estranho, onde% 1 continha todas as variáveis ​​de ambiente atuais.
John Ahearn 30/03
0

Às vezes, preciso extrair vários parâmetros de linha de comando, mas nem todos eles e não do primeiro. Vamos assumir a seguinte chamada:

Test.bat uno dos tres cuatro cinco seis siete

Obviamente, a extensão ".bat" não é necessária, pelo menos você tem o test.exe na mesma pasta. O que queremos é obter a saída "tres cuatro cinco" (não importa se uma linha ou três). O objetivo é que apenas eu precise de três parâmetros e comece no terceiro. Para ter um exemplo simples, a ação de cada uma é apenas "eco", mas você pode pensar em outra ação mais complexa sobre os parâmetros selecionados.

Eu produzi alguns exemplos (opções) para que você possa ver qual deles considera melhor para você. Infelizmente, não existe uma maneira agradável (ou não sei) baseada em um loop for acima do intervalo, como "para %% 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

Provavelmente você pode encontrar mais opções ou combinar várias. Aproveite-os.

Fortu
fonte
-1

Versão do Windows (embora seja necessária)

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

configurando:

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