Bucle de secuencia de comandos por lotes

Necesito ejecutar un comando 100-200 veces, y hasta ahora mi investigación indica que tendría que copiar / pegar 100 copias de este comando, O usar un forbucle, pero el forbucle espera una lista de elementos, por lo tanto, necesitaría 200 archivos para operar, o una lista de 200 elementos, derrotando el punto.

Preferiría no tener que escribir un programa en C y documentar por qué tuve que escribir otro programa para ejecutar mi programa con fines de prueba. La modificación de mi programa en sí tampoco es una opción.

Entonces, dado un comando, a¿cómo lo ejecutaría Nveces a través de un script por lotes?

Nota: no quiero un bucle infinito

Por ejemplo, así es como se vería en Javascript:

var i;
for (i = 0; i < 100; i++) {
  console.log( i );
} 

¿Cómo se vería en un script por lotes que se ejecuta en Windows?

for /l es tu amigo:

for /l %x in (1, 1, 100) do echo %x

Comienza en 1, pasos por uno y termina en 100.

Use dos %s si está en un archivo por lotes

for /l %%x in (1, 1, 100) do echo %%x

(que es una de las cosas que realmente odio de las secuencias de comandos de Windows)

Si tiene varios comandos para cada iteración del bucle, haga esto:

for /l %x in (1, 1, 100) do (
   echo %x
   copy %x.txt z:\whatever\etc
)

o en un archivo por lotes

for /l %%x in (1, 1, 100) do (
   echo %%x
   copy %%x.txt z:\whatever\etc
)

Clave:
/ldenota que el forcomando operará de manera numérica, en lugar de operar en un conjunto de archivos
%xes la variable de bucles
(valor inicial, incremento de valor, condición final [inclusive])

Y para iterar sobre los archivos de un directorio:

@echo off 
setlocal enableDelayedExpansion 

set MYDIR=C:\something
for /F %%x in ('dir /B/D %MYDIR%') do (
  set FILENAME=%MYDIR%\%%x\log\IL_ERROR.log
  echo ===========================  Search in !FILENAME! ===========================
  c:\utils\grep motiv !FILENAME!
)

Debe usar "enableDelayedExpansion" y! FILENAME! en lugar de $ FILENAME $. En el segundo caso, DOS interpretará la variable solo una vez (antes de que ingrese al bucle) y no cada vez que el programa se repita.

Plantilla para un bucle simple pero contado:

set loopcount=[Number of times]
:loop
[Commands you want to repeat]
set /a loopcount=loopcount-1
if %loopcount%==0 goto exitloop
goto loop
:exitloop

Ejemplo: di "¡Hola mundo!" 5 veces:

@echo off
set loopcount=5
:loop
echo Hello World!
set /a loopcount=loopcount-1
if %loopcount%==0 goto exitloop
goto loop
:exitloop
pause

Este ejemplo generará:

Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Press any key to continue . . .

También puedes probar esto en lugar de un forbucle:

set count=0
:loop
set /a count=%count%+1
(Commands here)
if %count% neq 100 goto loop
(Commands after loop)

Es bastante pequeño y es lo que uso todo el tiempo.

O puede disminuir / incrementar una variable por la cantidad de veces que desea realizar un bucle:

SETLOCAL ENABLEDELAYEDEXPANSION
SET counter=200
:Beginning
IF %counter% NEQ 0 (
echo %x
copy %x.txt z:\whatever\etc
SET /A counter=%counter%-1
GOTO Beginning
) ELSE (
ENDLOCAL
SET counter=
GOTO:eof

Obviamente, usar FOR /Les la carretera y esta es la calle secundaria que lleva más tiempo, pero llega al mismo destino.

Podría hacer algo para el siguiente efecto evitando el bucle FOR.

set counter=0
:loop
echo "input commands here"
SET /A counter=%counter%+1
if %counter% GTR 200
(GOTO exit) else (GOTO loop)
:exit
exit

Puede hacer esto sin una fordeclaración ^. ^:

@echo off
:SPINNER
SET COUNTP1=1

:1
CLS
 :: YOUR COMMAND GOES HERE
IF !COUNTP1! EQU 200 goto 2

SET COUNTP1=1
) ELSE (
SET /A COUNTP1+=1
)
goto 1

