---
title: "Infinite loops in PHP"
url: https://www.exakat.io/infinite-loops-in-php/
date: 2025-07-03
modified: 2025-07-05
author: "dams"
description: "Infinite loops in PHP Sometimes, they are demonized, and sometimes, they are useful. Infinite loops come in a variety of options in PHP, so let's put them neatly on a..."
categories:
  - "Code auditing"
tags:
  - "loop"
  - "recursion"
  - "trick"
image: https://www.exakat.io/wp-content/uploads/2025/07/infinite.320.jpg
word_count: 861
---

# Infinite loops in PHP

[![Going to the horizon with infinite loops](https://www.exakat.io/wp-content/uploads/2025/07/infinite.320-300x300.jpg)](https://www.exakat.io/wp-content/uploads/2025/07/infinite.320.jpg)

# Infinite loops in PHP

Sometimes, they are demonized, and sometimes, they are useful. Infinite loops come in a variety of options in PHP, so let's put them neatly on a shelf, with all theirs variations.

## Classic while (true)

To make an infinite loop, the most simple is to take a loop, and make it unconditional. The poster child for this is `while (true)`.

## Using do...while(true)

Obviously, `do...while` can do the same than `while`, but it is seldom mentionned anywhere. Indeed, `do...while` is roughly used 10 times less than `while`.

The main difference is that the loop will be executed at least one, but with infinite loop, what differences does this make?

## With for (;;)

Another big star of the infinite loops is the empty `for()`. Here, the loop uses 3 expressions, which are initialization, terminaison and increment. Usually, removing terminaison or increment lead both to infinite loop.

In the end `for (;;)` is a lot more readable.

## Using a Generator with foreach()

Let's move to `foreach()`. This one is naturally bounded: `foreach()` reads all the values in the provided source. This means that no source build on an array can be infinite: PHP will never build an infinite array before running out of memory.

So, we can use a generator. Let's see how this works:

To be honest, this is a bit cheating. There is a hidden `while(true)` hidden in the generator, which is actually creating the infinite loop. Let's see if we can do better.

## Using an inifinite Generator with foreach()

To get rid of the `while(true)` in the generator, we can rely on our good old friend `yield from`. While `yield` emits one value, `yield from` can do the same from an array, or another generator. We just need to get an infinite number of generators.

Or, we can use the same one, and pass it an argument. It is lesser known that generators can take arguments, but this works. Here, the second generator is initialized with the previous last value. This builds an infinite recursion.

Compared to the previous examples, it certainly less efficient, as the recursive calls are creation nested execution contexts. We might exhaust the memory before reaching the infinite.... (sic).

## With the PHP native InfiniteIterator

The [infiniteIterator](https://www.php.net/manual/en/class.infiniteiterator.php) loops over another iterator, which provides the values. The underlying iterator must be able to rewind, which is to start at the beginning. Here, an array is a good example.

## Infinite foreach() by itself

One trick of `foreach()` is that it works on a copy of the initial array. This is a default security to make loops finite. But, `foreach()` also ensures that all the keys of the source array are actually used.

So, when the `foreach()` works with references, it actually switches to using the original array, as it may have to updates its values. Then, it runs over all the keys, but now, the keys may be changed by writing again in the same array. The trick is to create only new keys in the source array.

And also, to start with one value in the array, at least. Otherwise, PHP skips the whole loop.

## Using goto

We could not avoid mentioning `goto` as a great tool to build infinite loops. After all, all the loops above are built on top of a hidden `goto`.

Just don't tell anyone I mentionned it, there are goto-haters in the wild.

## Using a Recursive Function

Finally, it is possible to skip entirely the loops by relying on recursive functions. Just skip the terminating condition.

We already ran into a variation of this, with the recursive generator. It was not the `yield` that was critical, but the recursion.

# Infinite loop, the sky is the limit

Infinite loops are useful, with indefinite waiting loops, such as event loops. This is when there is no limit to what may happen, so looping again and again is important.

In the other cases, it is better to know how to write an infinite loop. Not to use it, but very well to avoid running it in production.