बैच स्क्रिप्ट लूप

Question

मुझे 100-200 बार एक कमांड निष्पादित करने की आवश्यकता है, और अब तक मेरे शोध से संकेत मिलता है कि मुझे या तो इस कमांड की 100 प्रतियां कॉपी / पेस्ट करनी होंगी, या एक forलूप का उपयोग करना होगा , लेकिन forलूप को आइटम की एक सूची की उम्मीद है, इसलिए मुझे इसकी आवश्यकता होगी बिंदु को पराजित करने के लिए 200 फाइलें, या 200 वस्तुओं की एक सूची को संचालित करने के लिए।

मुझे इसके बजाय C प्रोग्राम लिखना नहीं होगा और दस्तावेज़ीकरण की अवधि के माध्यम से जाना होगा कि मुझे परीक्षण प्रयोजनों के लिए अपने कार्यक्रम को निष्पादित करने के लिए एक और कार्यक्रम क्यों लिखना पड़ा। मेरे कार्यक्रम का संशोधन भी एक विकल्प नहीं है।

इसलिए, एक कमांड दिया गया है, aमैं इसे Nएक बैच स्क्रिप्ट के माध्यम से कैसे निष्पादित करूंगा ?

नोट: मुझे एक अनंत लूप नहीं चाहिए

उदाहरण के लिए, जावास्क्रिप्ट में यह कैसा दिखेगा:

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

यह विंडोज पर चलने वाली एक बैच स्क्रिप्ट में कैसा दिखेगा?

Comments

ss64.com/nt/for.html

— इमान

Answer 1

for /l आपका दोस्त है:

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

1 से शुरू होता है, एक से कदम, और 100 पर समाप्त होता है।

%यदि यह एक बैच फ़ाइल में दो s का उपयोग करें

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

(जो चीजों में से एक है जो मैं वास्तव में विंडोज़ स्क्रिप्टिंग के बारे में नफरत करता हूं)

यदि आपके पास लूप के प्रत्येक पुनरावृत्ति के लिए कई कमांड हैं, तो यह करें:

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

या एक बैच फ़ाइल में

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

कुंजी:
/lयह दर्शाता है कि forकमांड संख्यात्मक रूप से संचालित होगी, फाइलों के एक सेट पर काम करने के बजाय
%xलूप्स चर है
(मूल्य शुरू, मूल्य में वृद्धि, अंतिम स्थिति [समावेशी])

Comments

यह इस बात पर निर्भर करता है कि हम "डॉस" संदर्भ को कितनी गंभीरता से लेते हैं। MS-DOS, 7.1 का नवीनतम संस्करण, 1997 से पहले का है और AFAIK में ये एक्सटेंशन नहीं हैं। दूसरी ओर, विंडोज के साथ कमांड शेल वितरित किए गए हैं।

— कार्ल स्मोत्रिकज़

@Imray %xलूप वैरिएबल है, /l(नहीं \l) का मतलब है कि कमांड के लिए फाइलों के सेट पर काम करने के बजाय संख्यात्मक फैशन में काम करेंगे।

— जॉन

दौड़ने से for /l %x in (1, 1, 100) do echo %xमुझे "x अपेक्षित नहीं है" मिलता है।

— लाब्राका

@ user193655 शेष उत्तर पढ़ें, यदि आप एक बैच फ़ाइल में ऐसा कर रहे हैं, तो आपको% s को दोगुना करने की आवश्यकता है।

— जॉन

अंतिम लूप में% x %% x होना चाहिए।

— वाइल्डपॉइंटर्स

Answer 2

और निर्देशिका की फ़ाइलों पर पुनरावृति करने के लिए:

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

आपको "enableDelayedExpansion" और FILENAME का उपयोग करना होगा! $ FILENAME $ के बजाय। दूसरे मामले में, डीओएस केवल एक बार चर की व्याख्या करेगा (इससे पहले कि यह लूप में प्रवेश करता है) और प्रत्येक बार प्रोग्राम लूप नहीं।

Comments

