लूप करते समय करें

जबकि लूप प्रवाह आरेख करें

अधिकांश कंप्यूटर प्रोग्रामिंग लैंग्वेज में डू घुमाव के दौरान एक बहाव को काबू करें बयान (कंप्यूटर विज्ञान) है जो कोड के एक ब्लॉक को निष्पादित करता है और फिर या तो ब्लॉक को दोहराता है या किसी दिए गए बूलियन डेटा प्रकार की स्थिति के आधार पर लूप से बाहर निकलता है।

'डू व्हाइल' कंस्ट्रक्शन में एक प्रोसेस सिंबल और एक कंडीशन होती है। पहले ब्लॉक के भीतर कोड निष्पादित किया जाता है। फिर स्थिति का मूल्यांकन किया जाता है। यदि कंडीशन ट्रूथ है तो ब्लॉक के भीतर कोड को फिर से निष्पादित किया जाता है। यह तब तक दोहराता है जब तक स्थिति झूठी (तर्क) नहीं बन जाती।

जब लूप कोड के ब्लॉक के निष्पादित होने के बाद स्थिति की जांच करें। इस नियंत्रण संरचना को पोस्ट-टेस्ट लूप के रूप में जाना जा सकता है। इसका मतलब है कि do-जबकि लूप एक्जिट-कंडीशन लूप है। हालाँकि थोड़ी देर का लूप ब्लॉक के भीतर कोड निष्पादित होने से पहले स्थिति का परीक्षण करेगा।

इसका मतलब यह है कि कोड को हमेशा पहले निष्पादित किया जाता है और फिर अभिव्यक्ति या परीक्षण की स्थिति का मूल्यांकन किया जाता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक अभिव्यक्ति सत्य का मूल्यांकन करती है। यदि अभिव्यक्ति गलत है तो लूप समाप्त हो जाता है। कोड के निष्पादन के लिए आवश्यक स्थिति के रूप में थोड़ी देर लूप एक बयान की सच्चाई सेट करता है। एक डू-जबकि लूप क्रिया के चल रहे निष्पादन के लिए प्रदान करता है जब तक कि स्थिति अब सत्य नहीं है।

स्थिति का हमेशा सत्य होना मूल्यांकन करना संभव है और कभी-कभी वांछनीय है। यह एक अनंत लूप बनाता है। जब एक अनंत लूप जानबूझकर बनाया जाता है तो आमतौर पर एक अन्य नियंत्रण संरचना होती है जो लूप को समाप्त करने की अनुमति देती है। उदाहरण के लिए एक नियंत्रण प्रवाह # छोरों से जल्दी बाहर निकलने से एक अनंत लूप की समाप्ति हो जाएगी।

कुछ भाषाएँ इस प्रकार के लूप के लिए भिन्न नामकरण परिपाटी का उपयोग कर सकती हैं। उदाहरण के लिए, पास्कल प्रोग्रामिंग भाषा और लुआ (प्रोग्रामिंग भाषा) लैंग्वेज में एक रिपीट टिल लूप होता है, जो कंट्रोल एक्सप्रेशन ट्रू होने तक ' चलता रहता है और फिर समाप्त हो जाता है। इसके विपरीत थोड़ी देर लूप चलता है जबकि नियंत्रण अभिव्यक्ति सत्य है और अभिव्यक्ति झूठी हो जाने पर समाप्त हो जाती है।

समकक्ष निर्माण

do {
    do_work();  
} while (condition);

के बराबर है

do_work();

while (condition) {
    do_work();
}

इस तरीके से, do ... while लूप प्रारंभिक लूप प्राइमिंग को बचाता है do_work(); लाइन से पहले while कुंडली।

जब तक जारी बयान का उपयोग नहीं किया जाता है, तब तक उपरोक्त तकनीकी रूप से निम्नलिखित के बराबर है (हालांकि ये उदाहरण रोजमर्रा के कंप्यूटरों में उपयोग की जाने वाली विशिष्ट या आधुनिक शैली नहीं हैं):

while (true) {
   do_work();
   if (!condition) break;
}

या

LOOPSTART:
    do_work();
    if (condition) goto LOOPSTART;

लूप करते समय प्रदर्शन करना

ये उदाहरण प्रोग्राम डू-वाइल लूप के लिए अपनी संबंधित भाषाओं के सिंटैक्स का उपयोग करके 5 के कारख़ाने का की गणना करते हैं।

ActionScript

var counter: int = 5;
var factorial: int = 1;

