In PHP 7.1, "iterable" is a pseudo-type that represents either an array or an object implementing the Traversable interface. 1. It allows functions to accept any loopable data structure, enhancing flexibility. 2. Developers can use it in parameter and return type declarations. 3. It supports arrays and Traversable objects interchangeably. 4. This pseudo-type enables abstraction, loose coupling, and easier switching between data sources. 5. Common mistakes include passing non-iterable values or assuming all objects are traversable. 6. The is_iterable() function checks if a variable is iterable. Using iterable instead of array broadens function compatibility while maintaining iteration capability.

In PHP 7.1, there isn't a formal type called "iterable" — but it is treated as a pseudo-type in the documentation and type system. The iterable pseudo-type is used to indicate that a function or method can accept either an array or an object implementing the Traversable interface (like most built-in iterators). This gives developers more flexibility when defining functions that work with data sets without enforcing a specific structure.

What does iterable mean in PHP?

The word “iterable” refers to anything you can loop through — like arrays or objects that implement the Traversable interface. In PHP, this includes both built-in classes like ArrayIterator and user-defined iterators.

So, when you see iterable used in a function parameter or return type declaration, it means the value must be either:

• An array
• An instance of a class implementing Traversable

This came into play more clearly starting in PHP 7.1 because that’s when iterable was added as a first-class pseudo-type for use in type declarations.

Why use iterable instead of array?

Using iterable instead of just array opens up your functions to more flexibility. If you restrict a function to only accept arrays, you’re excluding any custom or object-based iteration logic that could be useful.

For example:

function processItems(iterable $items) {
    foreach ($items as $item) {
        // process item
    }
}

Here, $items can be an array or any traversable object. That makes the function reusable across different parts of your codebase or libraries that might use iterators for lazy loading or filtering.

Some benefits:

• Supports better abstraction by allowing any kind of collection.
• Makes it easier to switch between data sources (e.g., arrays vs database results wrapped in iterators).
• Encourages loose coupling between components.

How to declare iterable types

From PHP 7.1 onward, you can use iterable as a type hint in both parameters and return types.

Parameter type declaration

function logValues(iterable $values) {
    foreach ($values as $value) {
        echo $value . "\n";
    }
}

Calling this function with either an array or a traversable object will work:

logValues([1, 2, 3]); // works
logValues(new ArrayIterator(['a', 'b'])); // also works

Return type declaration

You can also specify that a function returns something iterable:

function getLines(): iterable {
    yield "Line 1";
    yield "Line 2";
}

This function uses generators (yield) which return a Generator object — a type of Traversable.

Common mistakes and gotchas

There are a few common issues people run into when using iterable:

• Passing non-iterable values: If you try to pass a string or integer where an iterable is expected, PHP will throw a TypeError.
• Mixing with other type hints: You can’t combine iterable with union types unless you're using PHP 8.0 with explicit syntax like array|Traversable.
• Assuming all objects are traversable: Just because something is an object doesn’t mean it implements Traversable. Trying to iterate over a plain object without proper implementation will cause errors.

Also, remember:

• is_iterable() is a helpful function to check if a variable is iterable.
• If you need strict array behavior, stick with array as a type hint instead of iterable.

That's the core idea behind the iterable pseudo-type in PHP 7.1. It's not complicated, but it adds a level of flexibility that's really useful in larger applications or libraries.

The above is the detailed content of What are iterable pseudo-type in PHP 7.1?. For more information, please follow other related articles on the PHP Chinese website!