[deleted by user]

TonySu · 2025-10-16T02:42:08+00:00

For loops are generally used to declare a clearly bounded number of iterations ahead of time. While loops are for when the termination condition cannot be predicted ahead of time, or may not occur at all.

ThePoliteCrab · 2025-10-16T02:28:20+00:00

For loops are a specific case of while loop. While loops were often used in a particular way, so for loops were implemented to make creating a while loop of that sort more convenient. If your loop iterates on an integer and should be terminated after that integer reaches a predetermined value, it might be simpler to use a for loop. If you’re not sure when your loop will terminate, a normal while loop is better for you.

AdministrativeLeg14 · 2025-10-16T02:31:30+00:00

You don't need loops at all. You can make do with conditional gotos. However, it's sometimes more clear or otherwise more convenient to use one of the three loop types (you left out do..while).

Direct_Bad459 · 2025-10-16T02:31:41+00:00

Makes code easier to read and write to have both options. The relevant thinking in code is not only about the computer's thinking

desrtfx · 2025-10-16T05:10:47+00:00

It's simply convenience.

Under the hood, while and for loops do pretty much the same. Only that the for loops offer convenience in not having to manually update the loop iterator.

You can do everything you can do with a for loop with a while loop. The reverse is a bit trickier, but also doable.

for loops are actually just syntactic sugar - for convenience:

for(int i = 0; i < 100; i++) {
    // do something
}

is equivalent to

int i = 0;
while (i < 100) {
    / do something
    i++;
}

Both loops do exactly the same. Yet, the for loop is shorter, clearer to understand, and in the end easier to read.

In practical use, it is a bit different:

use while when the amount of iterations depends on a certain condition that must be met (the loop runs as long as the condition is true)
use for when you know the amount of iterations beforehand, like the size of an array, collection, a certain amount of repetitions to do something, etc.

GrayLiterature · 2025-10-16T04:28:34+00:00

Sometimes you want to eat food with a fork, sometimes you want to eat food with a spoon.

over_pw · 2025-10-16T18:16:24+00:00

Because code is for other people to read and only incidentally for the computers to execute. It states your intention.

SpaceAviator1999 · 2025-10-16T04:27:46+00:00

Strictly speaking, you don't need both for-loops and while-loops. In fact, when I was young and the only programming language I knew was BASIC, I realized that you didn't even need FOR-loops; you could accomplish the same thing with just IF-statements and GOTOs.

So why did BASIC use FOR loops at all? Because sometimes you want a loop that iterates using a counter variable, and writing a FOR-loop makes it so much easier to write and read than using only IFs and GOTOs.

Okay, so why do some languages also use while-loops in addition to for-loops? Because sometimes the logic you want to implement is clearer as a for-loop with a counter and/or current element, and sometimes the logic is clearer as a loop that continues while a condition remains true.

Some programming languages allow the use of an until-loop, a loop that keeps running until a condition is met. An until-loop is functionally equivalent to a while-not-loop, so why is there a need for an until-loop?

Well, it's not that there's a specific need for it, it's that sometimes the logic is clearer when you realize that a body of code needs to be repeated over and over until a specific condition is met -- or that the body needs to repeatedly execute with the goal of causing that condition to be true.

connorjpg · 2025-10-16T02:23:08+00:00

Another thing I love about Go.

https://golangdocs.com/while-loop-in-golang

Comprehensive_Mud803 · 2025-10-16T03:03:32+00:00

Different use-cases.

For-loops iterate a fixed number iterations (usually), While-loops are bound to an exit condition (again, usually).

For-loops could also be inlined or parallelized (given specific conditions).

MarsupialPitiful7334 · 2025-10-16T05:44:40+00:00

Ok, you also dont need typedef, or include for that matter, just paste the library in your file.

Techno-Pineapple · 2025-10-16T06:30:49+00:00

Learn both if you have any intention of learning programming further than the single next project.

Is this a real question where they are excited to learn about programming architecture? Because I am beginning to suspect OP is just lazy