do {
    factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);

trace(factorial);

अदा (प्रोग्रामिंग भाषा)

with Ada.Integer_Text_IO;

procedure Factorial is
    Counter   : Integer := 5;
    Factorial : Integer := 1;
begin
    loop
        Factorial := Factorial * Counter;
        Counter   := Counter - 1;
        exit when Counter = 0;
    end loop;

    Ada.Integer_Text_IO.Put (Factorial);
end Factorial;

बेसिक

शुरुआती बेसिक्स (जैसे GW-BASIC) ने WHILE/WEND सिंटैक्स का इस्तेमाल किया। PowerBASIC जैसे आधुनिक बेसिक, WHILE/WEND और DO/LOOP दोनों संरचनाएँ प्रदान करते हैं, जैसे कि DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP UNTIL, और DO/LOOP (बाहरी परीक्षण के बिना, लेकिन लूप के अंदर कहीं एक सशर्त निकास लूप के साथ)। विशिष्ट बुनियादी स्रोत कोड:

Dim factorial As Integer
Dim counter As Integer

factorial = 1
counter = 5

Do 
    factorial = factorial * counter
    counter = counter - 1
Loop While counter > 0

Print factorial

सी शार्प (प्रोग्रामिंग भाषा)|सी#

int counter = 5;
int factorial = 1;

do
{
    factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);

System.Console.WriteLine(factorial);

सी (प्रोग्रामिंग भाषा)

int counter = 5;
int factorial = 1;

do {
    factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);

printf("factorial of 5 is %d\n", factorial);

डू-वाइल (0) स्टेटमेंट्स का उपयोग आमतौर पर सी मैक्रोज़ में कई स्टेटमेंट्स को नियमित (कंपाउंड के विपरीत) स्टेटमेंट में लपेटने के तरीके के रूप में किया जाता है। यह मैक्रो के बाद आवश्यक अर्धविराम बनाता है, सरल पार्सर और प्रोग्रामर के साथ-साथ स्कोपिंग समस्या से बचने के लिए अधिक फ़ंक्शन-जैसी उपस्थिति प्रदान करता है if. CERT C कोडिंग मानक नियम PRE10-C में इसकी सिफारिश की गई है।

सी ++

int counter = 5;
int factorial = 1;

do {
    factorial *= counter--;
} while (counter > 0);

std::cout << "factorial of 5 is "<< factorial << std::endl;

सीएफस्क्रिप्ट

factorial = 1;
count = 10;

do {
    factorial *= count--;
} while (count > 1);

writeOutput(factorial);

डी (प्रोग्रामिंग भाषा)

int counter = 5;
int factorial = 1;

do {
    factorial *= counter--; // Multiply, then decrement.
} while (counter > 0);

writeln("factorial of 5 is ", factorial);

फोरट्रान

लीगेसी फोरट्रान 77 के साथ कोई DO-WHILE कंस्ट्रक्शन नहीं है, लेकिन GOTO के साथ समान प्रभाव प्राप्त किया जा सकता है:

      INTEGER CNT,FACT
      CNT=5
      FACT=1
    1 CONTINUE
      FACT=FACT*CNT
      CNT=CNT-1
      IF (CNT.GT.0) GOTO 1
      PRINT*,FACT
      END

फोरट्रान 90 और बाद में कोई डू-जबकि निर्माण नहीं होता है, लेकिन इसमें एक while_loop#Fortran निर्माण होता है जो कीवर्ड do while का उपयोग करता है और इस प्रकार यह वास्तव में for लूप के समान है।

program FactorialProg
    integer :: counter = 5
    integer :: factorial = 1
    
    factorial = factorial * counter
    counter = counter - 1
    
    do while (counter > 0) ! Truth value is tested before the loop
        factorial = factorial * counter
        counter = counter - 1
    end do
    
    print *, factorial
end program FactorialProg

जावा (प्रोग्रामिंग भाषा)

इंट काउंटर = 5;
इंट फैक्टोरियल = 1;

करना {
    फैक्टोरियल * = काउंटर--; /* गुणा करें, फिर घटाएं। */
} जबकि (काउंटर> 0);

System.out.println (5 का फैक्टोरियल + फैक्टोरियल है);

//

=== [[जावास्क्रिप्ट]] ===
<syntaxhighlight lang="javascript">
let counter = 5; // Declaring two variables, counter and factorial 
let factorial = 1; 

do {
    factorial *= counter--; //What will be looped
} while (counter > 0); //The looping conditions

