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

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

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

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

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

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

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

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

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

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

के समान है

do_work();

while (condition) {
    do_work();
}

इस विधि से, डू ... वाइल लूप प्रारंभिक लूप प्राइमिंग को 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);

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

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;

बेसिक

प्रारंभिक बेसिक्स (जैसे जीडब्ल्यू-बेसिक) ने WHILE/WEND सिंटैक्स का उपयोग किया पावरबेसिक जैसे आधुनिक बेसिक, 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

C# (प्रोग्रामिंग भाषा)

int counter = 5;
int factorial = 1;

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

System.Console.WriteLine(factorial);

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

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. सर्ट सी कोडिंग मानक नियम प्री10-C में इसकी पक्षसमर्थन की गई है।

C++

int counter = 5;
int factorial = 1;

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

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

CFScript

factorial = 1;
count = 10;

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

writeOutput(factorial);

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

int counter = 5;
int factorial = 1;

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

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

फोरट्रान

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

      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 और बाद में कोई डू-जबकि निर्माण नहीं होता है किंतु इसमें एक वाइल _लूप या फोरट्रान निर्माण होता है जो कीवर्ड डू-वाइल का उपयोग करता है और इस प्रकार यह वास्तव में फॉर लूप के समान है।

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

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

int counter = 5;
int factorial = 1;

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

System.out.println("The factorial of 5 is " + factorial);

//============================================//
// The below function does the same as above. //
//============================================//

int counter = 5;
int factorial = 1;

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

System.out.println("The factorial of 5 is " + factorial);

इंट काउंटर = 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

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

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

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;

पीएल/आई

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

declare counter   fixed initial(5);
declare factorial fixed initial(1);

do until(counter <= 0);
    factorial = factorial * counter;
    counter = counter - 1;
end;

put(factorial);

 फैक्टोरियल = फैक्टोरियल * काउंटर;
 काउंटर = काउंटर - 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)

रैकेट में जैसा कि अन्य योजना कार्यान्वयन में है लूप को प्रयुक्त करने के लिए "नामित-लेट" एक लोकप्रिय विधि है:

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

(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