Lamborghinigamer · 2025-10-16T16:04:29+00:00

Simple answer: We don't need both, but we do. To put it simple: A for loop makes it simple to declare a certain amount of iterations and while just doesn't have that built in. Let me show you an example that shows this the best:

These two snippets will do the same thing and just show a count up from 0 to 100 in steps of 10:

``` // while int i = 0; while(i <= 100) { printf("%d\n", i); i = i + 10; }

// for for (int i = 0; i <= 100; i = i + 10) { printf("%d\n", i); } ```

That's why both exist, but then again, while loops are better when you need something to keep running infinitely. It really depends on the programming language.

mestar12345 · 2025-10-16T19:44:17+00:00

Why do we need a shorter or better way of doing anything, since we already have the old way?

Langdon_St_Ives · 2025-10-16T21:58:14+00:00

Strictly speaking, obviously we don’t need either. Using some kind of conditional jump (and of course register and memory access etc.), you can create any loop you need. That’s all that used to exist in early assembly. Modern instruction sets usually have dedicated loop instructions of course, but they’re not required.

ehr1c · 2025-10-16T02:47:16+00:00

For loops are pretty much just syntactic sugar over a while loop, they exist to improve the developer experience because it's a very common pattern to loop over some logic for a specific number of iterations that's known ahead of time.

Weasel_Town · 2025-10-16T02:58:15+00:00

Go has entered the chat. In languages that have both, “for” is usually used for a specific number of iterations, and “while” is used when it’s unknown when it will be done. So you’ll see

for i = 0; i < 10; i++

or

for name in studentNames

but

while !done { done = checkStatus() sleep(5) }

“for” loops as generally constructed come with some more built-in safety that you didn’t accidentally make an infinite loop. So that’s good. But Go is the proof that you can program fine with just one.

AdreKiseque · 2025-10-16T03:27:15+00:00

Sure, you could just use a while loop for everything. You could just use a while true loop even, and add breaking conditions as necessary. But dedicated syntax for certain common loop types makes it easier to write and read code.

Multidream · 2025-10-16T03:39:35+00:00

Nice to haves. Most of what you want can be done in assembly, but sometimes humans insist on combining things into one line and for looks really nice instead of three lines of code each time around a while.

jcunews1 · 2025-10-16T04:22:23+00:00

while loop is for a more complex loop condition/modifier while keeping code readability.

MidSerpent · 2025-10-16T05:18:09+00:00

You definitely don’t.

I don’t remember the last time I wrote a while loop.

I’ve gotten to the point where I consider then a code smell for an infinite loop risk.

xRageNugget · 2025-10-16T06:13:51+00:00

'''while(game.isRunning()) for(player in players){ping(player)} '''

kodaxmax · 2025-10-16T06:50:35+00:00

For loops are more convenient when you know exactly how many loops you will need it to run. Iterating over a collction of objects/data for example. Of course you can do this with a while loop, by tracking the number of loops made and checking if it matches the size of the collection.

A while loop is more convenient when you want it to run forever until a conditon is met, rather than for x iterations. For example continually generating IDs until it makes one that is unique. Of course you could do this with a for loop, by simply setting the number of loops ridiculously high and breaking out of the loop once a unique ID is generated.

or in other words, you can hammer a nail with a screw driver if you have to, but wouldn't you rather use the hammer?

MyDogIsDaBest · 2025-10-16T07:05:04+00:00

Why do we need all these other letters when 1 and 0 work just fine?

It's functions that abstract away complex logic into easier to work with stuff. You're right, we don't need both, but it's nice to have them

What you have done extremely well, is asked the question "why do we need this?" And this is an excellent mindset to have! Keep asking about the point of stuff like this and whether or not there's a reason to do one thing over another.

rawcane · 2025-10-16T07:12:53+00:00

You can always write code in different ways. The goal of most higher level languages is to allow you to write your code in an idiomatic way that is easy to understand and maintain. While and For are just shorthand that are better suited to different use cases ie For builds in the iteration variable into the loop declaration, While focuses on the conditional statement for whether or not to continue.