console.log(factorial); //Showing the result

कोटलिन (प्रोग्रामिंग भाषा)

var counter = 5
var factorial = 1
//These line of code is almost the same as the above JavaScript codes, the only difference is the keyword that shows the results
do {
    factorial *= counter--
} while (counter > 0)

println("Factorial of 5 is $factorial")

पास्कल (प्रोग्रामिंग भाषा)

पास्कल (प्रोग्रामिंग भाषा) में कोई कार्य/समय नहीं है; इसके बजाय, यह एक दोहराना/तक है। जैसा कि परिचय में उल्लेख किया गया है, एक 'डू कोड जबकि नॉट एक्सप्रेशन' निर्माण के बराबर होने के लिए एक दोहराने पर विचार कर सकता है।

factorial := 1;
counter := 5;
repeat
   factorial := factorial * counter;
   counter := counter - 1; // In Object Pascal one may use dec (counter);
until counter = 0;

पीएचपी

$counter = 5;
$factorial = 1;

do {
    $factorial *= $counter--;
} while ($counter > 0);

echo $factorial;

पीएल/आई

पीएल/आई डीओ स्टेटमेंट पोस्ट-टेस्ट लूप (तब तक करें), प्री-टेस्ट लूप (डू व्हाइल), और फॉर लूप के कार्यों को समाहित करता है। सभी कार्यों को एक ही कथन में शामिल किया जा सकता है। उदाहरण केवल सिंटैक्स तक do दिखाता है।

<पूर्व> काउंटर निश्चित प्रारंभिक (5) घोषित करें; फैक्टोरियल फिक्स्ड इनिशियल (1) घोषित करें;

तब तक करें (काउंटर <= 0);

 फैक्टोरियल = फैक्टोरियल * काउंटर;
 काउंटर = काउंटर - 1;

अंत;

पुट (तथ्यात्मक); </पूर्व>

पायथन (प्रोग्रामिंग भाषा)

प्रवाह नियंत्रण निर्माण के दौरान पायथन में एक विशिष्ट कार्य का अभाव है। हालाँकि, समतुल्य को ब्रेक के साथ थोड़ी देर के लूप से बनाया जा सकता है।

counter = 5
factorial = 1

while True:
    factorial *= counter
    counter -= 1
    
    if counter == 0:
        break
    
print(factorial)

रैकेट (प्रोग्रामिंग भाषा)

रैकेट में, जैसा कि अन्य योजना (प्रोग्रामिंग भाषा) कार्यान्वयन में है, नाम-लेट लूप को लागू करने का एक लोकप्रिय तरीका है:

#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
    (set! factorial (* factorial counter))
    (set! counter (sub1 counter))
    (when (> counter 0) (loop)))
(displayln factorial)

इसकी तुलना रैकेट के लिए जबकि लूप#रैकेट उदाहरण के पहले उदाहरण से करें। विदित हो कि एक नामित let तर्क भी ले सकता है।

रैकेट और स्कीम भी उचित डू लूप प्रदान करते हैं।

(define (factorial n)
    (do ((counter n (- counter 1))
        (result 1 (* result counter)))
    ((= counter 0) result) ; Stop condition and return value.
    ; The body of the do-loop is empty.
    ))

रूबी (प्रोग्रामिंग भाषा)

counter = 10
factorial = 2

begin
  factorial *= counter
  counter -= 2
end while counter > 1

puts factorial

स्मालटॉक

| counter factorial |
counter := 5.
factorial := 1.

[counter > 0] whileTrue: 
    [factorial := factorial * counter.
    counter := counter - 1].

Transcript show: factorial printString

स्विफ्ट (प्रोग्रामिंग भाषा)

स्विफ्ट 2.x और बाद में:

var counter = 5
var factorial = 1

repeat {
    factorial *= counter
    counter -= 1
} while counter > 0

print(factorial)

स्विफ्ट 1.x:

var counter = 5
var factorial = 1

do {
    factorial *= counter
    counter -= 1
} while counter > 0

println(factorial)

विजुअल बेसिक .NET

Dim counter As Integer = 5
Dim factorial As Integer = 1

Do
    factorial *= counter
    counter -= 1 
Loop While counter > 0

Console.WriteLine(factorial)

यह भी देखें

• बहाव को काबू करें
• पाश के लिए
• प्रत्येक के लिए
• रिपीट लूप (बहुविकल्पी)
• घुमाव के दौरान

बाहरी संबंध

• do {...} while (0) in C macros