इसे पोस्ट करने के लिए धन्यवाद - मुझे पता है कि यह वह नहीं है जो ओपी पूछ रहा था, लेकिन यह वही है जो मैं यहां समाप्त होने पर खोज रहा था।

— BrainSlugs83

Answer 3

सरल लेकिन गिने हुए लूप के लिए टेम्प्लेट:

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

उदाहरण: कहो "हैलो वर्ल्ड!" 5 बार:

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

यह उदाहरण आउटपुट करेगा:

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

Comments

यह एकमात्र पाश कोड है जो मैं अपने win7 पीसी पर उपयोग करने में सक्षम था। Googleing द्वारा पाए गए अन्य सभी काम नहीं करते हैं।

— लाब्राका

आपके उदाहरण में, मैं जोड़ूंगा set /p loopcount="How many loops? "ताकि आप इसे उपयोगकर्ता इनपुट के साथ चला सकें। यह अधिक व्यावहारिक है।

— 1934286

Answer 4

आप forलूप के बजाय इसे भी आज़मा सकते हैं :

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

यह काफी छोटा है और यह वही है जो मैं हर समय उपयोग करता हूं।

Comments

यह मूल रूप से मार्कस कलेवर के उत्तर के समान है । कृपया ऐसे उत्तर न दें जो कुछ नया न जोड़ें। धन्यवाद!

— फैबियो का कहना है कि

Ups sry ने यह नहीं देखा कि, बस उसे फेंक दिया और बस छोरों के लिए देखा ... Im क्षमा करें फिर :)

— BlazeLP

Answer 5

या आप लूप करना चाहते हैं की संख्या से एक चर को घटा / बढ़ा सकते हैं:

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

जाहिर है, का उपयोग FOR /Lकरना राजमार्ग है और यह बैकस्ट्रीट है जिसमें अधिक समय लगता है, लेकिन यह एक ही गंतव्य तक पहुंचता है।

Answer 6

आप फ़ॉर लूप से बचने के लिए निम्नलिखित प्रभाव के लिए कुछ कर सकते हैं।

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

Answer 7

आप यह एक forबयान के बिना कर सकते हैं ^ ^।)

@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

इसकी बुनियादी समझ है। बस इसे एक परीक्षा दें। : पी

Comments

आपको यहां विलंबित विस्तार की आवश्यकता नहीं है।

— स्टीफन

Answer 8

लेबल का उपयोग करके cmd प्रोग्रामिंग में लूपिंग को लागू करने का बहुत ही मूल तरीका है

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

Answer 9

डॉस इसके लिए बहुत ही सुरुचिपूर्ण तंत्र प्रदान नहीं करता है, लेकिन मुझे लगता है कि आप अभी भी उचित प्रयास के साथ 100 या 200 पुनरावृत्तियों के लिए एक लूप कोड कर सकते हैं। जबकि एक संख्यात्मक forलूप नहीं है , आप "लूप वेरिएबल" के रूप में एक वर्ण स्ट्रिंग का उपयोग कर सकते हैं।

GOTO का उपयोग करके लूप को कोड करें, और प्रत्येक पुनरावृत्ति के लिए एक पर्यावरण चर X पर एक SET X=%X%@और @संकेत जोड़ने के लिए उपयोग करें; और लूप से बाहर निकलने के लिए, X के मान की तुलना 100 (या 200) @संकेतों की एक स्ट्रिंग के साथ करें ।

मैंने कभी नहीं कहा कि यह सुरुचिपूर्ण था, लेकिन यह काम करना चाहिए!

Comments

कमांड का /aविकल्प SETसही साइड वैल्यू के लिए संख्यात्मक अभिव्यक्ति का मूल्यांकन करेगा। SET के लिए डॉक्यूमेंटेशन देखें । यह जरूरी नहीं है कि कॉन्टेक्शन ट्रिक करें।

— एडम पोराड