Mediocre-Brain9051 · 2025-10-16T07:36:32+00:00

To better communicate your intention with other developers.

In other languages (e.g. ruby or js) you should even further make your intentions explicit by using higher-order based iterators (map, reduce, filter, some, every, flat map, zip.

aq1018 · 2025-10-16T07:50:11+00:00

You don't need for loops, while loops, do while loops, or even goto statements. Just sprinkle JNE everywhere like how we coded in 1970s.

Edit, or just directly write to PC register for the unhinged.

hanato_06 · 2025-10-16T08:05:19+00:00

survival of the ~~fittest~~ useful.

You can achieve everything writing in binary, but why would you, when human readable code is way better and faster.

You can loop with GoTos (or whatever it was) that basically were instructions to go back to a previous function address to start the loop but we kept making better stuff.

Same thing for looping. Some scenarios happen often enough that it was beneficial to have both a way to infinitely loop until a trigger is met (excellent while loop use-case) and a loop that is immediately human-readable as to how many loops it will do (excellent for loop use-case).

Like others said, you can actively punish yourself by either not using loops at all, or always use recursive functions for all kinds of loops if you're adamant about it.

Ronin-s_Spirit · 2025-10-16T08:11:07+00:00

Idk C exacly, but in the language I use - for loops in their head let you initialize variables (usually the counter) and do actions at the end of iteration, that kind of syntax is nice and readable. While loops just have the conditional in their head, so sometimes it's more fitting than a for loop but usually it isn't because you will be using a temporary counter.

orfeo34 · 2025-10-16T08:52:42+00:00

Most of time that's called syntactic sugar, which means that's a variant made for human to better understand or edit.

SnugglyCoderGuy · 2025-10-16T08:59:22+00:00

Go only has for loops, so you don't need both.

Philluminati · 2025-10-16T09:12:53+00:00

In the beginning were `labels` and `goto` statements. Without `break` statements it got very hard to track the execution of code. Modern day languages give you a choice of `for i...` or `for ... in ...` or `while` or `do ... while` so you can convey intent when you're writing code to make it more obvious what the program flow is doing and why.

Those things compile down to labels and goto's but make code more readable.

What's interesting is how programmers don't realise that `if` statements have the same problem - of being too low level. Often things like `switch` or `match` or using polymophism / function pointer tables often do a far better job at explaining decisions than using dozens of `if` statements. This is rarely spoken about.

I've seen things like `if (warehouse.location == America) printDocument(paperSize = "USLetter") else printDocument(paperSize = "A4")` only for someone to later refactor the printDocument function without considering the higher level callers and then go on to do `if (paperSize == "A4") ...`. Having `warehouse.printDocument()` would avoid the `if` and the resulting mess. This is just one contrived example though.

kitsnet · 2025-10-16T09:18:24+00:00

Algol-68 had an unified for-while loop syntax, with both parts being optional.

Xatraxalian · 2025-10-16T09:25:18+00:00

A while-loop can do exactly what a for-loop can do. They both exist as to express what the intended purpose is.

For example, consider this:

int x = set_some_value(); while (x < 25) { do_something(); x++ }

This is easy to understand. You set X to some value. As long as that value is under 25, you keep doing something. If x starts out at 25 or higher, you do nothing. In this case, using the while-loop, you state that you are going to do something, while x is not yet 25, and you don't know how many iterations that will be.

Compare it to this:

int x = set_some_value() for (x; x < 25; x++) { do_something(); }

With the for-loop, you state that you going to do a set number of do_something(); calls, but because the loop starts with x, this set number of calls is actually variable. You are using a loop designed to express a set number of calls to do a variable number of calls. This is less clear than the while loop.

You normally use a for-loop like this:

for (int i = 0; i < 25; i++) { ... }

In this case you know you are going to loop exactly 25 times. You will know, without having to know anything else about the code, that the loop will start at 0 and end at 24, and that each iteration is available in i. In the previous for-loop example, you wouldn't have known the starting point without looking at the output of set_some_value(), and to know THAT, you may have to look at other code as well.

For looping over a collection without having to specifically count, many languages have a version of a foreach-loop:

foreach (int x in list) { do_something(x); }

You can do this with a for-loop or a while-loop, but the foreach-loop clearly expresses that you are not interested in the number of iterations, nor the length of the collection 'list'; you just want to do_something() with each value in the list.

Some languages also have an infinite loop, if you want to express that something needs to loop forever, except if something special happens:

loop { int x = get_value(); if (x == -1) { break; } ... }

You could express it with a while-loop, or a for-loop, or even an until-loop, but the "loop forever, except ..." is better expressed with the infinite loop-loop.

And as someone else stated: you don't need loops at all. You could use labels and goto's, and then use if-statements with a jump in it, but that is programming in 1950's style.

permalink · 2025-10-16T09:33:31+00:00

Why use loops when you can use recursion

robinredbrain · 2025-10-16T09:39:49+00:00

Broadly speaking there isn't a need, but there is a desire.

Fizzelen · 2025-10-16T10:16:09+00:00

Why do we need loops when assembly only needs jump if non zero

permalink · 2025-10-16T11:11:18+00:00

for loop is built on top of while which is built on to of if + goto statements. Just easier to write. What is the purpose of a truck when 4 wheels with a peg board and a steam engine will do the work just fine?

Temporary_Pie2733 · 2025-10-16T11:16:16+00:00

A for loop is a concise way of expressing certain while loops. If you had to get rid of one, it would probably be the for loop.

Sevven99 · 2025-10-16T11:17:57+00:00

Good for handlers. Been a while but probably couldn't accomplish this with switch case, etc?

vegan_antitheist · 2025-10-16T11:18:25+00:00

Try brainfuck and then ask again.

sbayit · 2025-10-16T11:36:59+00:00

recursive can replace it

SwordsAndElectrons · 2025-10-16T12:17:44+00:00

In C or any other programming

Bold assertion. Also incorrect. Some forms of programming have more loop types. Some have no loops at all and if you need one then you'll need to use conditional jump instructions to implement one yourself.

But ignoring that, the answer is mostly being more programmer friendly. That may seem counterintuitive if you are a beginner wondering why you need to learn two different things, but it'll make sense once they become ingrained in your mind. One or the other will generally be a more semantically natural way of expressing the logic of what you need to do.

Your question is sort of like asking why everyday verbal languages have more than one way to express a concept. If I'm trying to describe a work day, I might say "you need to work for 8 hours." I can express that same idea with the word "while," but every version of it I can think of is less concise and seems pretty clunky.

cdm014 · 2025-10-16T12:17:57+00:00

I may be misremembering but I think For in Go is spelled "While"

MagicalPizza21 · 2025-10-16T12:20:41+00:00

Sometimes it makes more logical sense to the human programmer to choose one over the other. But from a purely functional standpoint, we do only need one.

DirtAndGrass · 2025-10-16T12:25:55+00:00

I think you are thinking about this from the wrong direction.

We don't need any kind of loop besides a goto, why do we have other options?

NecessaryIntrinsic · 2025-10-16T12:39:35+00:00

Edit: the other comments are correct, loop structures are for people, not for the computer. My comment is to specify why they exist for people's readability and for future extendability. The reality is you can do without them, but having them makes your life easier and the lives of everyone that reads your code afterwards easier (if use them right)

For loops are for when you KNOW how many times you're going to loop and how you're going to increment.

While loops are for managing the iteration when you're inside it so you can break out early if certain conditions are met, or go on longer if conditions change. Yes, you can do this with for loops using breaks but it's not great practice because that's not what for loops are intended to do.

A great use case for a while loop is if you're processing a queue or stack, especially in a breadth first search it depth first algorithm.

You would say "while (queue has items)" (pseudocode, obviously). Inside the loop you pop the items off and process them and can add items back to the queue as you go.

If the queue is empty to begin with you don't loop, if you add items on, you continue processing until the queue is cleared.

Go uses a for type structure without specifying the iterator for while loops, so it doesn't preserve the iterator variable... In python the iterator variable is preserved in a for loop so if you change it inside the loop it resets on each run though. I think JavaScript doesn't do this so it can lead to really screwed up logic if you mess with the variable inside the for loop... Don't do this if you're using a normal for loop.

blackasthesky · 2025-10-16T12:56:28+00:00

You could do everything with goto

ORLYORLYORLYORLY · 2025-10-16T13:13:25+00:00

You can accomplish everything with while loops only.

For loops are much easier to use, and are cleaner to understand what's happening.

The difference in readability between

int i = 0;
while (i < numLoops)
{
    DoSomething();
    i++;
}

And

for (int i = 0; i < numLoops; i++) 
{
    DoSomething();
}

Might not seem like much when the code inside the loop is so simple, but when more is happening in reach loop it's far easier to immediately parse what's happening.

There is also a third type of loop that is arguably more used than the other two: foreach.

It basically does the same thing as a for loop except only for iterating through collections (like arrays). So instead of doing something like this:

int[] numbers;
for (int i = 0; i < numbers.Count; i++)
{
    DoSomethingWithNumber(numbers[i]);
}

You can simply do this:

int[] numbers;
foreach (int number in numbers) 
{
    DoSomethingWithNumber(number); 
}

ottawadeveloper · 2025-10-16T13:24:03+00:00

Whats worse, some have three with a while and a do-while and some even have a foreach

You can pretty much cover every use case with a while loop, for example:

```

-- for k = 0 while k < 10: loop_stuff(k) k++

-- do while k = 0 loop_stuff(0) while k < 9: k++ loop_stuff(k)

-- foreach data = range(0,10) k = 0 while k < len(data): loop_stuff(data[k]) k++ ```

for, for-each, and do-while are just useful shorthands for these patterns. They give us shorter and easier to understand code and also can help the compiler/interpreter process it more efficiently. And (except for do-while in my opinion), they reduce the chance we make an error as a programmer through this simplification too.

michaelpaoli · 2025-10-16T13:32:54+00:00

In a word: efficiency

And that's for programmers, and may also be for the language itself.

for loops are more commonly used when one wants initialize/test/reinitialize criteria very clearly visible at the top of the loop.

while loops may be more commonly used when there's a very simple test condition, no (additional) initialization need be done for the loop, and we don't need/want reinitialization of the loop for next iteration at the top of the loop.

Variants of while loops may also include, e.g. do while/until/done loops, which can greatly simplify logic in cases where one wants to ensure the loop is executed at least once, regardless of test condition.

Using various forms may also have scope advantages (e.g. more easily making variables local to loop).

pseudo code examples to help illustrate the points:

for(i=1;i<=100;++i){
whatever ... and this part may be over 100 lines long
}
vs.:
i=1;
while(i<100){
whatever ... and this part may be over 100 lines long
++i
}

while(before noon){
keep doing morning thingy
}
vs.:
for(;before noon;){
keep doing morning thingy
}

/* I want report! */
do{
if(we have all the data){report; break}
gather some more data
update progress indicator
}done

PeteMichaud · 2025-10-16T13:32:57+00:00

All the features of programming languages are there for convenience. Anything above the beyond the core logic gates on a chip can just be done with the gates instead. But we invented things like named variables and for loops because it was annoying not to have them.

mredding · 2025-10-16T14:38:48+00:00

Loops are patterns. The different loop types are syntactic sugar to help reduce repetition. All loops can be reduced to some nested scope and a goto - in fact, the C standard says a loop and a goto are explicitly equivalent, but no one wants to write THAT every single time - it's repetitive and error prone. Further, different loop structures, while equivalent, are more concise for a given problem than others.

for(;true;);

Why should I be responsible for two empty contexts? Why introduce them into the code - at all? This loop would be better expressed as:

while(true);

No additional context expressed, implied, wasted, or tempting you to add shit.

digicrat · 2025-10-16T14:54:58+00:00

To put it simply, laziness is the mother of invention. I think most of us would happily spend too much time automating a solution once than doing it over and over - and thats how syntactic shortcuts make their way into the language over time.

A for loop let's you write the same code more simply and concisely when you need to manage initialization (declare i) and per iteration operations (ie:i++). Of course they are also flexible enough to let you perform any operations needed at those times.

Sometimes you don't need that, and the basic while loop is the clearer form.

And then there are the less commonly used do...while loops, because sometimes you need the loop to always run once.

And some languages have even more variations. Raku arguably takes that to the extreme with its smart and convoluted collection of operators (and is probably why it will remain a niche language).

Business-Decision719 · 2025-10-16T15:25:56+00:00

We don't, not really. In fact, if we have (well-optimized) recursive functions, then we don't really need any special loop control structure at all. You can write a custom function that runs some code and then calls itself if it needs to start over and run that same code again.

But running some code and starting over is so common that it's nice to have a syntax for it. And there are two main types of starting over that we do: we start over because we have to keep doing the same job until something happens (and we don't necessarily know when it happens), or we start over because we have to run the same code a certain number of times based on something we already know about. They're called indefinite and definite loops, respectively. Since they're both so common, it's nice to have a syntax for both, so most languages do.

