Batch-Skriptschleife

Ich muss einen Befehl 100-200 Mal ausführen, und meine Forschung hat bisher ergeben, dass ich entweder 100 Kopien dieses Befehls kopieren / einfügen oder eine forSchleife verwenden formüsste , aber die Schleife erwartet eine Liste von Elementen, daher würde ich benötigen 200 zu bearbeitende Dateien oder eine Liste mit 200 Elementen, die den Punkt zunichte machen.

Ich würde lieber kein C-Programm schreiben und die Länge der Dokumentation durchgehen müssen, warum ich ein anderes Programm schreiben musste, um mein Programm zu Testzwecken auszuführen. Eine Änderung meines Programms selbst ist ebenfalls keine Option.

aWie würde ich einen Befehl bei einem Befehl Nüber ein Batch-Skript ausführen ?

Hinweis: Ich möchte keine Endlosschleife

Hier ist zum Beispiel, wie es in Javascript aussehen würde:

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

Wie würde es in einem Batch-Skript unter Windows aussehen?

for /l ist dein Freund:

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

Beginnt bei 1, Schritt für Schritt und endet bei 100.

Verwenden Sie zwei %s, wenn es sich um eine Batch-Datei handelt

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

(Das ist eines der Dinge, die ich an Windows-Skripten wirklich sehr hasse.)

Wenn Sie für jede Iteration der Schleife mehrere Befehle haben, gehen Sie folgendermaßen vor:

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

oder in einer Batch-Datei

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

Schlüssel:
/lbedeutet, dass der forBefehl numerisch ausgeführt wird, anstatt eine Reihe von Dateien zu
%xbearbeiten. Dies ist die Schleifenvariable
(Startwert, Wertinkrement, Endbedingung [einschließlich]).

Und um die Dateien eines Verzeichnisses zu durchlaufen:

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

Sie müssen "enableDelayedExpansion" und! FILENAME! anstelle von $ FILENAME $. Im zweiten Fall interpretiert DOS die Variable nur einmal (bevor sie in die Schleife eintritt) und nicht jedes Mal, wenn sich das Programm wiederholt.

Vorlage für eine einfache, aber gezählte Schleife:

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

Beispiel: Sagen Sie "Hallo Welt!" 5 mal:

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

In diesem Beispiel wird Folgendes ausgegeben:

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

Sie können dies auch anstelle einer forSchleife versuchen :

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

Es ist ziemlich klein und ich benutze es die ganze Zeit.

Oder Sie können eine Variable um die Anzahl der Schleifen dekrementieren / inkrementieren:

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

Die Nutzung FOR /List natürlich die Autobahn und dies ist die Seitenstraße, die länger dauert, aber zum selben Ziel führt.

Sie können Folgendes tun, um die FOR-Schleife zu vermeiden.

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

Sie können dies ohne forAussage tun ^. ^:

@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

Es hat Grundverständnis. Probieren Sie es einfach aus. : P.

Sehr einfache Methode zum Implementieren von Schleifen in der Cmd-Programmierung mithilfe von Labels

@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 bietet hierfür keine sehr eleganten Mechanismen, aber ich denke, Sie können mit angemessenem Aufwand immer noch eine Schleife für 100 oder 200 Iterationen codieren. Obwohl es keine numerische forSchleife gibt, können Sie eine Zeichenfolge als "Schleifenvariable" verwenden.

Codieren Sie die Schleife mit GOTO und SET X=%X%@fügen Sie für jede Iteration ein weiteres @Vorzeichen zu einer Umgebungsvariablen X hinzu. und um die Schleife zu verlassen, vergleichen Sie den Wert von X mit einer Zeichenfolge aus 100 (oder 200) @Zeichen.

Ich habe nie gesagt, dass dies elegant ist, aber es sollte funktionieren!

Ich bin mir nicht sicher, ob eine solche Antwort bereits eingereicht wurde, aber Sie könnten Folgendes versuchen:

@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

Die Variable% var% erhöht sich um eins, bis sie 100 erreicht, wo das Programm dann ausgibt, dass die Ausführung beendet ist. Auch hier bin ich mir nicht sicher, ob dies eingereicht wurde oder so, aber ich denke, es ist möglicherweise das kompakteste.

Ich benutze das. Es ist ungefähr dasselbe wie die anderen, aber es ist nur eine andere Art, es zu schreiben.

@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

Die Antwort hängt wirklich davon ab, wie gut Sie mit Batch vertraut sind. Wenn Sie nicht so erfahren sind, würde ich empfehlen, eine Schleifenvariable zu erhöhen:

@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

Wenn Sie jedoch mehr Erfahrung mit Chargen haben, würde ich empfehlen, je praktischer for /l %loop in (1, 1, 10) do echo %loopdie bessere Wahl ist.

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

Hier ist ein Vorlagenskript, das ich verwenden werde.

@echo off
goto Loop

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

exit

Wenn es startet, schaltet es das Echo aus und danach läuft die "Schleife", aber an dieser Stelle geht es weiter zur "Schleife" (ich hoffe, das hilft.)

eine völlig fehlerfreie Schleife

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

Sie können es bearbeiten, indem Sie die 10 in Zeile 5 in eine beliebige Zahl ändern, um anzugeben, wie oft die Schleife ausgeführt werden soll.

(BEARBEITET) Ich habe es so gemacht, dass es nach 100 Mal aufhört

@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

Dies erzeugt 4 Zufallszahlen pro 1 Sekunde 100 Mal. Nehmen Sie das "Timeout 1 / nobreak> nul" heraus, damit es super schnell geht.

Verwenden Sie wahrscheinlich goto like

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

Dies macht eine inf (Endlosschleife).

Ich habe 2 Antworten Methoden 1: Fügen Sie Javascript in Batch ein

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

:: batch portion

@ECHO OFF

cscript /e:jscript "%~f0"


:: JScript portion */

Input Javascript here

(Ich weiß nicht viel über JavaScript)

Methode 2: Schleife im Stapel

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

(Danke FluorescentGreen5)