:2
:: COMMAND HAS FINISHED RUNNING 200 TIMES

Tiene comprensión básica. Solo pruébalo. :PAGS

Forma muy básica de implementar bucles en la programación de cmd usando etiquetas

@echo off
SET /A "index=1"
SET /A "count=5"
:while
if %index% leq %count% (
   echo The value of index is %index%
   SET /A "index=index + 1"
   goto :while
)

DOS no ofrece mecanismos muy elegantes para esto, pero creo que aún puede codificar un ciclo para 100 o 200 iteraciones con un esfuerzo razonable. Si bien no hay un forbucle numérico , puede usar una cadena de caracteres como una "variable de bucle".

Codifique el bucle usando GOTO, y para cada iteración use SET X=%X%@agregar otro @signo a una variable de entorno X; y para salir del bucle, compare el valor de X con una cadena de 100 (o 200) @signos.

Nunca dije que esto fuera elegante, ¡pero debería funcionar!

No estoy seguro si ya se ha enviado una respuesta como esta, pero podría intentar algo como esto:

@echo off
:start
set /a var+=1
if %var% EQU 100 goto end
:: Code you want to run goes here
goto start

:end
echo var has reached %var%.
pause
exit

La variable% var% aumentará en uno hasta llegar a 100, donde el programa muestra que ha terminado de ejecutarse. Una vez más, no estoy seguro de si esto se ha enviado o algo así, pero creo que puede ser el más compacto.

Yo uso esto. Es casi lo mismo que los demás, pero es solo otra forma de escribirlo.

@ECHO off
set count=0
:Loop
if %count%==[how many times to loop] goto end
::[Commands to execute here]
set count=%count%+1
goto Loop
:end

La respuesta realmente depende de qué tan familiarizado esté con el lote; si no tiene tanta experiencia, recomendaría incrementar una variable de bucle:

@echo off
set /a loop=1
:repeat
echo Hello World!
set /a loop=%loop%+1
if %loop%==<no. of times to repeat> (
goto escapedfromrepeat
)
goto repeat
:escapedfromrepeat
echo You have come out of the loop
pause

Pero si tiene más experiencia con el lote, le recomendaría que lo más práctico for /l %loop in (1, 1, 10) do echo %loopsea ​​la mejor opción.

             (start at 1, go up in 1's, end at 10)
for /l %[your choice] (start, step, end) do [command of your choice]

Aquí hay un script de plantilla que usaré.

@echo off
goto Loop

:Loop
<EXTRA SCRIPTING HERE!!!!>
goto Loop

exit

Lo que esto hace es cuando comienza, apaga el eco y luego ejecuta el "Loop", pero en ese lugar sigue yendo a "Loop" (espero que esto ayude).

un circuito completamente perfecto

set num=0
:loop
:: insert code
set num=%num%+1
if %num% neq 10 goto loop
::insert after code code

puede editarlo cambiando el 10 en la línea 5 a cualquier número para representar cuántas veces desea que se repita.

(EDITADO) Lo hice para que se detenga después de 100 veces

@echo off
goto actual
set /a loopcount=0
:actual
set /a loopcount=%loopcount% + 1
echo %random% %random% %random% %random%
timeout 1 /nobreak>nul
if %loopcount%== 100 goto stop
goto actual
:stop
exit

Esto generará 4 números aleatorios cada 1 segundo 100 veces. Elimina el "tiempo de espera 1 / nobreak> nul" para que sea súper rápido

Probablemente use goto like

@echo off
:Whatever
echo hello world
pause
echo TEST
goto Whatever

Esto hace un bucle inf (infinito).

Tengo 2 respuestas Métodos 1: Insertar Javascript en Batch

@if (@a==@b) @end /*

:: batch portion

@ECHO OFF

cscript /e:jscript "%~f0"


:: JScript portion */

Input Javascript here

(No sé mucho sobre JavaScript)

Método 2: bucle en lote

   @echo off
    set loopcount=5
    :loop
    echo Hello World!
    set /a loopcount=loopcount-1
    if %loopcount%==0 goto exitloop
    goto loop
    :exitloop
    pause

(Gracias FluorescentGreen5)