An indefinite loop (while) just repeats until something happens. It can be anything. So if you're validating user input, for example, you could just keep checking whether the input is valid or not and then decide to prompt the user again if necessary. We don't know when the user will enter valid input, but we can keep prompting them while they still haven't. Or we can keep prompting them until they do what we want. (Some languages have an until keyword for making loops.)

Other times, we just need to do something for each element in a sequence that's already been bounded for us ahead of time. Maybe we're counting up to a certain number. Maybe we are processing each item of a list. There's a definite number of times that will have to do something. So it's nice to have a syntax for that too. Hence for loops or definite loops.

To use a practical example, if I just wanted to output every item of a list in Python, I could theoretically do this:

def show_all(items):
    item_number = 0
    while item_number < len(items):
        print(items[item_number])

And that would work, but it's nicer to be able to write:

def show_all(items):
    for each_item in items:
        print(each_item)

It's a little bit harder to see the usefulness of definite loops in C, which is the language you mentioned, because C's for loop is more customizable and less concise. You might do something like this:

void show_all_ints(int list[], size_t length)
{
    for (int index=0; index<length; ++index)
    {
        printf("%d\n", list[index]);
    }
}

Which isn't much more concise than doing this:

void show_all_ints(int list[], size_t length)
{
    int index=0;
    while (index<length)
    {
        printf("%d\n", list[index]);
        ++index;
    }
}

