I need to emulate a do-while loop in a Python program. Unfortunately, the following straightforward code does not work:

    list_of_ints = [ 1, 2, 3 ]
    iterator = list_of_ints.__iter__()
    element = None

    while True:
      if element:
        print element

      try:
        element = iterator.next()
      except StopIteration:
        break

    print &quot;done&quot;

Instead of &quot;1,2,3,done&quot;, it prints the following output:

    [stdout:]1
    [stdout:]2
    [stdout:]3
    None[&#39;Traceback (most recent call last):
    &#39;, &#39;  File &quot;test_python.py&quot;, line 8, in &lt;module&gt;
        s = i.next()
    &#39;, &#39;StopIteration
    &#39;]

What can I do in order to catch the &#39;stop iteration&#39; exception and break a while
loop properly?

An example of why such a thing may be needed is shown below as pseudocode.

State machine:

    s = &quot;&quot;
    while True :
      if state is STATE_CODE :
        if &quot;//&quot; in s :
          tokens.add( TOKEN_COMMENT, s.split( &quot;//&quot; )[1] )
          state = STATE_COMMENT
        else :
          tokens.add( TOKEN_CODE, s )
      if state is STATE_COMMENT :
        if &quot;//&quot; in s :
          tokens.append( TOKEN_COMMENT, s.split( &quot;//&quot; )[1] )
        else
          state = STATE_CODE
          # Re-evaluate same line
          continue
      try :
        s = i.next()
      except StopIteration :
        break


How to emulate a do-while loop?

I am having trouble coming up with the right combination of semicolons and/or braces. I&#39;d like to do this, but as a one-liner from the command line:

    while [ 1 ]
    do
        foo
        sleep 2
    done


Syntax for a single-line while loop in Bash

What is wrong with using `feof()` to control a read loop?  For example:

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    
    int
    main(int argc, char **argv)
    {
        char *path = &quot;stdin&quot;;
        FILE *fp = argc &gt; 1 ? fopen(path=argv[1], &quot;r&quot;) : stdin;

        if( fp == NULL ){
            perror(path);
            return EXIT_FAILURE;
        }

        while( !feof(fp) ){  /* THIS IS WRONG */
            /* Read and process data from file… */
        }
        if( fclose(fp) != 0 ){
            perror(path);
            return EXIT_FAILURE;
        }
        return EXIT_SUCCESS;
    }


What is wrong with this loop?


Why is “while ( !feof (file) )” always wrong?

This was an interview question asked by a senior manager.

Which is faster? 

    while(1) {
        // Some code
    }

or 

    while(2) {
        //Some code
    }

I said that both have the same execution speed, as the expression inside `while` should finally evaluate to `true` or `false`. In this case, both evaluate to `true` and there are no extra conditional instructions inside the `while` condition. So, both will have the same speed of execution and I prefer while (1).

But the interviewer said confidently:
&quot;Check your basics. `while(1)` is faster than `while(2)`.&quot;
(He was not testing my confidence)

Is this true?

### See also: https://stackoverflow.com/questions/2611246/is-for-faster-than-while-true-if-not-why-do-people-use-it


Which is faster: while(1) or while(2)?

I&#39;ve noticed the following code is legal in Python. My question is why? Is there a specific reason?

    n = 5
    while n != 0:
        print n
        n -= 1
    else:
        print &quot;what the...&quot;

Else clause on Python while statement

I am trying to plot some data from a camera in real time using OpenCV. However, the real-time plotting (using matplotlib) doesn&#39;t seem to be working.

I&#39;ve isolated the problem into this simple example:

    fig = plt.figure()
    plt.axis([0, 1000, 0, 1])

    i = 0
    x = list()
    y = list()

    while i &lt; 1000:
        temp_y = np.random.random()
        x.append(i)
        y.append(temp_y)
        plt.scatter(i, temp_y)
        i += 1
        plt.show()

I would expect this example to plot 1000 points individually. What actually happens is that the window pops up with the first point showing (ok with that), then waits for the loop to finish before it populates the rest of the graph.

Any thoughts why I am not seeing points populated one at a time?

How do I plot in real-time in a while loop using matplotlib?

I have a script and want to ask the user for some information, but the script cannot continue until the user fills in this information. The following is my attempt at putting a command into a loop to achieve this but it doesn&#39;t work for some reason:

```shell
echo &quot;Please change password&quot;
while passwd
do
    echo &quot;Try again&quot;
done
```

I have tried many variations of the while loop:

```shell
while `passwd`
while [[ &quot;`passwd`&quot; -gt 0 ]]
while [ `passwd` -ne 0 ]]
# ... And much more
```

But I can&#39;t seem to get it to work.

How can you run a command in bash over and over until success?

I&#39;ve heard this quite a few times. Are JavaScript loops really faster when counting backward? If so, why? I&#39;ve seen a few test suite examples showing that reversed loops are quicker, but I can&#39;t find any explanation as to why!

I&#39;m assuming it&#39;s because the loop no longer has to evaluate a property each time it checks to see if it&#39;s finished and it just checks against the final numeric value.

I.e. 

    for (var i = count - 1; i &gt;= 0; i--)
    {
      // count is only evaluated once and then the comparison is always on 0.
    }


Are loops really faster in reverse?

I have a list consisting of like 20000 lists. I use each list&#39;s 3rd element as a flag. I want to do some operations on this list as long as at least one element&#39;s flag is 0, it&#39;s like:

    my_list = [[&quot;a&quot;, &quot;b&quot;, 0], [&quot;c&quot;, &quot;d&quot;, 0], [&quot;e&quot;, &quot;f&quot;, 0], .....]

In the beginning, all flags are 0. I use a while loop to check if at least one element&#39;s flag is 0:


    def check(list_):
        for item in list_:
            if item[2] == 0:
                return True
        return False

If `check(my_list)` returns `True`, then I continue working on my list:

    while check(my_list):
        for item in my_list:
            if condition:
                item[2] = 1
            else:
                do_sth()

Actually, I wanted to remove an element in my_list as I iterated over it, but I&#39;m not allowed to remove items as I iterate over it.

Original my_list didn&#39;t have flags:

    my_list = [[&quot;a&quot;, &quot;b&quot;], [&quot;c&quot;, &quot;d&quot;], [&quot;e&quot;, &quot;f&quot;], .....]

Since I couldn&#39;t remove elements as I iterated over it, I invented these flags. But the `my_list` contains many items, and `while` loop reads all of them at each `for` loop, and it consumes lots of time! Do you have any suggestions?

How to check if all elements of a list match a condition?

Why does the following work fine?

    String str;
    while (condition) {
        str = calculateStr();
        .....
    }

But this one is said to be dangerous/incorrect:

    while (condition) {
        String str = calculateStr();
        .....
    }

Is it necessary to declare variables outside the loop?

Declaring variables inside or outside of a loop

In the following program, if I set the variable `$foo` to the value 1 inside the first `if` statement, it works in the sense that its value is remembered after the if statement. However, when I set the same variable to the value 2 inside an `if` which is inside a `while` statement, it&#39;s forgotten after the `while` loop. It&#39;s behaving like I&#39;m using some sort of copy of the variable `$foo` inside the `while` loop and I am modifying only that particular copy. Here&#39;s a complete test program:

    #!/bin/bash
    
    set -e
    set -u 
    foo=0
    bar=&quot;hello&quot;  
    if [[ &quot;$bar&quot; == &quot;hello&quot; ]]
    then
        foo=1
        echo &quot;Setting \$foo to 1: $foo&quot;
    fi

    echo &quot;Variable \$foo after if statement: $foo&quot;   
    lines=&quot;first line\nsecond line\nthird line&quot; 
    echo -e $lines | while read line
    do
        if [[ &quot;$line&quot; == &quot;second line&quot; ]]
        then
    	foo=2
    	echo &quot;Variable \$foo updated to $foo inside if inside while loop&quot;
        fi
        echo &quot;Value of \$foo in while loop body: $foo&quot;
    done
    
    echo &quot;Variable \$foo after while loop: $foo&quot;
    
    # Output:
    # $ ./testbash.sh
    # Setting $foo to 1: 1
    # Variable $foo after if statement: 1
    # Value of $foo in while loop body: 1
    # Variable $foo updated to 2 inside if inside while loop
    # Value of $foo in while loop body: 2
    # Value of $foo in while loop body: 2
    # Variable $foo after while loop: 1
    
    # bash --version
    # GNU bash, version 4.1.10(4)-release (i686-pc-cygwin)

A variable modified inside a while loop is not remembered

**Question 1:**

Why does the following code compile without having a return statement?
		
	public int a() {
		while(true);
	}

Notice: If I add return after the while then I get an `Unreachable Code Error`.

**Question 2:** 

On the other hand, why does the following code compile,

	public int a() {
		while(0 == 0);
	}

even though the following does not.

	public int a(int b) {
		while(b == b);
	}

Java method with return type compiles without return statement

I&#39;ve been programming in Java for several years now, but I just recently returned to school to get a formal degree. I was quite surprised to learn that, on my last assignment, I lost points for using a loop like the one below.

    do{
         //get some input.
         //if the input meets my conditions, break;
         //Otherwise ask again.
    } while(true)

Now for my test I&#39;m just scanning for some console input, but I was told that this kind of loop is discouraged because using `break` is akin to `goto`, we just don&#39;t do it.

I understand fully the pitfalls of `goto` and its Java cousin `break:label`, and I have the good sense not to use them. I also realize that a more complete program would provide some other means of escape, say for instance to just end the program, but that wasn&#39;t a reason my professor cited, so...

What&#39;s wrong with `do-while(true)`?


Are &quot;while(true)&quot; loops so bad?

I want to write a Bash script to process text, which might require a while loop. 

For example, a while loop in C:

    int done = 0;
    while(1) {
      ...
      if(done) break;
    }

I want to write a Bash script equivalent to that. But what I usually used and as all the classic examples I read have showed, is this:

    while read something;
    do
    ...
    done

It offers no help about how to do `while(1){}` and `break;`, which is well defined and widely used in C, and I do not have to read data for stdin. 

Could anyone help me with a Bash equivalent of the above C code?

How to break out of a loop in Bash?

Many Python programmers are probably unaware that the syntax of `while` loops and `for` loops includes an optional `else:` clause:

    for val in iterable:
        do_something(val)
    else:
        clean_up()

The body of the `else` clause is a good place for certain kinds of clean-up actions, and is executed on normal termination of the loop: I.e., exiting the loop with `return` or `break` skips the `else` clause; exiting after a `continue` executes it. I know this only because I just [looked it up][for] (yet again), because  I can never remember _when_ the `else` clause is executed.

Always? On &quot;failure&quot; of the loop, as the name suggests? On regular termination? Even if the loop is exited with `return`? I can never be entirely sure without looking it up.

[for]: https://docs.python.org/3/reference/compound_stmts.html#the-for-statement

I blame my persisting uncertainty on the choice of keyword: I find `else` incredibly unmnemonic for this semantics. My question is not &quot;why is this keyword used for this purpose&quot; (which I would probably vote to close, though only after reading the answers and comments), but **how can I think about the `else` keyword so that its semantics make sense, and I can therefore remember it?**

I&#39;m sure there was a fair amount of discussion about this, and I can imagine that the choice was made for consistency with the `try` statement&#39;s `else:` clause (which I also have to look up), and with the goal of not adding to the list of Python&#39;s reserved words. Perhaps the reasons for choosing `else` will clarify its function and make it more memorable, but I&#39;m after connecting name to function, not after historical explanation per se.

The answers to [this question][why], which my question was briefly closed as a duplicate of, contain a lot of interesting back story. My question has a different focus (how to connect the specific semantics of `else` with the keyword choice), but I feel there should be a link to this question somewhere.

[why]: https://stackoverflow.com/q/9979970/699305


How can I make sense of the `else` clause of Python loops?

I have the following shell script. The purpose is to loop thru each line of the target file (whose path is the input parameter to the script) and do work against each line. Now, it seems only work with the very first line in the target file and stops after that line got processed. Is there anything wrong with my script? 

    #!/bin/bash
    # SCRIPT: do.sh
    # PURPOSE: loop thru the targets 

    FILENAME=$1
    count=0

    echo &quot;proceed with $FILENAME&quot;

    while read LINE; do
       let count++
       echo &quot;$count $LINE&quot;
       sh ./do_work.sh $LINE
    done &lt; $FILENAME

    echo &quot;\ntotal $count targets&quot;

In `do_work.sh`, I run a couple of `ssh` commands.

While loop stops reading after the first line in Bash

Is there any method for implement `do while` loop in SQL server 2008?

Do while loop in SQL Server 2008

So Scala is supposed to be as fast as Java. I&#39;m revisiting some [Project Euler][1] problems in Scala that I originally tackled in Java. Specifically Problem 5: &quot;What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?&quot;

Here&#39;s my Java solution, which takes 0.7 seconds to complete on my machine:

    public class P005_evenly_divisible implements Runnable{
        final int t = 20;

        public void run() {
            int i = 10;
            while(!isEvenlyDivisible(i, t)){
                i += 2;
            }
            System.out.println(i);
        }

        boolean isEvenlyDivisible(int a, int b){
            for (int i = 2; i &lt;= b; i++) {
                if (a % i != 0) 
                    return false;
            }
            return true;
        }

        public static void main(String[] args) {
            new P005_evenly_divisible().run();
        }
    }

Here&#39;s my &quot;direct translation&quot; into Scala, which takes 103 seconds (147 times longer!)

    object P005_JavaStyle {
        val t:Int = 20;
        def run {
            var i = 10
            while(!isEvenlyDivisible(i,t))
                i += 2
            println(i)
        }
        def isEvenlyDivisible(a:Int, b:Int):Boolean = {
            for (i &lt;- 2 to b)
                if (a % i != 0)
                    return false
            return true
        }
        def main(args : Array[String]) {
            run
        }
    }

Finally here&#39;s my attempt at functional programming, which takes 39 seconds (55 times longer)

    object P005 extends App{
        def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
        def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
        println (find (2))
    }

Using Scala 2.9.0.1 on Windows&amp;nbsp;7 64-bit. How do I improve performance? Am I doing something wrong? Or is Java just a lot faster?

  [1]: http://en.wikipedia.org/wiki/Project_Euler


How to optimize for-comprehensions and loops in Scala?

I am using a While...Wend loop of VBA.

    Dim count as Integer
    
    While True
        count=count+1

        If count = 10 Then
            &#39;&#39;What should be the statement to break the While...Wend loop? 
            &#39;&#39;Break or Exit While not working
        EndIf
    Wend

I don&#39;t want to use condition like `While count&lt;=10...Wend

Break out of a While...Wend loop

I am reading serial data and writing to a csv file using a while loop. I want the user to be able to kill the while loop once they feel they have collected enough data.

    while True:
        #do a bunch of serial stuff
        
        #if the user presses the &#39;esc&#39; or &#39;return&#39; key:
            break

I have done something like this using opencv, but it doesn&#39;t seem to be working in this application (and i really don&#39;t want to import opencv just for this function anyway)...

			# Listen for ESC or ENTER key
			c = cv.WaitKey(7) % 0x100
			if c == 27 or c == 10:
				break

So. How can I let the user break out of the loop?

Also, I don&#39;t want to use keyboard interrupt, because the script needs to continue to run after the while loop is terminated.

How to kill a while loop with a keystroke?

I found similar questions asked here but there weren&#39;t answers to my satisfaction. So rephrasing the question again-

I have a task that needs to be done on a periodic basis (say 1 minute intervals). What is advantage of using Timertask &amp; Timer to do this as opposed to creating a new thread that has a infinite loop with sleep?

Code snippet using timertask-

    TimerTask uploadCheckerTimerTask = new TimerTask(){
    
     public void run() {
      NewUploadServer.getInstance().checkAndUploadFiles();
     }
    };
    
    Timer uploadCheckerTimer = new Timer(true);
    uploadCheckerTimer.scheduleAtFixedRate(uploadCheckerTimerTask, 0, 60 * 1000);

Code snippet using Thread and sleep-

    Thread t = new Thread(){
     public void run() {
      while(true) {
       NewUploadServer.getInstance().checkAndUploadFiles();
       Thread.sleep(60 * 1000);
      }
     }
    };
    t.start();

I really don&#39;t have to worry if I miss certain cycles if the execution of the logic takes more than the interval time.

Please comment on this..

Update:  
Recently I found another difference between using Timer versus Thread.sleep(). Suppose the current system time is 11:00AM. If we rollback the system time to 10:00AM for some reason, The Timer will STOP executing the task until it has reached 11:00AM, whereas Thread.sleep() method would continue executing the task without hindrance. This can be a major decision maker in deciding what to use between these two.

Timer &amp; TimerTask versus Thread + sleep in Java

&gt; **Possible Duplicates:** &lt;br/&gt;
&gt; [While vs. Do While](https://stackoverflow.com/questions/390605/while-vs-do-while) &lt;br/&gt;
&gt; [When should I use do-while instead of while loops?](https://stackoverflow.com/questions/3094972/when-should-i-use-do-while-instead-of-while-loops)

&lt;!-- End of automatically inserted text --&gt;

I&#39;ve been programming for a while now (2 years work + 4.5 years degree + 1 year pre-college), and I&#39;ve never used a do-while loop short of being forced to in the Introduction to Programming course. I have a growing feeling that I&#39;m doing programming wrong if I never run into something so fundamental.

Could it be that I just haven&#39;t run into the correct circumstances?

What are some examples where it would be necessary to use a do-while instead of a while?

(My schooling was almost all in C/C++ and my work is in C#, so if there is another language where it absolutely makes sense because do-whiles work differently, then these questions don&#39;t really apply.)

To clarify...I know the difference between a `while` and a `do-while`. While checks the exit condition and then performs tasks. `do-while` performs tasks and then checks exit condition.


&#39;do...while&#39; vs. &#39;while&#39;

Bash allows to use: `cat &lt;(echo &quot;$FILECONTENT&quot;)`

Bash also allow to use: `while read i; do echo $i; done &lt;/etc/passwd`

to combine previous two this can be used: `echo $FILECONTENT | while read i; do echo $i; done`

The problem with last one is that it creates sub-shell and after the while loop ends variable `i` cannot be accessed any more.

My question is:

How to achieve something like this: `while read i; do echo $i; done &lt;(echo &quot;$FILECONTENT&quot;)` or in other words: How can I be sure that `i` survives while loop?

Please note that I am aware of enclosing while statement into `{}` but this does not solves the problem (imagine that you want use the while loop in function and return `i` variable)

How to pipe input to a Bash while loop and preserve variables after loop ends

What is the best way to exit/terminate a while loop in Java?


For example, my code is currently as follows:

    while(true){
        if(obj == null){

            // I need to exit here

        }
    }

How do I exit a while loop in Java?

When C# throws an exception, it can have an inner exception. What I want to do is get the inner-most exception, or in other words, the leaf exception that doesn&#39;t have an inner exception. I can do this in a while loop:

    while (e.InnerException != null)
    {
        e = e.InnerException;
    }


But I was wondering if there was some one-liner I could use to do this instead.

Find the inner-most exception without using a while loop?

I just came across this piece of code

    while 1:
        line = data.readline()
        if not line:
            break
        #...

and thought, there *must* be a better way to do this, than using an infinite loop with `break`.

So I tried:

    while line = data.readline():
        #...

and, obviously, got an error.

Is there any way to avoid using a `break` in that situation?

### Edit:

Ideally, you&#39;d want to avoid saying `readline` twice... IMHO, repeating is even worse than just a `break`, especially if the statement is complex.

Assign variable in while loop condition in Python?

There are three loops in C: `for`, `while`, and `do-while`. What&#39;s the difference between them?

For example, it seems nearly all `while` statements can be replaced by `for` statements, right? Then, what&#39;s the advantage using `while`?


For vs. while in C programming?

I&#39;ve been trying to read input into environment variables from program output like this:

    echo first second | read A B ; echo $A-$B 

And the result is:

    -

Both A and B are always empty. I read about bash executing piped commands in sub-shell and that basically preventing one from piping input to read. However, the following:

    echo first second | while read A B ; do echo $A-$B ; done

Seems to work, the result is:

    first-second


Can someone please explain what is the logic here? Is it that the commands inside the `while` ... `done` construct are actually executed in the same shell as `echo` and not in a sub-shell?

Why piping input to &quot;read&quot; only works when fed into &quot;while read ...&quot; construct?

I often use this code pattern:

    while(true) {
    	
    	//do something
    	
    	if(&lt;some condition&gt;) {
    		break;
    	}
    	
    }	

Another programmer told me that this was bad practice and that I should replace it with the more standard:

    while(!&lt;some condition&gt;) {
    	
    	//do something
    	
    }	

His reasoning was that you could &quot;forget the break&quot; too easily and have an endless loop. I told him that in the second example you could just as easily put in a condition which never returned true and so just as easily have an endless loop, so both are equally valid practices.

Further, I often prefer the former as it makes the code easier to read when you have multiple break points, i.e. multiple conditions which get out of the loop.

Can anyone enrichen this argument by adding evidence for one side or the other?


Is while (true) with break bad programming practice?

I have a homework to implement a simple testing application, below is my current code:

    import java.util.*;

    public class Test{

    private static int typing;
    
    public static void main(String argv[]){
    	Scanner sc = new Scanner(System.in);
    	System.out.println(&quot;Testing starts&quot;);
    	while(sc.hasNextInt()){
    	    typing = sc.nextInt();
    	    switch(typing){
    	        case 0:
    	          break; //Here I want to break the while loop
    	        case 1:
    	          System.out.println(&quot;You choosed 1&quot;);
    	          break;
    	        case 2:
    	          System.out.println(&quot;You choosed 2&quot;);
    	          break;
    	        default:
    	          System.out.println(&quot;No such choice&quot;);
    	    }
    	}
    	  System.out.println(&quot;Test is done&quot;);
        }
    }
What I want to do now is that when `0` is pressed, it means that the user wants to quit the test, then I break the `while loop` and print `Test is done`, but it doesn&#39;t work like that, I know the reason might be that the `&quot;break&quot;` breaks the `switch`, how can I let it break the `while loop` instead?

Java How can I break a while loop under a switch statement?

I am asking this question from an educational/hacking point of view, (I wouldn&#39;t really want to code like this).

Is it possible to implement a while loop only using **C** preprocessor directives. I understand that macros cannot be expanded recursively, so how would this be accomplished?



How to write a while loop with the C preprocessor?

In this code sample, is there any way to continue on the outer loop from the catch block?

    while
    {
       // outer loop

       while
       {
           // inner loop
           try
           {
               throw;
           }
           catch 
           {
               // how do I continue on the outer loop from here?
               continue;
           }
       }
    }

Continue in nested while loops

While browsing the code for the Java 8 version of ForkJoinPool(which has a few interesting changes from Java 7) I ran across this construct ([here][1]):


    do {} while (!blocker.isReleasable() &amp;&amp;
                 !blocker.block());

I&#39;m struggling with why you would write it like this instead of just

    while (!blocker.isReleasable() &amp;&amp;
           !blocker.block());

Is it just a semantics/readability choice, since you could read the first construct as `do &quot;nothing&quot; while &quot;conditions&quot;`? Or is there some additional benefit I&#39;m missing?

  [1]: http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/util/concurrent/ForkJoinPool.java#l3207

Do &quot;nothing&quot; while &quot;condition&quot;

What is the difference between a standard `while(true)` loop and `for(;;)`?

Is there any, or will both be mapped to the same bytecode after compiling?

Java: for(;;) vs. while(true)

I am having trouble figuring out how to break out of a loop that contains a switch statement.  Break breaks out of the switch, not the loop.

There is probably a more elegant solution to this.  I have implemented a flag that starts out as true and gets set to false and ends the loop.  Can you offer a better solution?

Background: this code is used in a bar code workflow system.  We have PocketPCs that have bar code scanners built in.  This code is used in one of those functions.  It prompts the user for different pieces of data throughout the routine.  This piece allows them to scroll through some inventory records displaying that info on the PocketPC terminal (paged results) and allows them to enter &quot;D&quot; for Done, &quot;Q&quot; to quit.

Here is the current C# example that needs to be improved:

    do
    {
        switch (MLTWatcherTCPIP.Get().ToUpper())
        {
            case &quot;&quot;: //scroll/display next inventory location
                MLTWatcherTCPIP.TerminalPrompt.ScrollBodyTextDown();
                break;
            case &quot;P&quot;: //scroll/display previous inventory location
                MLTWatcherTCPIP.TerminalPrompt.ScrollBodyTextDown();
                break;
            case &quot;D&quot;: //DONE (exit out of this Do Loop)
                // break; // this breaks out of the switch, not the loop
                // return; // this exists entire method; not what I&#39;m after
                keepOnLooping = false;
                break;
            case &quot;Q&quot;: //QUIT (exit out to main menu)
                return;
            default:
                break;
        }
    } while (keepOnLooping);

Here is an example of code that does this in VB.NET

    Do
        Select Case MLTWatcherTCPIP.Get().ToUpper
            Case &quot;&quot; &#39;&#39;#scroll/display next inventory location
                MLTWatcherTCPIP.TerminalPrompt.ScrollBodyTextDown()
            Case &quot;P&quot; &#39;&#39;#scroll/display previous inventory location
                MLTWatcherTCPIP.TerminalPrompt.ScrollBodyTextUp()
            Case &quot;D&quot; &#39;&#39;#DONE (exit out of this Do Loop)
                Exit Do
            Case &quot;Q&quot; &#39;&#39;#QUIT (exit out to main menu)
                Return
        End Select
    Loop

Thanks,

Break out of a while loop that contains a switch statement

I&#39;m trying to get a simple while loop working in bash that uses two conditions, but after trying many different syntax from various forums, I can&#39;t stop throwing an error. Here is what I have:

    while [ $stats -gt 300 ] -o [ $stats -eq 0 ]

I have also tried:

    while [[ $stats -gt 300 ] || [ $stats -eq 0 ]]

... as well as several others constructs. I want this loop to continue while `$stats is &gt; 300` or if `$stats = 0`.

Bash scripting, multiple conditions in while loop

I have a while loop, and I want it to keep running through for 15 minutes. it is currently:
    
    while True:
        #blah blah blah


(this runs through, and then restarts. I need it to continue doing this except after 15 minutes it exits the loop)

Thanks!

Python loop to run for certain amount of seconds

I am experimenting with a more functional style in my JavaScript; therefore, I have replaced for loops with utility functions such as map and reduce.  However, I have not found a functional replacement for while loops since tail call optimization is generally not available for JavaScript.  (From what I understand ES6 prevents tail calls from overflowing the stack but does not optimize their performance.)

I explain what I have tried below, but the TLDR is:
If I don&#39;t have tail call optimization, what is the functional way to implement while loops?

What I have tried:

Creating a &quot;while&quot; utility function:

    function while(func, test, data) {
      const newData = func(data);
      if(test(newData)) {
        return newData;
      } else {
        return while(func, test, newData);
      }
    }

Since tail call optimization isn&#39;t available I could rewrite this as:

    function while(func, test, data) {
      let newData = *copy the data somehow*
      while(test(newData)) {
        newData = func(newData);
      }
      return newData;
    }

However at this point it feels like I have made my code more complicated/confusing for anyone else who uses it, since I have to lug around a custom utility function.  The only practical advantage that I see is that it forces me to make the loop pure; but it seems like it would be more straightforward to just use a regular while loop and make sure that I keep everything pure.

I also tried to figure out a way to create a generator function that mimics the effects of recursion/looping and then iterate over it using a utility function like find or reduce.  However, I haven&#39;t figured out an readable way to do that yet.

Finally, replacing for loops with utility functions makes it more apparent what I am trying to accomplish (e.g. do a thing to each element, check if each element passes a test, etc.).  However, it seems to me that a while loop already expresses what I am trying to accomplish (e.g. iterate until we find a prime number, iterate until the answer is sufficiently optimized, etc.).

So after all this, my overall question is: If I need a while loop, I am programming in a functional style, and I don&#39;t have access to tail call optimization, then what is the best strategy.

How do I replace while loops with a functional programming alternative without tail call optimization?

Here is what I want, inside the `BACKUPDIR`, I want to execute `cscript /nologo c:\deletefile.vbs %BACKUPDIR%` until number of files inside the folder is greater than 21(`countfiles` holds it).
Here is my code:

    @echo off
    SET BACKUPDIR=C:\test
    for /f %%x in (&#39;dir %BACKUPDIR% /b ^| find /v /c &quot;::&quot;&#39;) do set countfiles=%%x
    
    for %countfiles% GTR 21 (
    cscript /nologo c:\deletefile.vbs %BACKUPDIR%
    set /a countfiles-=%countfiles%
    )

While loop in batch

Pretty simple question from a first-time Ruby programmer.

How do you loop through a slab of text in Ruby? Everytime a newline is met, I want to re-start the inner-loop.

    def parse(input)
        ...
    end

How do you loop through a multiline string in Ruby?

I am playing a sound file using this code inside a broadcast receiver activity:

    notification.sound = Uri.parse(&quot;android.resource://emad.app/raw/seven_chimes&quot;);

I would like to detect when this file has finished playing.

I tried a loop like this but I think this is only good for the media player because it always = false even though I made sure the sound file was still playing:

    /*
     * Stay here until the chime sound is finished.
     */
       while (manager.isMusicActive()){
       }
	
Can you show me what I should use instead of `manager.isMusicActive()`?

How do you detect when a sound file has finished?

What purpose does `while(1);` serve ?  I am aware `while(1)` (no semicolon) loops infinitely and is similar to a spinlock situation.  However I do not see where `while(1);` could be used ? 

## Sample code ##

    if(!condition)
    { 
      while(1);
    }

Note: This is not a case of `do`-`while()` or plain `while(1)`.

Purpose of while(1); statement in C

In Python you have two fine ways to repeat some action more than once. One of them is `while` loop and the other - `for` loop. So let&#39;s have a look on two simple pieces of code:

    for i in range(n):
        do_sth()

And the other:

    i = 0
    while i &lt; n:
        do_sth()
        i += 1

My question is which of them is better. Of course, the first one, which is very common in documentation examples and various pieces of code you could find around the Internet, is much more elegant and shorter, but on the other hand it creates a completely useless list of integers just to loop over them. Isn&#39;t it a waste of memory, especially as far as big numbers of iterations are concerned?

So what do you think, which way is better?
    

for or while loop to do something n times

Surprisingly, the following code outputs:
```none
/
-1
```
The code:
```
public class LoopOutPut {

    public static void main(String[] args) {
        LoopOutPut loopOutPut = new LoopOutPut();
        for (int i = 0; i &lt; 30000; i++) {
            loopOutPut.test();
        }

    }

    public void test() {
        int i = 8;
        while ((i -= 3) &gt; 0) ;
        String value = i + &quot;&quot;;
        if (!value.equals(&quot;-1&quot;)) {
            System.out.println(value);
            System.out.println(i);
        }
    }

}
```

I tried many times to determine how many times this would occur, but, unfortunately, it was ultimately uncertain, and I found that the output of -2 sometimes turned into a period. In addition, I also tried to remove the while loop and output -1 without any problems. Who can tell me why?

----------------------------------

JDK version information:
```none
HopSpot 64-Bit 1.8.0.171
IDEA 2019.1.1
```

The output -1 becomes a slash in the loop

    while (temp-&gt;left-&gt;oper == &#39;+&#39; || 
           temp-&gt;left-&gt;oper == &#39;-&#39; || 
           temp-&gt;left-&gt;oper == &#39;*&#39; || 
           temp-&gt;left-&gt;oper == &#39;/&#39; || 
           temp-&gt;right-&gt;oper == &#39;+&#39; || 
           temp-&gt;right-&gt;oper == &#39;-&#39; || 
           temp-&gt;right-&gt;oper == &#39;*&#39; || 
           temp-&gt;right-&gt;oper == &#39;/&#39;)
    {
        // do something
    }

For clarity: `temp` is a pointer that points to following `node` structure:

    struct node
    {
        int num;
        char oper;
        node* left;
        node* right;
    };


  



Is there a way to shorten this while condition?

I run into this case a lot of times when doing simple text processing and print statements where I am looping over a collection and I want to special case the last element (for example every normal element will be comma separated except for the last case).

Is there some best practice idiom or elegant form that doesn&#39;t require duplicating code or shoving in an if, else in the loop.

For example I have a list of strings that I want to print in a comma separated list. (the do while solution already assumes the list has 2 or more elements otherwise it&#39;d be just as bad as the more correct for loop with conditional).

e.g. List&lt;String&gt; = (&quot;dog&quot;, &quot;cat&quot;, &quot;bat&quot;)

I want to print &quot;[dog, cat, bat]&quot;

I present 2 methods the

 1. For loop with conditional



        public static String forLoopConditional(String[] items) {

        String itemOutput = &quot;[&quot;;
    
        for (int i = 0; i &lt; items.length; i++) {
            // Check if we&#39;re not at the last element
            if (i &lt; (items.length - 1)) {
                itemOutput += items[i] + &quot;, &quot;;
            } else {
                // last element
                itemOutput += items[i];
            }
        }
        itemOutput += &quot;]&quot;;
    
        return itemOutput;
         }


 2. do while loop priming the loop


        public static String doWhileLoopPrime(String[] items) {
        String itemOutput = &quot;[&quot;;
        int i = 0;

        itemOutput += items[i++];
        if (i &lt; (items.length)) {
            do {
                itemOutput += &quot;, &quot; + items[i++];
            } while (i &lt; items.length);
        }
        itemOutput += &quot;]&quot;;

        return itemOutput;
        }
Tester class:

    
        public static void main(String[] args) {
            String[] items = { &quot;dog&quot;, &quot;cat&quot;, &quot;bat&quot; };
    
            System.out.println(forLoopConditional(items));
            System.out.println(doWhileLoopPrime(items));
    
        }

In the Java AbstractCollection class it has the following implementation (a little verbose because it contains all edge case error checking, but not bad).

    public String toString() {
        Iterator&lt;E&gt; i = iterator();
	if (! i.hasNext())
	    return &quot;[]&quot;;

	StringBuilder sb = new StringBuilder();
	sb.append(&#39;[&#39;);
	for (;;) {
	    E e = i.next();
	    sb.append(e == this ? &quot;(this Collection)&quot; : e);
	    if (! i.hasNext())
		return sb.append(&#39;]&#39;).toString();
	    sb.append(&quot;, &quot;);
	}
    }


Best Loop Idiom for special casing the last element

I currently have code that basically runs an infinite while loop to collect data from users. Constantly updating dictionaries/lists based on the contents of a text file. For reference:

    while (True):
	    IDs2=UpdatePoints(value,IDs2)
	    time.sleep(10)
	
Basically, my problem is that I do not know when I want this to end, but after this while loop runs I want to use the information collected, not lose it by crashing my program. Is there a simple, elegant way to simply exit out of the while loop whenever I want? Something like pressing a certain key on my keyboard would be awesome.

All While Loop Solutions on Gang of Coders

Total of 47 While Loop Solutions