डॉस के लिए, यह है आवश्यक, के रूप में वहाँ कोई है set /aडॉस में। सौभाग्य से क़िले दहन के लिए है cmd... (इस उत्तर के समय, प्रश्न का शीर्षक "डॉस बैच स्क्रिप्ट लूप" था

— स्टीफ़न

Answer 10

यकीन नहीं होता कि इस तरह का उत्तर पहले ही प्रस्तुत किया जा चुका है, लेकिन आप कुछ इस तरह की कोशिश कर सकते हैं:

@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

चर% var% एक तक बढ़ जाएगा जब तक कि यह 100 तक नहीं पहुंच जाता है जहां कार्यक्रम तब आउटपुट करता है कि इसे निष्पादित करना समाप्त हो गया है। फिर से, सुनिश्चित नहीं है कि यह प्रस्तुत किया गया है या ऐसा कुछ है, लेकिन मुझे लगता है कि यह सबसे कॉम्पैक्ट हो सकता है।

Answer 11

मैं इसका उपयोग करता हूं। यह सिर्फ दूसरों के समान ही है, लेकिन इसे लिखने का एक और तरीका है।

@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

Answer 12

उत्तर वास्तव में इस बात पर निर्भर करता है कि आप बैच से कितने परिचित हैं, यदि आप इतने अनुभवी नहीं हैं, तो मैं एक लूप वेरिएबल को बढ़ाने की सलाह दूंगा:

@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

लेकिन अगर आप बैच के साथ अधिक अनुभवी हैं, तो मैं सुझाव दूंगा कि अधिक व्यावहारिक for /l %loop in (1, 1, 10) do echo %loopबेहतर विकल्प है।

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

Answer 13

यहां एक टेम्पलेट स्क्रिप्ट है जिसका मैं उपयोग करूंगा।

@echo off
goto Loop

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

exit

यह क्या करता है जब यह शुरू होता है तो यह प्रतिध्वनित हो जाता है फिर इसके बाद यह "लूप" चलाता है लेकिन उस स्थान पर यह "लूप" तक जाता रहता है (मुझे आशा है कि यह मदद करता है।)

Answer 14

एक पूरी तरह से निर्दोष पाश

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

आप लूप में कितने समय तक यह दर्शाने के लिए किसी भी संख्या में 10 को पंक्ति 5 में बदलकर संपादित कर सकते हैं।

Answer 15

(संपादित) मैंने इसे बनाया है इसलिए यह 100 बार के बाद बंद हो जाता है

@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

यह 4 यादृच्छिक संख्याओं को 1 सेकंड 100 बार उत्पन्न करेगा। सुपर फास्ट जाने के लिए "टाइमआउट 1 / नोब्रे> नुल" को बाहर निकालें।

Comments

सवाल "100 - 200 बार" था, "अंतहीन लूप" नहीं।

— Stephan

Answer 16

शायद विश्व स्तर पर गोटो की तरह उपयोग करें

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

यह एक अनंत (अनंत) लूप करता है।

Comments

ठीक है, infiniteयह अनुरोध के मुकाबले काफी बड़ा है 100-200 times, इसलिए यह सवाल का जवाब नहीं देता है।

— Stephan

वास्तव में, मैं एक निर्धारित संख्या को लूप करने में सक्षम होना चाहता था इसलिए मुझे एक कमांड को बार-बार कॉपी करने की जरूरत नहीं होगी

— टॉम जे नोवेल

Answer 17

मेरे पास 2 उत्तर हैं विधि 1: जावास्क्रिप्ट को बैच में डालें

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

:: batch portion

@ECHO OFF

cscript /e:jscript "%~f0"


:: JScript portion */

Input Javascript here

(मुझे जावास्क्रिप्ट के बारे में ज्यादा जानकारी नहीं है)

विधि 2: बैच में लूप

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

(साभार फ्लोरेसेंटग्रीन 5)

Comments

हम योगदान देने के आपके प्रयास की सराहना करते हैं, लेकिन एक पांच साल पुराने उत्तर को दोहराते हुए बहुत मदद नहीं मिलती है और सिर्फ शोर बढ़ता है।

— चरण सिंह