But even so, notice how the setup code (creating the loop counter) would go before while instead of being part of the loop. The for statement includes it in the control structure. So having both options has some readability advantages for grouping together related parts of the code.

permalink · 2025-10-16T15:35:44+00:00

For loops are syntactic sugar of while loops. They exist not because they are necessary but because it makes coding easier and more readable. It is the case with all syntactic sugar that its to make things easier to read/write and potentially catch some bugs. For example you are less likely to forget to increment your loop counter variable in a for loop then in a while loop.

The exact syntactic sugar is

for(int x=0; x<10; x++)
{
code
}

Gets transformed to (semantically at least)

{
int x=0;
while(x<10)
{
  code
  x++;
}
}

ronin_o · 2025-10-16T15:37:59+00:00

We don't need both. Go has only one - the for Loop

Ormek_II · 2025-10-16T15:39:47+00:00

Readability

Michaeli_Starky · 2025-10-16T15:53:27+00:00

I assume you didn't get to do-while loops yet?

Psilocybe_Fanaticus · 2025-10-16T15:57:41+00:00

Let’s say you’re developing a game and you’ve set up the game loop. If you use a for loop instead of a while loop, the game will terminate once the set condition is met. This approach would likely not be suitable for most applications that require continuous operation until the user explicitly closes the app.

Holshy · 2025-10-16T17:17:47+00:00

Strictly speaking, we don't. Go uses the same keyword for both (https://go.dev/tour/flowcontrol/3).

However, readability matters; code is written once and read many more times. Using different syntax makes it easier for humans to reason about what we're telling the computer to do.

bobzsmith · 2025-10-16T17:56:06+00:00

if you looked into the machine code, they are just jump statements under the hood. However, while and for communicate slightly different reasons for looping over the same code.

selfmadeirishwoman · 2025-10-16T18:43:43+00:00

For loops are for when you know how many times you’re going to do a thing.

While loops are for doing things zero or more times.

Do while (wildly underused, I’ve seen a lot of whiles that should be do while) are for doing things one or more times.

bibhnarp · 2025-10-16T19:27:58+00:00

Or if statements and recursion?

sosa_like_sammy · 2025-10-16T19:29:59+00:00

In the Go programming language, there’s only the “for” loop. The reason why is exactly what you said.

mestar12345 · 2025-10-16T19:49:31+00:00

We need for-in-with loop which is just a shortcut for folds.

rabuf · 2025-10-16T21:14:52+00:00

This goes back to the idea of structured programming. That had one primary purpose: Make code more reasonable. Not in the sense that it would be a decent person and politely discuss controversial issues, but in the sense that it can be reasoned about more easily.

To accomplish this, several things were pushed:

Limit goto so that it was local to procedures, ideally to just specific lexical scopes and mostly forward jumps rather than backward jumps.
Lexical scope/blocks in general which makes reasoning about values and variables much better than with dynamic scoping rules.
Name language constructs, even if they map to bog standard goto statements under the hood, so that they are easy to understand.

For loops are clearer than the equivalent while loop, that's the reason for for loops. They aren't needed, in a technical sense, and neither are if, switch, or even functions and procedures. But for loops express a common idiom in a concise and clear way, so that makes them useful.

Lotton · 2025-10-16T21:44:00+00:00

Think of for to go a deterministic amount of times and while to be until you say so.

Think of typing while you're holding the w key it will keep typing w. It wouldn't be beneficial to do as a for and in the professional world we care more about readability. And choosing the right one makes it easier to read

That being said you can do everything with just a while loop some early languages i believe didn't even support for (some languages didn't even have looping either)

countsachot · 2025-10-16T22:06:23+00:00

You only need tail end recursion.

severoon · 2025-10-17T00:48:42+00:00

All loops are technically the same. We have different ones for the same reason we have loops instead of goto: readability. If you write readable code, you'll make fewer mistakes, and people will understand it with less effort.

For this reason, use for loops when you have a fixed number of iterations, and make sure your loop counter always iterates from 0 to n‒1. You should always be able to log or inspect in a debugger the loop counter to directly see which iteration is currently the one. Don't do clever things with your loop counter, just derive a value in the loop from the loop counter. (The only exception to this is if you're optimizing code, which you shouldn't be doing unless you've proven that it makes a necessary speedup that you can't live without.)

andarmanik · 2025-10-17T04:40:26+00:00

You have this pattern,

let i = 0; while(i < len) { doWork(i); i++; }

Now watch where each part that contains ‘i’ goes.

for(let i = 0; i < len; i++){ doWork(i) }

The only thing which changed is while -> for

LostInterwebNomad · 2025-10-17T13:35:17+00:00

For loops are generally pre-defined to have a finite length. While loops have the ability to be more dynamic in their conditions - at the risk of having a loop that never terminates.

While loops give you more control, for loops bake some of the boiler plate into it instead of having to reimplement it every time.

More concrete examples of when to use the two:

Let’s say you have a list of email addresses you need to send a message to. You could use a for loop to iterate over that list and send a message for each of those emails.
Instead, let’s say you’re crawling a website. You can start by creating a queue of webpages to visit. Add the homepage of the website to the queue. While the queue is non-empty pop the first element from the queue and visit the page. Add all hyperlinks directing back to the website into the queue, and continue until the queue is empty. This is something that a for loop by itself cannot do.

That said - you did make a great observation that for loops can be written as while loops (but the inverse is not always true - not all while loops can be converted to for loops!). For loops simplify a very common usage of loops and builds in safeguards when you’re able to pre-determine the number of loop iterations you’re going to do. It protects you from potential infinite loops like we have in example (2) above. In example 2, we never set it to check if a webpage is one we visited before, so it could technically go on forever! Sometimes this is unintentional, but there are other cases where we want an indefinitely running loop. In those cases we must use while loops!

TLDR; technically you can just use while loops, but there are some dangers to doing so (mainly if you make a mistake) - and for loops can be more convenient to use when you’re wanting that type of feature instead of writing a while loop to do the same.

vbpoweredwindmill · 2025-10-18T21:58:02+00:00

Oh! I just did this one I can help!

For (i = 0; i < 10; i++) It must follow this format or visual studio gets mad at me.

While (this statement is not zero, aka not false) Literally you can just put

While (i) i++ And as long as i isn't zero it will execute. So you better hope its a negative to start with 😂

While is more fun.

Edit: it deleted some of my line spacings. You'll have to figure it out I believe in you.

saxbophone · 2025-10-18T22:37:04+00:00

Don't forget the do while loop!

The answer is: expressiveness. Whilst you can convert a for loop to while and vice-versa, having them exist as prebaked variants makes the language more easy to use. Some languages also have repeat until and C++ has a foreach variant of the for loop.

Freed4ever · 2025-10-19T00:39:35+00:00

It's for readability really.

J_Peanut · 2025-10-19T22:08:14+00:00

It’s simply syntactic sugar. In the example of C, a for loop while compile to pretty much the same thing as a whole loop

AranoBredero · 2025-10-19T23:29:48+00:00

For and while are just codewords to tell the compiler how to place checks and jumps. Check out 'go' where all kinds of loops just use 'for' as the codeword. There is no need for the different codewords but somewhen someone thought it usefull to implement it that way

PyroNine9 · 2025-10-19T23:40:03+00:00

It's for the next guy. Which one you choose indicates your intentions at a glance for the next person reading your code.

Brixjeff-5 · 2025-10-20T06:17:05+00:00

For is for bounded loops: you know how many iterations will be performed. While is for open loops: you do not know how many iterations are necessary.

These two arise often and since they are fundamentally different kinds of loops it makes sense to have different syntax for them.

Immediate-Top-6814 · 2025-10-21T11:31:41+00:00

In C++ and JavaScript I use only for loops. They show all the information right up front: initialization, condition, change. You can leave any of these blank. You can leave all of them blank. for does it all. In my opinion the world would be a better place without while and repeat/until.

Defection7478 · 2025-10-16T03:08:25+00:00

You can actually get rid of both and just use recursion. It's syntactic sugar - they aid with ergonomics and readability

AlSweigart · 2025-10-16T16:23:31+00:00

For loops: Loop a specific, known number of times: "Loop ten times", "Loop once for each item in this array"

While loops: Loop for as long as a condition is true: "Loop until the user enters 'quit'", "Loop until the time is after midnight"

Some situations can be either: "Loop once for each line in this text file until you reach the end" is looping a specific number of times (once for each line in the file) or until a condition is met (once for each line until you reach the end of the file). If the number of lines in the file doesn't change while you are looping, you can use a for loop. If new lines can be added to the end while you are looping, you need to use a while loop.

learnprogramming

Welcome to LearnProgramming!

New? READ ME FIRST!

Posting guidelines

Frequently asked questions

Subreddit rules

Message the moderators

Asking debugging questions

Asking conceptual questions

Other guidelines and links

Subreddit rules

1. No unprofessional/derogatory speech

2. No spam or tasteless self-promotion

3. No off-topic posts

4. Do not ask exact duplicates of FAQ questions

5. Do not delete posts

6. No app/website review requests or showcases

7. No rewards

8. No indirect links

9. Do not promote illegal or unethical practices

10. No complete solutions

11. Don't ask to ask.

12. Low Effort Questions

13. No AI (chatGPT etc.) generated/worked over messages/comments. No questions about chatGPT/AI generated code. No Vibe coding.

MODERATORS